def do_loop_analysis(self):
entries = [e for (e, tag, nm, args) in self.entries]
self.loop_data = {}
graph = self.mk_node_graph()
comps = logic.tarjan(graph, entries)
self.tarjan_order = []
for (head, tail) in comps:
self.tarjan_order.append(head)
self.tarjan_order.extend(tail)
if not tail and head not in graph[head]:
continue
trace('Loop (%d, %s)' % (head, tail))
loop_set = set(tail)
loop_set.add(head)
r = self.force_single_loop_return(head, loop_set)
if r != None:
tail.append(r)
loop_set.add(r)
self.tarjan_order.append(r)
self.compute_preds()
self.loop_data[head] = ('Head', loop_set)
for t in tail:
self.loop_data[t] = ('Mem', head)
# put this in first-to-last order.
self.tarjan_order.reverse()
def do_loop_analysis(self):
entries = [e for (e, tag, nm, args) in self.entries]
self.loop_data = {}
graph = self.mk_node_graph()
comps = logic.tarjan(graph, entries)
self.tarjan_order = []
for (head, tail) in comps:
self.tarjan_order.append(head)
self.tarjan_order.extend(tail)
if not tail and head not in graph[head]:
continue
trace("Loop (%d, %s)" % (head, tail))
loop_set = set(tail)
loop_set.add(head)
r = self.force_single_loop_return(head, loop_set)
if r != None:
tail.append(r)
loop_set.add(r)
self.tarjan_order.append(r)
self.compute_preds()
self.loop_data[head] = ("Head", loop_set)
for t in tail:
self.loop_data[t] = ("Mem", head)
# put this in first-to-last order.
self.tarjan_order.reverse()
def get_loops_within (ns): graph = dict ([(n, p.nodes[n].get_conts ()) for n in ns]) graph['ENTRYPOINT'] = list (ns) for n in ns: for c in p.nodes[n].get_conts (): graph.setdefault (c, []) res = logic.tarjan (graph, ['ENTRYPOINT']) return [(head, tail) for (head, tail) in res if tail]
def loop_inner_loops(p, head):
loop_set_all = p.loop_body(head)
loop_set = set(loop_set_all) - set([head])
graph = dict([(n, [c for c in p.nodes[n].get_conts() if c in loop_set]) for n in loop_set_all])
comps = logic.tarjan(graph, [head])
assert sum([1 + len(t) for (_, t) in comps]) == len(loop_set_all)
return [comp for comp in comps if comp[1]]
def loop_body_inner_loops(p, head, loop_body):
loop_set_all = set(loop_body)
loop_set = loop_set_all - set([head])
graph = dict([(n, [c for c in p.nodes[n].get_conts() if c in loop_set])
for n in loop_set_all])
comps = logic.tarjan(graph, [head])
assert sum([1 + len(t) for (_, t) in comps]) == len(loop_set_all)
return [comp for comp in comps if comp[1]]
def get_graph_loops(nodes):
graph = dict([(n, [c for c in nodes[n].get_conts() if type(c) != str]) for n in nodes])
graph["ENTRY"] = list(nodes)
comps = logic.tarjan(graph, ["ENTRY"])
comp_ids = {}
for (head, tail) in comps:
comp_ids[head] = head
for n in tail:
comp_ids[n] = head
loops = set([(n, n2) for n in graph for n2 in graph[n] if comp_ids[n] == comp_ids[n2]])
return loops
def check_no_inner_loop (head, tail, graph, p):
graph = dict ([(x, [y for y in graph[x] if y in tail])
for x in [head] + tail])
comps2 = logic.tarjan (graph, [head])
assert sum([1 + len (t) for (_, t) in comps2]) == 1 + len (tail)
subs = [comp2 for comp2 in comps2 if comp2[1]]
if subs:
trace ('Aborting %s, complex loop' % p.name)
trace (' sub-loops %s of %s' % (subs, (head, tail)))
for (h, _) in subs:
trace (' head %d tagged %s' % (h, p.node_tags[h]))
raise Abort ()
def get_graph_loops(nodes):
graph = dict([(n, [c for c in nodes[n].get_conts() if type(c) != str])
for n in nodes])
graph['ENTRY'] = list(nodes)
comps = logic.tarjan(graph, ['ENTRY'])
comp_ids = {}
for (head, tail) in comps:
comp_ids[head] = head
for n in tail:
comp_ids[n] = head
loops = set([(n, n2) for n in graph for n2 in graph[n]
if comp_ids[n] == comp_ids[n2]])
return loops
def get_recursion_identifiers(funs, extra_unfolds=[]):
idents = {}
del recursion_trace[:]
graph = dict([(f, list(functions[f].function_calls())) for f in functions])
fs = funs
fs2 = set()
while fs2 != fs:
fs2 = fs
fs = set.union(
set([f for f in graph if [f2 for f2 in graph[f] if f2 in fs2]]),
set([f2 for f in fs2 for f2 in graph[f]]), fs2)
graph = dict([(f, graph[f]) for f in fs])
entries = list(fs - set([f2 for f in graph for f2 in graph[f]]))
comps = logic.tarjan(graph, entries)
for (head, tail) in comps:
if tail or head in graph[head]:
group = [head] + list(tail)
idents2 = compute_recursion_idents(group, extra_unfolds)
idents.update(idents2)
return idents
def get_recursion_identifiers (funs, extra_unfolds = []):
idents = {}
del recursion_trace[:]
graph = dict ([(f, list (functions[f].function_calls ()))
for f in functions])
fs = funs
fs2 = set ()
while fs2 != fs:
fs2 = fs
fs = set.union (set ([f for f in graph if [f2 for f2 in graph[f]
if f2 in fs2]]),
set ([f2 for f in fs2 for f2 in graph[f]]), fs2)
graph = dict ([(f, graph[f]) for f in fs])
entries = list (fs - set ([f2 for f in graph for f2 in graph[f]]))
comps = logic.tarjan (graph, entries)
for (head, tail) in comps:
if tail or head in graph[head]:
group = [head] + list (tail)
idents2 = compute_recursion_idents (group,
extra_unfolds)
idents.update (idents2)
return idents
def do_loop_analysis (self,skipInnerLoopCheck=False):
entries = [e for (e, tag, nm, args) in self.entries]
self.loop_data = {}
self.loop_splittables = {}
graph = dict([(n, [c for c in self.nodes[n].get_conts ()
if type (c) != str])
for n in self.nodes])
comps = logic.tarjan (graph, entries)
self.tarjan_order = []
for (head, tail) in comps:
self.tarjan_order.append (head)
self.tarjan_order.extend (tail)
if not tail and head not in graph[head]:
continue
trace ('Loop (%d, %s)' % (head, tail))
if not skipInnerLoopCheck:
check_no_inner_loop (head, tail, graph, self)
loop_set = set (tail)
loop_set.add (head)
r = self.force_single_loop_return (head, loop_set)
if r != None:
tail.append (r)
loop_set.add (r)
self.tarjan_order.append (r)
self.compute_preds ()
self.loop_data[head] = ('Head', loop_set)
for t in tail:
self.loop_data[t] = ('Mem', head)
self.add_loop_splittables (head, loop_set)
# put this in first-to-last order.
self.tarjan_order.reverse ()
def immediate_stack_bounds_loop(immed):
graph = dict([(k, immed[k][1].keys()) for k in immed])
graph['ENTRY'] = list(immed)
comps = logic.tarjan(graph, ['ENTRY'])
rec_comps = [[x] + y for (x, y) in comps if y]
return rec_comps
def immediate_stack_bounds_loop (immed): graph = dict ([(k, immed[k][1].keys ()) for k in immed]) graph['ENTRY'] = list (immed) comps = logic.tarjan (graph, ['ENTRY']) rec_comps = [[x] + y for (x, y) in comps if y] return rec_comps
