def guess_mnemo(cls, bs, attrib, pre_dis_info, offset):
candidates = []
candidates = set()
fname_values = pre_dis_info
todo = [(dict(fname_values), branch, offset * 8)
for branch in cls.bintree.items()]
cpt = 0
if hasattr(bs, 'getlen'):
bs_l = bs.getlen()
else:
bs_l = len(bs)
for fname_values, branch, offset_b in todo:
(l, fmask, fbits, fname, flen), vals = branch
cpt += 1
if flen is not None:
l = flen(attrib, fname_values)
if l is not None:
try:
v = cls.getbits(bs, attrib, offset_b, l)
except IOError:
# Raised if offset is out of bound
continue
offset_b += l
if v & fmask != fbits:
continue
if fname is not None and not fname in fname_values:
fname_values[fname] = v
for nb, v in vals.items():
if 'mn' in nb:
candidates.update(v)
else:
todo.append((dict(fname_values), (nb, v), offset_b))
candidates = [c for c in candidates]
if not candidates:
raise Disasm_Exception('cannot disasm (guess) at %X' % offset)
return candidates
def dis(cls, bs_o, mode_o=None, offset=0):
if not isinstance(bs_o, bin_stream):
bs_o = bin_stream_str(bs_o)
bs_o.enter_atomic_mode()
offset_o = offset
try:
pre_dis_info, bs, mode, offset, prefix_len = cls.pre_dis(
bs_o, mode_o, offset)
except:
bs_o.leave_atomic_mode()
raise
candidates = cls.guess_mnemo(bs, mode, pre_dis_info, offset)
if not candidates:
bs_o.leave_atomic_mode()
raise Disasm_Exception('cannot disasm (guess) at %X' % offset)
out = []
out_c = []
if hasattr(bs, 'getlen'):
bs_l = bs.getlen()
else:
bs_l = len(bs)
alias = False
for c in candidates:
log.debug("*" * 40, mode, c.mode)
log.debug(c.fields)
c = cls.all_mn_inst[c][0]
c.reset_class()
c.mode = mode
if not c.add_pre_dis_info(pre_dis_info):
continue
todo = {}
getok = True
fname_values = dict(pre_dis_info)
offset_b = offset * 8
total_l = 0
for i, f in enumerate(c.fields_order):
if f.flen is not None:
l = f.flen(mode, fname_values)
else:
l = f.l
if l is not None:
total_l += l
f.l = l
f.is_present = True
log.debug("FIELD %s %s %s %s", f.__class__, f.fname,
offset_b, l)
if bs_l * 8 - offset_b < l:
getok = False
break
bv = cls.getbits(bs, mode, offset_b, l)
offset_b += l
if not f.fname in fname_values:
fname_values[f.fname] = bv
todo[i] = bv
else:
f.is_present = False
todo[i] = None
if not getok:
continue
c.l = prefix_len + total_l / 8
for i in c.to_decode:
f = c.fields_order[i]
if f.is_present:
ret = f.decode(todo[i])
if not ret:
log.debug("cannot decode %r", f)
break
if not ret:
continue
for a in c.args:
a.expr = expr_simp(a.expr)
c.b = cls.getbytes(bs, offset_o, c.l)
c.offset = offset_o
c = c.post_dis()
if c is None:
continue
c_args = [a.expr for a in c.args]
instr = cls.instruction(c.name,
mode,
c_args,
additional_info=c.additional_info())
instr.l = prefix_len + total_l / 8
instr.b = cls.getbytes(bs, offset_o, instr.l)
instr.offset = offset_o
instr.get_info(c)
if c.alias:
alias = True
out.append(instr)
out_c.append(c)
bs_o.leave_atomic_mode()
if not out:
raise Disasm_Exception('cannot disasm at %X' % offset_o)
if len(out) != 1:
if not alias:
log.warning('dis multiple args ret default')
assert (len(out) == 2)
for i, o in enumerate(out_c):
if o.alias:
return out[i]
raise NotImplementedError('not fully functional')
return out[0]
