def get_loop_virtual_stack_analysis (p, tag):
"""computes variable liveness etc analyses with stack slots treated
as virtual variables."""
cache_key = ('loop_stack_analysis', tag)
if cache_key in p.cached_analysis:
return p.cached_analysis[cache_key]
(ent, fname, _) = p.get_entry_details (tag)
(_, sp) = get_stack_sp (p, tag)
cc = get_asm_calling_convention (fname)
rets = list (set ([ptr for arg in cc['rets']
for (ptr, _) in stack_virtualise_expr (arg, None)[0]]))
rets = [adjust_ret_ptr (ret) for ret in rets]
renames = p.entry_exit_renames (tags = [tag])
r = renames[tag + '_OUT']
rets = [syntax.rename_expr (ret, r) for ret in rets]
ns = [n for n in p.nodes if p.node_tags[n][0] == tag]
ptrs = list (set ([(n, ptr) for n in ns
for ptr in (stack_virtualise_node (p.nodes[n], None))[0]]))
ptrs += [(n, (sp, 'StackPointer')) for n in ns if p.loop_id (n)]
offs = get_ptr_offsets (p, [(n, ptr) for (n, (ptr, _)) in ptrs],
[(ent, sp, 'stack')]
+ [(ent, ptr, 'indirect_ret') for ptr in rets[:1]])
ptr_offs = {}
rep_offs = {}
upd_offsets = {}
for ((n, ptr), off, k) in offs:
ptr_offs.setdefault (n, {})
rep_offs.setdefault (n, {})
ptr_offs[n][ptr] = (k, off)
rep_offs[n][k] = (ptr, - off)
for (n, (ptr, kind)) in ptrs:
if kind == 'MemUpdate' and p.loop_id (n):
loop = p.loop_id (n)
(k, off) = ptr_offs[n][ptr]
upd_offsets.setdefault (loop, set ())
upd_offsets[loop].add ((k, off))
loc_offs = mk_get_local_offs (p, tag, rep_offs)
adj_nodes = {}
for n in ns:
(_, node) = stack_virtualise_node (p.nodes[n],
ptr_offs.get (n, {}))
adj_nodes[n] = node
# finally do analysis on this collection of nodes
preds = dict (p.preds)
preds['Ret'] = [n for n in preds['Ret'] if p.node_tags[n][0] == tag]
preds['Err'] = [n for n in preds['Err'] if p.node_tags[n][0] == tag]
vds = logic.compute_var_deps (adj_nodes,
adjusted_var_dep_outputs (p), preds)
result = (vds, adj_nodes, loc_offs, upd_offsets)
p.cached_analysis[cache_key] = result
return result
def compute_var_dependencies (self): var_deps = logic.compute_var_deps (self.nodes, self.var_dep_outputs, self.preds) var_deps2 = dict ([(n, dict ([(v, None) for v in var_deps.get (n, [])])) for n in self.nodes]) return var_deps2
def rename_vars (function):
preds = logic.compute_preds (function.nodes)
var_deps = logic.compute_var_deps (function.nodes,
lambda x: function.outputs, preds)
vs = set ()
dont_rename_vs = set ()
for n in var_deps:
rev_renames = {}
for (v, t) in var_deps[n]:
v2 = recommended_rename (v)
rev_renames.setdefault (v2, [])
rev_renames[v2].append ((v, t))
vs.add ((v, t))
for (v2, vlist) in rev_renames.iteritems ():
if len (vlist) > 1:
dont_rename_vs.update (vlist)
renames = dict ([(v, recommended_rename (v)) for (v, t) in vs
if (v, t) not in dont_rename_vs])
f = function
f.inputs = [(renames.get (v, v), t) for (v, t) in f.inputs]
f.outputs = [(renames.get (v, v), t) for (v, t) in f.outputs]
for n in f.nodes:
f.nodes[n] = syntax.copy_rename (f.nodes[n], (renames, {}))
def compute_var_dependencies(self):
if "var_dependencies" in self.cached_analysis:
return self.cached_analysis["var_dependencies"]
var_deps = logic.compute_var_deps(self.nodes, self.var_dep_outputs, self.preds)
var_deps2 = dict([(n, dict([(v, None) for v in var_deps.get(n, [])])) for n in self.nodes])
self.cached_analysis["var_dependencies"] = var_deps2
return var_deps2
def rename_vars(function):
preds = logic.compute_preds(function.nodes)
var_deps = logic.compute_var_deps(function.nodes,
lambda x: function.outputs, preds)
vs = set()
dont_rename_vs = set()
for n in var_deps:
rev_renames = {}
for (v, t) in var_deps[n]:
v2 = recommended_rename(v)
rev_renames.setdefault(v2, [])
rev_renames[v2].append((v, t))
vs.add((v, t))
for (v2, vlist) in rev_renames.iteritems():
if len(vlist) > 1:
dont_rename_vs.update(vlist)
renames = dict([(v, recommended_rename(v)) for (v, t) in vs
if (v, t) not in dont_rename_vs])
f = function
f.inputs = [(renames.get(v, v), t) for (v, t) in f.inputs]
f.outputs = [(renames.get(v, v), t) for (v, t) in f.outputs]
for n in f.nodes:
f.nodes[n] = syntax.copy_rename(f.nodes[n], (renames, {}))
def compute_var_dependencies(self):
if 'var_dependencies' in self.cached_analysis:
return self.cached_analysis['var_dependencies']
var_deps = logic.compute_var_deps(self.nodes, self.var_dep_outputs,
self.preds)
var_deps2 = dict([(n, dict([(v, None) for v in var_deps.get(n, [])]))
for n in self.nodes])
self.cached_analysis['var_dependencies'] = var_deps2
return var_deps2
adj_nodes = {}
for n in ns:
try:
(_, node) = stack_virtualise_node(p.nodes[n], ptr_offs.get(n, {}))
except StackOffsMissing, e:
printout("Stack analysis issue at (%d, %s)." % (n, p.node_tags[n]))
node = p.nodes[n]
adj_nodes[n] = node
# finally do analysis on this collection of nodes
preds = dict(p.preds)
preds['Ret'] = [n for n in preds['Ret'] if p.node_tags[n][0] == tag]
preds['Err'] = [n for n in preds['Err'] if p.node_tags[n][0] == tag]
vds = logic.compute_var_deps(adj_nodes, adjusted_var_dep_outputs(p), preds)
result = (vds, adj_nodes, loc_offs, upd_offsets, (ptrs, offs))
p.cached_analysis[cache_key] = result
return result
def norm_int(n, radix):
n = n & ((1 << radix) - 1)
n2 = n - (1 << radix)
if abs(n2) < abs(n):
return n2
else:
return n
