8 log = logging.getLogger(
"symbexec")
9 console_handler = logging.StreamHandler()
10 console_handler.setFormatter(logging.Formatter(
"%(levelname)-5s: %(message)s"))
11 log.addHandler(console_handler)
12 log.setLevel(logging.INFO)
22 for k, v
in init.items():
26 if not isinstance(a, m2_expr.ExprMem):
27 return self.symbols_id.__contains__(a)
28 if not self.symbols_mem.__contains__(a.arg):
33 if not isinstance(a, m2_expr.ExprMem):
34 return self.symbols_id.__getitem__(a)
37 m = self.symbols_mem.__getitem__(a.arg)
38 if m[0].size != a.size:
43 if not isinstance(a, m2_expr.ExprMem):
44 self.symbols_id.__setitem__(a, v)
46 self.symbols_mem.__setitem__(a.arg, (a, v))
55 if not isinstance(a, m2_expr.ExprMem):
56 self.symbols_id.__delitem__(a)
58 self.symbols_mem.__delitem__(a.arg)
61 k = self.symbols_id.items() + [x
for x
in self.symbols_mem.values()]
65 k = self.symbols_id.keys() + [x[0]
for x
in self.symbols_mem.values()]
76 for k, v
in self.
items():
85 def __init__(self, ir_arch, known_symbols,
88 sb_expr_simp=expr_simp):
90 for k, v
in known_symbols.items():
98 if e
in self.symbols.symbols_mem:
99 return self.symbols.symbols_mem[e][0]
103 if eval_cache
is None:
105 if isinstance(e.name, asmbloc.asm_label)
and e.name.offset
is not None:
106 return m2_expr.ExprInt_from(e, e.name.offset)
116 if eval_cache
is None:
120 a = self.
expr_simp(m2_expr.ExprMem(a_val, size=e.size))
127 if a_val
in self.symbols.symbols_mem:
128 tmp = self.symbols.symbols_mem[a_val][0]
142 m = min(a.size - off * 8, x.size)
143 ee = m2_expr.ExprSlice(self.
symbols[x], 0, m)
145 out.append((ee, off_base, off_base + m))
148 m = min(a.size - off * 8, x.size)
149 ee = m2_expr.ExprSlice(self.
symbols[x], -off * 8, m)
151 new_off_base = off_base + m + off * 8
152 out.append((ff, off_base, new_off_base))
153 off_base = new_off_base
155 missing_slice = self.
rest_slice(out, 0, a.size)
156 for sa, sb
in missing_slice:
158 a_val + m2_expr.ExprInt_from(a_val, sa / 8)
160 mm = m2_expr.ExprMem(ptr, size=sb - sa)
163 out.append((mm, sa, sb))
164 out.sort(key=
lambda x: x[1])
167 ee = m2_expr.ExprSlice(m2_expr.ExprCompose(out), 0, a.size)
170 if self.
func_read and isinstance(a.arg, m2_expr.ExprInt):
177 if a.size > tmp.size:
186 val = m2_expr.ExprMem(ptr, 8)
194 val = self.
symbols[v][0:diff_size]
195 val = (val, ptr_index, ptr_index + diff_size)
197 ptr_index += diff_size
201 m2_expr.ExprOp(
'+', ptr,
202 m2_expr.ExprInt_from(ptr, v.size / 8)),
205 e = self.
expr_simp(m2_expr.ExprCompose(out))
212 if eval_cache
is None:
226 e = deal_class[c](e, eval_cache)
228 if not (isinstance(e, m2_expr.ExprId)
or isinstance(e,
234 if eval_cache
is None:
240 if init_state
is None:
241 init_state = self.ir_arch.arch.regs.regs_init
242 ids = self.symbols.symbols_id.keys()
245 if i
in init_state
and \
246 i
in self.symbols.symbols_id
and \
247 self.symbols.symbols_id[i] == init_state[i]:
252 mems = self.symbols.symbols_mem.values()
264 ids = self.symbols.symbols_id.keys()
267 if i
in self.ir_arch.arch.regs.regs_init
and \
268 i
in self.symbols.symbols_id
and \
269 self.symbols.symbols_id[i] == self.ir_arch.arch.regs.regs_init[i]:
271 print i, self.symbols.symbols_id[i]
274 mems = self.symbols.symbols_mem.values()
282 for _, a, b
in slices:
295 if not isinstance(ex, m2_expr.ExprInt):
297 ptr_diff = int(int32(ex.arg))
302 sub_size = b.size + ptr_diff * 8
303 if sub_size >= a.size:
306 ex = m2_expr.ExprOp(
'+', a.arg,
307 m2_expr.ExprInt_from(a.arg, sub_size / 8))
311 rest_size = a.size - sub_size
313 val = self.
symbols[a][sub_size:a.size]
314 out = [(m2_expr.ExprMem(rest_ptr, rest_size), val)]
325 val = self.
symbols[a][0:ptr_diff * 8]
326 out.append((m2_expr.ExprMem(a.arg, ptr_diff * 8), val))
328 if ptr_diff * 8 + b.size < a.size:
330 ex = m2_expr.ExprOp(
'+', b.arg,
331 m2_expr.ExprInt_from(b.arg, b.size / 8))
335 rest_size = a.size - (ptr_diff * 8 + b.size)
336 val = self.
symbols[a][ptr_diff * 8 + b.size:a.size]
337 out.append((m2_expr.ExprMem(ex, val.size), val))
342 if eval_cache
is None:
344 if not isinstance(e, m2_expr.ExprMem):
345 raise ValueError(
'mem overlap bad arg')
350 for i
in xrange(-7, e.size / 8):
352 self.
eval_expr(base_ptr + m2_expr.ExprInt_from(e.arg, i),
354 to_test.append((i, ex))
357 if not x
in self.symbols.symbols_mem:
360 if not isinstance(ex, m2_expr.ExprInt):
361 raise ValueError(
'ex is not ExprInt')
362 ptr_diff = int32(ex.arg)
363 if ptr_diff >= self.symbols.symbols_mem[x][1].size / 8:
366 ov.append((i, self.symbols.symbols_mem[x][0]))
372 eval_cache = dict(self.symbols.items())
375 if not isinstance(e, m2_expr.ExprAff):
376 raise TypeError(
'not affect', str(e))
379 if isinstance(e.dst, m2_expr.ExprMem):
380 a = self.
eval_expr(e.dst.arg, eval_cache)
385 tmp = m2_expr.ExprMem(a, e.dst.size)
387 if self.
func_write and isinstance(dst.arg, m2_expr.ExprInt):
392 elif isinstance(e.dst, m2_expr.ExprId):
393 pool_out[e.dst] = src
395 raise ValueError(
"affected zarb", str(e.dst))
397 return pool_out.items()
403 eval_cache = dict(self.symbols.items())
404 for dst, src
in src_dst:
405 if isinstance(dst, m2_expr.ExprMem):
407 for _, base
in mem_overlap:
410 for new_mem, new_val
in diff_mem:
411 new_val.is_term =
True
412 self.
symbols[new_mem] = new_val
417 if isinstance(dst, m2_expr.ExprMem):
422 for ir
in bloc_ir.irs:
427 eval_cache = dict(self.symbols.items())
428 return self.
eval_expr(self.ir_arch.IRDst, eval_cache)
431 b = myir.get_bloc(ad)
438 b = myir.get_bloc(ad)
441 if b.label == lbl_stop:
448 for mem_ad, (mem, _)
in self.symbols.symbols_mem.items():
450 diff = self.
eval_expr(mem_ad - sp_val, {})
452 if not isinstance(diff, m2_expr.ExprInt):