diff options
Diffstat (limited to 'miasm2/arch/x86')
| -rw-r--r-- | miasm2/arch/x86/arch.py | 259 | ||||
| -rw-r--r-- | miasm2/arch/x86/jit.py | 35 | ||||
| -rw-r--r-- | miasm2/arch/x86/regs.py | 23 | ||||
| -rw-r--r-- | miasm2/arch/x86/sem.py | 223 |
4 files changed, 295 insertions, 245 deletions
diff --git a/miasm2/arch/x86/arch.py b/miasm2/arch/x86/arch.py index b625647e..7a2c371c 100644 --- a/miasm2/arch/x86/arch.py +++ b/miasm2/arch/x86/arch.py @@ -1,6 +1,12 @@ #-*- coding:utf-8 -*- +from __future__ import print_function +from builtins import range import re + +from future.utils import viewitems + +from miasm2.core.utils import int_to_byte from miasm2.expression.expression import * from pyparsing import * from miasm2.core.cpu import * @@ -123,7 +129,7 @@ replace_regs = {16: replace_regs16, segm2enc = {CS: 1, SS: 2, DS: 3, ES: 4, FS: 5, GS: 6} -enc2segm = dict([(x[1], x[0]) for x in segm2enc.items()]) +enc2segm = dict((value, key) for key, value in viewitems(segm2enc)) segm_info = reg_info_dct(enc2segm) @@ -215,7 +221,7 @@ XMMWORD = Literal('XMMWORD') MEMPREFIX2SIZE = {'BYTE': 8, 'WORD': 16, 'DWORD': 32, 'QWORD': 64, 'TBYTE': 80, 'XMMWORD': 128} -SIZE2MEMPREFIX = dict((x[1], x[0]) for x in MEMPREFIX2SIZE.items()) +SIZE2MEMPREFIX = dict((value, key) for key, value in viewitems(MEMPREFIX2SIZE)) def cb_deref_mem(tokens): if len(tokens) == 2: @@ -272,7 +278,7 @@ class x86_arg(m_arg): if value.name in ["FAR"]: return None - loc_key = loc_db.get_or_create_name_location(value.name) + loc_key = loc_db.get_or_create_name_location(value.name.encode()) return ExprLoc(loc_key, size_hint) if isinstance(value, AstOp): # First pass to retrieve fixed_size @@ -430,13 +436,13 @@ repeat_mn = ["INS", "OUTS", ] -class group: +class group(object): def __init__(self): self.value = None -class additional_info: +class additional_info(object): def __init__(self): self.except_on_instr = False @@ -446,7 +452,7 @@ class additional_info: self.stk = False self.v_opmode = None self.v_admode = None - self.prefixed = '' + self.prefixed = b'' class instruction_x86(instruction): @@ -537,7 +543,7 @@ class instruction_x86(instruction): self.additional_info.v_opmode = c.v_opmode() self.additional_info.v_admode = c.v_admode() self.additional_info.prefix = c.prefix - self.additional_info.prefixed = getattr(c, "prefixed", "") + self.additional_info.prefixed = getattr(c, "prefixed", b"") def __str__(self): return self.to_string() @@ -547,13 +553,13 @@ class instruction_x86(instruction): if self.additional_info.g1.value & 1: o = "LOCK %s" % o if self.additional_info.g1.value & 2: - if getattr(self.additional_info.prefixed, 'default', "") != "\xF2": + if getattr(self.additional_info.prefixed, 'default', b"") != b"\xF2": o = "REPNE %s" % o if self.additional_info.g1.value & 8: - if getattr(self.additional_info.prefixed, 'default', "") != "\xF3": + if getattr(self.additional_info.prefixed, 'default', b"") != b"\xF3": o = "REP %s" % o elif self.additional_info.g1.value & 4: - if getattr(self.additional_info.prefixed, 'default', "") != "\xF3": + if getattr(self.additional_info.prefixed, 'default', b"") != b"\xF3": o = "REPE %s" % o return o @@ -650,7 +656,7 @@ class mn_x86(cls_mn): info.g2.value = self.g2.value info.stk = hasattr(self, 'stk') info.v_opmode = self.v_opmode() - info.prefixed = "" + info.prefixed = b"" if hasattr(self, 'prefixed'): info.prefixed = self.prefixed.default return info @@ -705,40 +711,40 @@ class mn_x86(cls_mn): 'rex_r': 0, 'rex_x': 0, 'rex_b': 0, - 'prefix': "", - 'prefixed': "", + 'prefix': b"", + 'prefixed': b"", } while True: c = v.getbytes(offset) - if c == '\x66': + if c == b'\x66': pre_dis_info['opmode'] = 1 - elif c == '\x67': + elif c == b'\x67': pre_dis_info['admode'] = 1 - elif c == '\xf0': + elif c == b'\xf0': pre_dis_info['g1'] = 1 - elif c == '\xf2': + elif c == b'\xf2': pre_dis_info['g1'] = 2 - elif c == '\xf3': + elif c == b'\xf3': pre_dis_info['g1'] = 12 - elif c == '\x2e': + elif c == b'\x2e': pre_dis_info['g2'] = 1 - elif c == '\x36': + elif c == b'\x36': pre_dis_info['g2'] = 2 - elif c == '\x3e': + elif c == b'\x3e': pre_dis_info['g2'] = 3 - elif c == '\x26': + elif c == b'\x26': pre_dis_info['g2'] = 4 - elif c == '\x64': + elif c == b'\x64': pre_dis_info['g2'] = 5 - elif c == '\x65': + elif c == b'\x65': pre_dis_info['g2'] = 6 else: break pre_dis_info['prefix'] += c offset += 1 - if mode == 64 and c in '@ABCDEFGHIJKLMNO': + if mode == 64 and c in b'@ABCDEFGHIJKLMNO': x = ord(c) pre_dis_info['rex_p'] = 1 pre_dis_info['rex_w'] = (x >> 3) & 1 @@ -746,7 +752,7 @@ class mn_x86(cls_mn): pre_dis_info['rex_x'] = (x >> 1) & 1 pre_dis_info['rex_b'] = (x >> 0) & 1 offset += 1 - elif pre_dis_info.get('g1', None) == 12 and c in ['\xa6', '\xa7', '\xae', '\xaf']: + elif pre_dis_info.get('g1', None) == 12 and c in [b'\xa6', b'\xa7', b'\xae', b'\xaf']: pre_dis_info['g1'] = 4 return pre_dis_info, v, mode, offset, offset - offset_o @@ -793,14 +799,14 @@ class mn_x86(cls_mn): def add_pre_dis_info(self, pre_dis_info=None): if pre_dis_info is None: return True - if hasattr(self, "prefixed") and self.prefixed.default == "\x66": + if hasattr(self, "prefixed") and self.prefixed.default == b"\x66": pre_dis_info['opmode'] = 0 self.opmode = pre_dis_info['opmode'] self.admode = pre_dis_info['admode'] if hasattr(self, 'no_xmm_pref') and\ pre_dis_info['prefix'] and\ - pre_dis_info['prefix'][-1] in '\x66\xf2\xf3': + pre_dis_info['prefix'][-1] in b'\x66\xf2\xf3': return False if (hasattr(self, "prefixed") and not pre_dis_info['prefix'].endswith(self.prefixed.default)): @@ -831,7 +837,7 @@ class mn_x86(cls_mn): def gen_prefix(self): - v = "" + v = b"" rex = 0x40 if self.g1.value is None: self.g1.value = 0 @@ -847,36 +853,40 @@ class mn_x86(cls_mn): if self.rex_b.value: rex |= 0x1 if rex != 0x40 or self.rex_p.value == 1: - v = chr(rex) + v + v = int_to_byte(rex) + v if hasattr(self, 'no_rex'): return None - - if hasattr(self, 'prefixed'): v = self.prefixed.default + v if self.g1.value & 1: - v = "\xf0" + v + v = b"\xf0" + v if self.g1.value & 2: if hasattr(self, 'no_xmm_pref'): return None - v = "\xf2" + v + v = b"\xf2" + v if self.g1.value & 12: if hasattr(self, 'no_xmm_pref'): return None - v = "\xf3" + v + v = b"\xf3" + v if self.g2.value: - v = {1: '\x2e', 2: '\x36', 3: '\x3e', 4: - '\x26', 5: '\x64', 6: '\x65'}[self.g2.value] + v + v = { + 1: b'\x2e', + 2: b'\x36', + 3: b'\x3e', + 4: b'\x26', + 5: b'\x64', + 6: b'\x65' + }[self.g2.value] + v # mode prefix if hasattr(self, "admode") and self.admode: - v = "\x67" + v + v = b"\x67" + v if hasattr(self, "opmode") and self.opmode: if hasattr(self, 'no_xmm_pref'): return None - v = "\x66" + v + v = b"\x66" + v return v def encodefields(self, decoded): @@ -1436,25 +1446,25 @@ def gen_modrm_form(): sib_u32 = [{f_isad: True} for i in range(0x100)] sib_u64 = [] - for rex_x in xrange(2): + for rex_x in range(2): o = [] - for rex_b in xrange(2): + for rex_b in range(2): x = [{f_isad: True} for i in range(0x100)] o.append(x) sib_u64.append(o) sib_u64_ebp = [] - for rex_x in xrange(2): + for rex_x in range(2): o = [] - for rex_b in xrange(2): + for rex_b in range(2): x = [{f_isad: True} for i in range(0x100)] o.append(x) sib_u64_ebp.append(o) sib_64_s08_ebp = [] - for rex_x in xrange(2): + for rex_x in range(2): o = [] - for rex_b in xrange(2): + for rex_b in range(2): x = [{f_isad: True} for i in range(0x100)] o.append(x) sib_64_s08_ebp.append(o) @@ -1479,17 +1489,17 @@ def gen_modrm_form(): elif sib_rez == sib_u32: sib_rez[index][f_imm] = f_u32 elif sib_rez == sib_u64_ebp: - for rex_b in xrange(2): - for rex_x in xrange(2): + for rex_b in range(2): + for rex_x in range(2): sib_rez[rex_x][rex_b][index][f_imm] = f_u32 sib_rez[rex_x][rex_b][index][ebp + 8 * rex_b] = 1 elif sib_rez == sib_u64: - for rex_b in xrange(2): - for rex_x in xrange(2): + for rex_b in range(2): + for rex_x in range(2): sib_rez[rex_x][rex_b][index][f_imm] = f_u32 elif sib_rez == sib_64_s08_ebp: - for rex_b in xrange(2): - for rex_x in xrange(2): + for rex_b in range(2): + for rex_x in range(2): sib_rez[rex_x][rex_b][index][f_imm] = f_s08 sib_rez[rex_x][rex_b][index][ebp + 8 * rex_b] = 1 @@ -1503,17 +1513,17 @@ def gen_modrm_form(): elif sib_rez == sib_u32: sib_rez[index][b] = 1 elif sib_rez == sib_u64_ebp: - for rex_b in xrange(2): - for rex_x in xrange(2): + for rex_b in range(2): + for rex_x in range(2): sib_rez[rex_x][rex_b][index][b + 8 * rex_b] = 1 sib_rez[rex_x][rex_b][index][f_imm] = f_u32 elif sib_rez == sib_u64: - for rex_b in xrange(2): - for rex_x in xrange(2): + for rex_b in range(2): + for rex_x in range(2): sib_rez[rex_x][rex_b][index][b + 8 * rex_b] = 1 elif sib_rez == sib_64_s08_ebp: - for rex_b in xrange(2): - for rex_x in xrange(2): + for rex_b in range(2): + for rex_x in range(2): sib_rez[rex_x][rex_b][index][f_imm] = f_s08 sib_rez[rex_x][rex_b][index][b + 8 * rex_b] = 1 @@ -1526,8 +1536,8 @@ def gen_modrm_form(): sib_rez[index][tmp] = 0 # 1 << ss sib_rez[index][tmp] += 1 << ss else: - for rex_b in xrange(2): - for rex_x in xrange(2): + for rex_b in range(2): + for rex_x in range(2): tmp = i + 8 * rex_x if i == 0b100 and rex_x == 0: continue @@ -1649,18 +1659,16 @@ def gen_modrm_form(): 32: defaultdict(list), 64: defaultdict(list), } - for size, db_afs in byte2modrm.items(): + for size, db_afs in viewitems(byte2modrm): for i, modrm in enumerate(db_afs): if not isinstance(modrm, list): - modrm = modrm.items() - modrm.sort() - modrm = tuple(modrm) + # We only need sort for determinism + modrm = tuple(sorted(viewitems(modrm), key=str)) modrm2byte[size][modrm].append(i) continue for j, modrm_f in enumerate(modrm): - modrm_f = modrm_f.items() - modrm_f.sort() - modrm_f = tuple(modrm_f) + # We only need sort for determinism + modrm_f = tuple(sorted(viewitems(modrm_f), key=str)) modrm2byte[size][modrm_f].append((i, j)) return byte2modrm, modrm2byte @@ -1870,7 +1878,7 @@ def expr2modrm(expr, parent, w8, sx=0, xmm=0, mm=0, bnd=0): def modrm2expr(modrm, parent, w8, sx=0, xmm=0, mm=0, bnd=0): o = [] if not modrm[f_isad]: - modrm_k = [x[0] for x in modrm.iteritems() if x[1] == 1] + modrm_k = [key for key, value in viewitems(modrm) if value == 1] if len(modrm_k) != 1: raise ValueError('strange reg encoding %r' % modrm) modrm_k = modrm_k[0] @@ -1895,8 +1903,8 @@ def modrm2expr(modrm, parent, w8, sx=0, xmm=0, mm=0, bnd=0): return expr admode = parent.v_admode() opmode = parent.v_opmode() - for modrm_k, scale in modrm.items(): - if isinstance(modrm_k, (int, long)): + for modrm_k, scale in viewitems(modrm): + if isinstance(modrm_k, int): expr = size2gpregs[admode].expr[modrm_k] if scale != 1: expr = ExprInt(scale, admode) * expr @@ -1965,9 +1973,9 @@ class x86_rm_arg(x86_arg): def gen_cand(self, v_cand, admode): if not admode in modrm2byte: # XXX TODO: 64bit - raise StopIteration + return if not v_cand: - raise StopIteration + return p = self.parent o_rex_x = p.rex_x.value @@ -1995,9 +2003,8 @@ class x86_rm_arg(x86_arg): v[f_imm] = size vo = v - v = v.items() - v.sort() - v = tuple(v) + # We only need sort for determinism + v = tuple(sorted(viewitems(v), key=str)) admode = 64 if p.mode == 64 else admode if not v in modrm2byte[admode]: continue @@ -2047,11 +2054,11 @@ class x86_rm_arg(x86_arg): yield True - raise StopIteration + return def encode(self): if isinstance(self.expr, ExprInt): - raise StopIteration + return p = self.parent admode = p.v_admode() mode = self.expr.size @@ -2091,11 +2098,11 @@ class x86_rm_mem_far(x86_rm_arg): def encode(self): if not (isinstance(self.expr, m2_expr.ExprOp) and self.expr.op == 'far'): - raise StopIteration + return expr = self.expr.args[0] if isinstance(expr, ExprInt): - raise StopIteration + return p = self.parent admode = p.v_admode() mode = expr.size @@ -2115,7 +2122,7 @@ class x86_rm_w8(x86_rm_arg): def encode(self): if isinstance(self.expr, ExprInt): - raise StopIteration + return p = self.parent if p.w8.value is None: if self.expr.size == 8: @@ -2140,7 +2147,7 @@ class x86_rm_sx(x86_rm_arg): def encode(self): if isinstance(self.expr, ExprInt): - raise StopIteration + return p = self.parent if p.w8.value is None: if self.expr.size == 8: @@ -2164,7 +2171,7 @@ class x86_rm_sxd(x86_rm_arg): def encode(self): if isinstance(self.expr, ExprInt): - raise StopIteration + return p = self.parent v_cand, segm, ok = expr2modrm(self.expr, p, 1, 2) if segm: @@ -2195,10 +2202,10 @@ class x86_rm_sd(x86_rm_arg): def encode(self): if isinstance(self.expr, ExprInt): - raise StopIteration + return p = self.parent if not self.expr.size in [32, 64]: - raise StopIteration + return self.set_s_value(0) v_cand, segm, ok = expr2modrm(self.expr, p, 1) for x in self.gen_cand(v_cand, p.v_admode()): @@ -2214,7 +2221,7 @@ class x86_rm_wd(x86_rm_sd): def encode(self): if isinstance(self.expr, ExprInt): - raise StopIteration + return p = self.parent p.wd.value = 0 v_cand, segm, ok = expr2modrm(self.expr, p, 1) @@ -2237,7 +2244,7 @@ class x86_rm_08(x86_rm_arg): def encode(self): if isinstance(self.expr, ExprInt): - raise StopIteration + return p = self.parent v_cand, segm, ok = expr2modrm(self.expr, p, 0, 0, 0, 0) for x in self.gen_cand(v_cand, p.v_admode()): @@ -2257,7 +2264,7 @@ class x86_rm_reg_m08(x86_rm_arg): def encode(self): if isinstance(self.expr, ExprInt): - raise StopIteration + return p = self.parent if isinstance(self.expr, ExprMem): expr = ExprMem(self.expr.ptr, 32) @@ -2284,7 +2291,7 @@ class x86_rm_m64(x86_rm_arg): def encode(self): if isinstance(self.expr, ExprInt): - raise StopIteration + return p = self.parent v_cand, segm, ok = expr2modrm(self.expr, p, 0, 0, 0, 1) for x in self.gen_cand(v_cand, p.v_admode()): @@ -2296,9 +2303,9 @@ class x86_rm_m80(x86_rm_m64): def encode(self): if isinstance(self.expr, ExprInt): - raise StopIteration + return if not isinstance(self.expr, ExprMem) or self.expr.size != self.msize: - raise StopIteration + return p = self.parent mode = p.mode if mode == 64: @@ -2320,7 +2327,7 @@ class x86_rm_m08(x86_rm_arg): def encode(self): if self.expr.size != 8: - raise StopIteration + return p = self.parent mode = p.mode v_cand, segm, ok = expr2modrm(self.expr, p, 0) @@ -2354,9 +2361,9 @@ class x86_rm_mm(x86_rm_m80): def encode(self): expr = self.expr if isinstance(expr, ExprInt): - raise StopIteration + return if isinstance(expr, ExprMem) and expr.size != self.msize: - raise StopIteration + return p = self.parent mode = p.mode if mode == 64: @@ -2458,7 +2465,7 @@ class x86_rm_reg_noarg(object): self.parent.w8.value = 0 return start, stop try: - result, start, stop = self.parser.scanString(text).next() + result, start, stop = next(self.parser.scanString(text)) except StopIteration: return None, None expr = self.asm_ast_to_expr(result[0], loc_db) @@ -2753,7 +2760,7 @@ class bs_cond_imm(bs_cond_scale, x86_arg): expr, start, stop = parser_result[self.parser] else: try: - expr, start, stop = self.parser.scanString(text).next() + expr, start, stop = next(self.parser.scanString(text)) except StopIteration: expr = None self.expr = expr @@ -2788,7 +2795,7 @@ class bs_cond_imm(bs_cond_scale, x86_arg): def encode(self): if not isinstance(self.expr, ExprInt): - raise StopIteration + return arg0_expr = self.parent.args[0].expr self.parent.rex_w.value = 0 # special case for push @@ -2800,10 +2807,10 @@ class bs_cond_imm(bs_cond_scale, x86_arg): self.l = l mask = ((1 << self.l) - 1) if v != sign_ext(v & mask, self.l, l): - raise StopIteration + return self.value = swap_uint(self.l, v & ((1 << self.l) - 1)) yield True - raise StopIteration + return # assume 2 args; use first arg to guess op size if arg0_expr.size == 64: @@ -2813,7 +2820,7 @@ class bs_cond_imm(bs_cond_scale, x86_arg): v = int(self.expr) if arg0_expr.size == 8: if not hasattr(self.parent, 'w8'): - raise StopIteration + return self.parent.w8.value = 0 l = 8 if hasattr(self.parent, 'se'): @@ -2838,7 +2845,7 @@ class bs_cond_imm(bs_cond_scale, x86_arg): mask = ((1 << self.l) - 1) if v != sign_ext(v & mask, self.l, l): - raise StopIteration + return self.value = swap_uint(self.l, v & ((1 << self.l) - 1)) yield True @@ -2880,7 +2887,7 @@ class bs_rel_off(bs_cond_imm): expr, start, stop = parser_result[self.parser] else: try: - expr, start, stop = self.parser.scanString(text).next() + expr, start, stop = next(self.parser.scanString(text)) except StopIteration: expr = None self.expr = expr @@ -2901,7 +2908,7 @@ class bs_rel_off(bs_cond_imm): def encode(self): if not isinstance(self.expr, ExprInt): - raise StopIteration + return arg0_expr = self.parent.args[0].expr if self.l == 0: l = self.parent.v_opmode() @@ -2911,14 +2918,14 @@ class bs_rel_off(bs_cond_imm): parent_len = len(prefix) * 8 + self.parent.l + self.l assert(parent_len % 8 == 0) - v = int(self.expr.arg - parent_len/8) + v = int(self.expr.arg) - parent_len // 8 if prefix is None: - raise StopIteration + return mask = ((1 << self.l) - 1) if self.l > l: - raise StopIteration + return if v != sign_ext(v & mask, self.l, l): - raise StopIteration + return self.value = swap_uint(self.l, v & ((1 << self.l) - 1)) yield True @@ -2939,7 +2946,7 @@ class bs_s08(bs_rel_off): def encode(self): if not isinstance(self.expr, ExprInt): - raise StopIteration + return arg0_expr = self.parent.args[0].expr if self.l != 0: l = self.l @@ -2950,9 +2957,9 @@ class bs_s08(bs_rel_off): v = int(self.expr) mask = ((1 << self.l) - 1) if self.l > l: - raise StopIteration + return if v != sign_ext(v & mask, self.l, l): - raise StopIteration + return self.value = swap_uint(self.l, v & ((1 << self.l) - 1)) yield True @@ -2983,12 +2990,12 @@ class bs_moff(bsi): def encode(self): if not hasattr(self.parent, "mseg"): - raise StopIteration + return m = self.parent.mseg.expr if not (isinstance(m, ExprOp) and m.op == 'segm'): - raise StopIteration + return if not isinstance(m.args[1], ExprInt): - raise StopIteration + return l = self.parent.v_opmode() if l == 16: self.l = 16 @@ -2997,7 +3004,7 @@ class bs_moff(bsi): v = int(m.args[1]) mask = ((1 << self.l) - 1) if v != sign_ext(v & mask, self.l, l): - raise StopIteration + return self.value = swap_uint(self.l, v & ((1 << self.l) - 1)) yield True @@ -3027,7 +3034,7 @@ class bs_movoff(x86_arg): return None, None return start, stop try: - v, start, stop = self.parser.scanString(text).next() + v, start, stop = next(self.parser.scanString(text)) except StopIteration: return None, None if not isinstance(e, ExprMem): @@ -3051,12 +3058,12 @@ class bs_movoff(x86_arg): def encode(self): p = self.parent if not isinstance(self.expr, ExprMem) or not isinstance(self.expr.ptr, ExprInt): - raise StopIteration + return self.l = p.v_admode() v = int(self.expr.ptr) mask = ((1 << self.l) - 1) if v != mask & v: - raise StopIteration + return self.value = swap_uint(self.l, v & ((1 << self.l) - 1)) yield True @@ -3092,7 +3099,7 @@ class bs_msegoff(x86_arg): return None, None return start, stop try: - v, start, stop = self.parser.scanString(text).next() + v, start, stop = next(self.parser.scanString(text)) except StopIteration: return None, None self.expr = v[0] @@ -3103,16 +3110,16 @@ class bs_msegoff(x86_arg): def encode(self): if not (isinstance(self.expr, ExprOp) and self.expr.op == 'segm'): - raise StopIteration + return if not isinstance(self.expr.args[0], ExprInt): - raise StopIteration + return if not isinstance(self.expr.args[1], ExprInt): - raise StopIteration + return l = self.parent.v_opmode() v = int(self.expr.args[0]) mask = ((1 << self.l) - 1) if v != sign_ext(v & mask, self.l, l): - raise StopIteration + return self.value = swap_uint(self.l, v & ((1 << self.l) - 1)) yield True @@ -3148,9 +3155,9 @@ sxd = bs(l=0, fname="sx") xmmreg = bs(l=0, fname="xmmreg") mmreg = bs(l=0, fname="mmreg") -pref_f2 = bs(l=0, fname="prefixed", default="\xf2") -pref_f3 = bs(l=0, fname="prefixed", default="\xf3") -pref_66 = bs(l=0, fname="prefixed", default="\x66") +pref_f2 = bs(l=0, fname="prefixed", default=b"\xf2") +pref_f3 = bs(l=0, fname="prefixed", default=b"\xf3") +pref_66 = bs(l=0, fname="prefixed", default=b"\x66") no_xmm_pref = bs(l=0, fname="no_xmm_pref") no_rex = bs(l=0, fname="no_rex") @@ -3186,7 +3193,7 @@ wd = bs(l=1, fname="wd") stk = bs(l=0, fname="stk") -class field_size: +class field_size(object): prio = default_prio def __init__(self, d=None): @@ -3287,7 +3294,7 @@ rm_arg_bnd_m128 = bs(l=0, cls=(x86_rm_bnd_m128,), fname='rmarg') rm_arg_bnd_reg = bs(l=0, cls=(x86_rm_bnd_reg,), fname='rmarg') -swapargs = bs_swapargs(l=1, fname="swap", mn_mod=range(1 << 1)) +swapargs = bs_swapargs(l=1, fname="swap", mn_mod=list(range(1 << 1))) class bs_op_mode(bsi): @@ -4626,5 +4633,5 @@ mod reg r/m def print_size(e): - print e, e.size + print(e, e.size) return e diff --git a/miasm2/arch/x86/jit.py b/miasm2/arch/x86/jit.py index f0a9875e..14418902 100644 --- a/miasm2/arch/x86/jit.py +++ b/miasm2/arch/x86/jit.py @@ -1,3 +1,4 @@ +from builtins import range import logging from miasm2.jitter.jitload import Jitter, named_arguments @@ -53,12 +54,12 @@ class jitter_x86_16(Jitter): return self.orig_irbloc_fix_regs_for_mode(irblock, 64) def push_uint16_t(self, value): - self.cpu.SP -= self.ir_arch.sp.size / 8 + self.cpu.SP -= self.ir_arch.sp.size // 8 self.vm.set_u16(self.cpu.SP, value) def pop_uint16_t(self): value = self.vm.get_u16(self.cpu.SP) - self.cpu.SP += self.ir_arch.sp.size / 8 + self.cpu.SP += self.ir_arch.sp.size // 8 return value def get_stack_arg(self, index): @@ -86,21 +87,21 @@ class jitter_x86_32(Jitter): return self.orig_irbloc_fix_regs_for_mode(irblock, 64) def push_uint16_t(self, value): - self.cpu.ESP -= self.ir_arch.sp.size / 8 + self.cpu.ESP -= self.ir_arch.sp.size // 8 self.vm.set_u16(self.cpu.ESP, value) def pop_uint16_t(self): value = self.vm.get_u16(self.cpu.ESP) - self.cpu.ESP += self.ir_arch.sp.size / 8 + self.cpu.ESP += self.ir_arch.sp.size // 8 return value def push_uint32_t(self, value): - self.cpu.ESP -= self.ir_arch.sp.size / 8 + self.cpu.ESP -= self.ir_arch.sp.size // 8 self.vm.set_u32(self.cpu.ESP, value) def pop_uint32_t(self): value = self.vm.get_u32(self.cpu.ESP) - self.cpu.ESP += self.ir_arch.sp.size / 8 + self.cpu.ESP += self.ir_arch.sp.size // 8 return value def get_stack_arg(self, index): @@ -116,7 +117,7 @@ class jitter_x86_32(Jitter): @named_arguments def func_args_stdcall(self, n_args): ret_ad = self.pop_uint32_t() - args = [self.pop_uint32_t() for _ in xrange(n_args)] + args = [self.pop_uint32_t() for _ in range(n_args)] return ret_ad, args def func_ret_stdcall(self, ret_addr, ret_value1=None, ret_value2=None): @@ -137,7 +138,7 @@ class jitter_x86_32(Jitter): @named_arguments def func_args_cdecl(self, n_args): ret_ad = self.pop_uint32_t() - args = [self.get_stack_arg(i) for i in xrange(n_args)] + args = [self.get_stack_arg(i) for i in range(n_args)] return ret_ad, args def func_ret_cdecl(self, ret_addr, ret_value1=None, ret_value2=None): @@ -162,13 +163,13 @@ class jitter_x86_32(Jitter): args_regs = ['ECX', 'EDX'] ret_ad = self.pop_uint32_t() args = [] - for i in xrange(n_args): + for i in range(n_args): args.append(self.get_arg_n_fastcall(i)) return ret_ad, args def func_prepare_fastcall(self, ret_addr, *args): args_regs = ['ECX', 'EDX'] - for i in xrange(min(len(args), len(args_regs))): + for i in range(min(len(args), len(args_regs))): setattr(self.cpu, args_regs[i], args[i]) remaining_args = args[len(args_regs):] for arg in reversed(remaining_args): @@ -202,12 +203,12 @@ class jitter_x86_64(Jitter): return self.orig_irbloc_fix_regs_for_mode(irblock, 64) def push_uint64_t(self, value): - self.cpu.RSP -= self.ir_arch.sp.size / 8 + self.cpu.RSP -= self.ir_arch.sp.size // 8 self.vm.set_u64(self.cpu.RSP, value) def pop_uint64_t(self): value = self.vm.get_u64(self.cpu.RSP) - self.cpu.RSP += self.ir_arch.sp.size / 8 + self.cpu.RSP += self.ir_arch.sp.size // 8 return value def get_stack_arg(self, index): @@ -225,15 +226,15 @@ class jitter_x86_64(Jitter): args_regs = self.args_regs_stdcall ret_ad = self.pop_uint64_t() args = [] - for i in xrange(min(n_args, 4)): + for i in range(min(n_args, 4)): args.append(self.cpu.get_gpreg()[args_regs[i]]) - for i in xrange(max(0, n_args - 4)): + for i in range(max(0, n_args - 4)): args.append(self.get_stack_arg(i)) return ret_ad, args def func_prepare_stdcall(self, ret_addr, *args): args_regs = self.args_regs_stdcall - for i in xrange(min(len(args), len(args_regs))): + for i in range(min(len(args), len(args_regs))): setattr(self.cpu, args_regs[i], args[i]) remaining_args = args[len(args_regs):] for arg in reversed(remaining_args): @@ -262,7 +263,7 @@ class jitter_x86_64(Jitter): @named_arguments def func_args_systemv(self, n_args): ret_ad = self.pop_uint64_t() - args = [self.get_arg_n_systemv(index) for index in xrange(n_args)] + args = [self.get_arg_n_systemv(index) for index in range(n_args)] return ret_ad, args func_ret_systemv = func_ret_cdecl @@ -270,7 +271,7 @@ class jitter_x86_64(Jitter): def func_prepare_systemv(self, ret_addr, *args): args_regs = self.args_regs_systemv self.push_uint64_t(ret_addr) - for i in xrange(min(len(args), len(args_regs))): + for i in range(min(len(args), len(args_regs))): setattr(self.cpu, args_regs[i], args[i]) remaining_args = args[len(args_regs):] for arg in reversed(remaining_args): diff --git a/miasm2/arch/x86/regs.py b/miasm2/arch/x86/regs.py index ef1095e2..b3f6534b 100644 --- a/miasm2/arch/x86/regs.py +++ b/miasm2/arch/x86/regs.py @@ -1,3 +1,4 @@ +from builtins import range from miasm2.expression.expression import ExprId from miasm2.core.cpu import reg_info @@ -12,20 +13,20 @@ interrupt_num = ExprId('interrupt_num', 8) regs08_str = ["AL", "CL", "DL", "BL", "AH", "CH", "DH", "BH"] + \ - ["R%dB" % (i + 8) for i in xrange(8)] + ["R%dB" % (i + 8) for i in range(8)] regs08_expr = [ExprId(x, 8) for x in regs08_str] regs08_64_str = ["AL", "CL", "DL", "BL", "SPL", "BPL", "SIL", "DIL"] + \ - ["R%dB" % (i + 8) for i in xrange(8)] + ["R%dB" % (i + 8) for i in range(8)] regs08_64_expr = [ExprId(x, 8) for x in regs08_64_str] regs16_str = ["AX", "CX", "DX", "BX", "SP", "BP", "SI", "DI"] + \ - ["R%dW" % (i + 8) for i in xrange(8)] + ["R%dW" % (i + 8) for i in range(8)] regs16_expr = [ExprId(x, 16) for x in regs16_str] regs32_str = ["EAX", "ECX", "EDX", "EBX", "ESP", "EBP", "ESI", "EDI"] + \ - ["R%dD" % (i + 8) for i in xrange(8)] + ["R%dD" % (i + 8) for i in range(8)] regs32_expr = [ExprId(x, 32) for x in regs32_str] regs64_str = ["RAX", "RCX", "RDX", "RBX", "RSP", "RBP", "RSI", "RDI", @@ -34,13 +35,13 @@ regs64_str = ["RAX", "RCX", "RDX", "RBX", "RSP", "RBP", "RSI", "RDI", regs64_expr = [ExprId(x, 64) for x in regs64_str] -regs_xmm_str = ["XMM%d" % i for i in xrange(16)] +regs_xmm_str = ["XMM%d" % i for i in range(16)] regs_xmm_expr = [ExprId(x, 128) for x in regs_xmm_str] -regs_mm_str = ["MM%d" % i for i in xrange(16)] +regs_mm_str = ["MM%d" % i for i in range(16)] regs_mm_expr = [ExprId(x, 64) for x in regs_mm_str] -regs_bnd_str = ["BND%d" % i for i in xrange(4)] +regs_bnd_str = ["BND%d" % i for i in range(4)] regs_bnd_expr = [ExprId(x, 128) for x in regs_bnd_str] gpregs08 = reg_info(regs08_str, regs08_expr) @@ -74,17 +75,17 @@ selectr_str = ["ES", "CS", "SS", "DS", "FS", "GS"] selectr_expr = [ExprId(x, 16) for x in selectr_str] segmreg = reg_info(selectr_str, selectr_expr) -crregs32_str = ["CR%d" % i for i in xrange(8)] +crregs32_str = ["CR%d" % i for i in range(8)] crregs32_expr = [ExprId(x, 32) for x in crregs32_str] crregs = reg_info(crregs32_str, crregs32_expr) -drregs32_str = ["DR%d" % i for i in xrange(8)] +drregs32_str = ["DR%d" % i for i in range(8)] drregs32_expr = [ExprId(x, 32) for x in drregs32_str] drregs = reg_info(drregs32_str, drregs32_expr) -fltregs32_str = ["ST(%d)" % i for i in xrange(8)] +fltregs32_str = ["ST(%d)" % i for i in range(8)] fltregs32_expr = [ExprId(x, 64) for x in fltregs32_str] fltregs = reg_info(fltregs32_str, fltregs32_expr) @@ -345,7 +346,7 @@ float_st7 = ExprId("float_st7", 64) float_list = [float_st0, float_st1, float_st2, float_st3, float_st4, float_st5, float_st6, float_st7] -float_replace = {fltregs32_expr[i]: float_list[i] for i in xrange(8)} +float_replace = {fltregs32_expr[i]: float_list[i] for i in range(8)} float_replace[r_st_all.expr[0]] = float_st0 diff --git a/miasm2/arch/x86/sem.py b/miasm2/arch/x86/sem.py index d03a7cd4..bec09249 100644 --- a/miasm2/arch/x86/sem.py +++ b/miasm2/arch/x86/sem.py @@ -16,6 +16,10 @@ # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. # +from builtins import range + +from future.utils import viewitems + import logging import miasm2.expression.expression as m2_expr from miasm2.expression.simplifications import expr_simp @@ -882,7 +886,7 @@ def push_gen(ir, instr, src, size): off_size = src.size sp = mRSP[instr.mode] - new_sp = sp - m2_expr.ExprInt(off_size / 8, sp.size) + new_sp = sp - m2_expr.ExprInt(off_size // 8, sp.size) e.append(m2_expr.ExprAssign(sp, new_sp)) if ir.do_stk_segm: new_sp = ir.gen_segm_expr(SS, new_sp) @@ -905,7 +909,7 @@ def pop_gen(ir, instr, src, size): raise ValueError('bad size stacker!') sp = mRSP[instr.mode] - new_sp = sp + m2_expr.ExprInt(src.size / 8, sp.size) + new_sp = sp + m2_expr.ExprInt(src.size // 8, sp.size) # don't generate ESP incrementation on POP ESP if src != ir.sp: e.append(m2_expr.ExprAssign(sp, new_sp)) @@ -1187,7 +1191,7 @@ def cmps(ir, instr, size): src1_sgm = src1 src2_sgm = src2 - offset = m2_expr.ExprInt(size / 8, src1.size) + offset = m2_expr.ExprInt(size // 8, src1.size) e, _ = l_cmp(ir, instr, ir.ExprMem(src1_sgm, size), @@ -1226,7 +1230,7 @@ def scas(ir, instr, size): else: src_sgm = src - offset = m2_expr.ExprInt(size / 8, src.size) + offset = m2_expr.ExprInt(size // 8, src.size) e, extra = l_cmp(ir, instr, mRAX[instr.mode][:size], ir.ExprMem(src_sgm, size)) @@ -1298,7 +1302,7 @@ def popfd(ir, instr): e.append(m2_expr.ExprAssign(vip, m2_expr.ExprSlice(tmp, 20, 21))) e.append(m2_expr.ExprAssign(i_d, m2_expr.ExprSlice(tmp, 21, 22))) e.append(m2_expr.ExprAssign(mRSP[instr.mode], - mRSP[instr.mode] + m2_expr.ExprInt(instr.mode / 8, mRSP[instr.mode].size))) + mRSP[instr.mode] + m2_expr.ExprInt(instr.mode // 8, mRSP[instr.mode].size))) e.append(m2_expr.ExprAssign(exception_flags, m2_expr.ExprCond(m2_expr.ExprSlice(tmp, 8, 9), m2_expr.ExprInt( @@ -1339,7 +1343,7 @@ def pusha_gen(ir, instr, size): e = [] cur_sp = mRSP[instr.mode] for i, reg in enumerate(pa_regs): - stk_ptr = cur_sp + m2_expr.ExprInt(-(size / 8) * (i + 1), instr.mode) + stk_ptr = cur_sp + m2_expr.ExprInt(-(size // 8) * (i + 1), instr.mode) e.append(m2_expr.ExprAssign(ir.ExprMem(stk_ptr, size), reg[size])) e.append(m2_expr.ExprAssign(cur_sp, stk_ptr)) return e, [] @@ -1359,10 +1363,10 @@ def popa_gen(ir, instr, size): for i, reg in enumerate(reversed(pa_regs)): if reg == mRSP: continue - stk_ptr = cur_sp + m2_expr.ExprInt((size / 8) * i, instr.mode) + stk_ptr = cur_sp + m2_expr.ExprInt((size // 8) * i, instr.mode) e.append(m2_expr.ExprAssign(reg[size], ir.ExprMem(stk_ptr, size))) - stk_ptr = cur_sp + m2_expr.ExprInt((size / 8) * (i + 1), instr.mode) + stk_ptr = cur_sp + m2_expr.ExprInt((size // 8) * (i + 1), instr.mode) e.append(m2_expr.ExprAssign(cur_sp, stk_ptr)) return e, [] @@ -1407,19 +1411,19 @@ def call(ir, instr, dst): e.append(m2_expr.ExprAssign(ir.IRDst, m2)) - c = myesp + m2_expr.ExprInt(-s / 8, s) + c = myesp + m2_expr.ExprInt(-s // 8, s) e.append(m2_expr.ExprAssign(ir.ExprMem(c, size=s).zeroExtend(s), CS.zeroExtend(s))) - c = myesp + m2_expr.ExprInt(-2 * s / 8, s) + c = myesp + m2_expr.ExprInt((-2 * s) // 8, s) e.append(m2_expr.ExprAssign(ir.ExprMem(c, size=s).zeroExtend(s), meip.zeroExtend(s))) - c = myesp + m2_expr.ExprInt((-2 * s) / 8, s) + c = myesp + m2_expr.ExprInt((-2 * s) // 8, s) e.append(m2_expr.ExprAssign(myesp, c)) return e, [] - c = myesp + m2_expr.ExprInt((-s / 8), s) + c = myesp + m2_expr.ExprInt(-s // 8, s) e.append(m2_expr.ExprAssign(myesp, c)) if ir.do_stk_segm: c = ir.gen_segm_expr(SS, c) @@ -1437,10 +1441,10 @@ def ret(ir, instr, src=None): myesp = mRSP[instr.mode][:size] if src is None: - value = (myesp + (m2_expr.ExprInt((size / 8), size))) + value = (myesp + (m2_expr.ExprInt(size // 8, size))) else: src = m2_expr.ExprInt(int(src), size) - value = (myesp + (m2_expr.ExprInt((size / 8), size) + src)) + value = (myesp + (m2_expr.ExprInt(size // 8, size) + src)) e.append(m2_expr.ExprAssign(myesp, value)) result = myesp @@ -1473,13 +1477,13 @@ def retf(ir, instr, src=None): e.append(m2_expr.ExprAssign(ir.IRDst, ir.ExprMem(result, size=size).zeroExtend(size))) # e.append(m2_expr.ExprAssign(meip, ir.ExprMem(c, size = s))) - result = myesp + m2_expr.ExprInt(size / 8, size) + result = myesp + m2_expr.ExprInt(size // 8, size) if ir.do_stk_segm: result = ir.gen_segm_expr(SS, result) e.append(m2_expr.ExprAssign(CS, ir.ExprMem(result, size=16))) - value = myesp + (m2_expr.ExprInt((2 * size) / 8, size) + src) + value = myesp + (m2_expr.ExprInt((2 * size) // 8, size) + src) e.append(m2_expr.ExprAssign(myesp, value)) return e, [] @@ -1490,7 +1494,7 @@ def leave(ir, instr): e = [] e.append(m2_expr.ExprAssign(mRBP[size], ir.ExprMem(mRBP[size], size=size))) e.append(m2_expr.ExprAssign(myesp, - m2_expr.ExprInt(size / 8, size) + mRBP[size])) + m2_expr.ExprInt(size // 8, size) + mRBP[size])) return e, [] @@ -1502,12 +1506,12 @@ def enter(ir, instr, src1, src2): src1 = src1.zeroExtend(size) e = [] - esp_tmp = myesp - m2_expr.ExprInt(size / 8, size) + esp_tmp = myesp - m2_expr.ExprInt(size // 8, size) e.append(m2_expr.ExprAssign(ir.ExprMem(esp_tmp, size=size), myebp)) e.append(m2_expr.ExprAssign(myebp, esp_tmp)) e.append(m2_expr.ExprAssign(myesp, - myesp - (src1 + m2_expr.ExprInt(size / 8, size)))) + myesp - (src1 + m2_expr.ExprInt(size // 8, size)))) return e, [] @@ -1930,8 +1934,8 @@ def stos(ir, instr, size): addr_o = mRDI[instr.mode][:instr.v_admode()] addr = addr_o - addr_p = addr + m2_expr.ExprInt(size / 8, addr.size) - addr_m = addr - m2_expr.ExprInt(size / 8, addr.size) + addr_p = addr + m2_expr.ExprInt(size // 8, addr.size) + addr_m = addr - m2_expr.ExprInt(size // 8, addr.size) if ir.do_str_segm: mss = ES if instr.additional_info.g2.value: @@ -1966,8 +1970,8 @@ def lods(ir, instr, size): addr_o = mRSI[instr.mode][:instr.v_admode()] addr = addr_o - addr_p = addr + m2_expr.ExprInt(size / 8, addr.size) - addr_m = addr - m2_expr.ExprInt(size / 8, addr.size) + addr_p = addr + m2_expr.ExprInt(size // 8, addr.size) + addr_m = addr - m2_expr.ExprInt(size // 8, addr.size) if ir.do_str_segm: mss = DS if instr.additional_info.g2.value: @@ -2018,7 +2022,7 @@ def movs(ir, instr, size): src_sgm = src dst_sgm = dst - offset = m2_expr.ExprInt(size / 8, src.size) + offset = m2_expr.ExprInt(size // 8, src.size) e.append(m2_expr.ExprAssign(ir.ExprMem(dst_sgm, size), ir.ExprMem(src_sgm, size))) @@ -2081,12 +2085,12 @@ def float_pop(avoid_flt=None, popcount=1): """ avoid_flt = float_prev(avoid_flt, popcount) e = [] - for i in xrange(8 - popcount): + for i in range(8 - popcount): if avoid_flt != float_list[i]: e.append(m2_expr.ExprAssign(float_list[i], float_list[i + popcount])) fill_value = m2_expr.ExprOp("sint_to_fp", m2_expr.ExprInt(0, 64)) - for i in xrange(8 - popcount, 8): + for i in range(8 - popcount, 8): e.append(m2_expr.ExprAssign(float_list[i], fill_value)) e.append( @@ -2619,20 +2623,45 @@ def fnstenv(ir, instr, dst): size = min(32, s) ad = ir.ExprMem(dst.ptr, size=16) e.append(m2_expr.ExprAssign(ad, float_control)) - ad = ir.ExprMem(dst.ptr + m2_expr.ExprInt(size / - 8 * 1, dst.ptr.size), size=16) + ad = ir.ExprMem( + dst.ptr + m2_expr.ExprInt( + size // (8 * 1), + dst.ptr.size + ), + size=16 + ) e.append(m2_expr.ExprAssign(ad, status_word)) - ad = ir.ExprMem(dst.ptr + m2_expr.ExprInt(size / - 8 * 3, dst.ptr.size), size=size) + ad = ir.ExprMem( + dst.ptr + m2_expr.ExprInt( + size // (8 * 3), + dst.ptr.size + ), + size=size + ) e.append(m2_expr.ExprAssign(ad, float_eip[:size])) - ad = ir.ExprMem(dst.ptr + m2_expr.ExprInt(size / - 8 * 4, dst.ptr.size), size=16) + ad = ir.ExprMem( + dst.ptr + m2_expr.ExprInt( + size // (8 * 4), + dst.ptr.size + ), + size=16 + ) e.append(m2_expr.ExprAssign(ad, float_cs)) - ad = ir.ExprMem(dst.ptr + m2_expr.ExprInt(size / - 8 * 5, dst.ptr.size), size=size) + ad = ir.ExprMem( + dst.ptr + m2_expr.ExprInt( + size // (8 * 5), + dst.ptr.size + ), + size=size + ) e.append(m2_expr.ExprAssign(ad, float_address[:size])) - ad = ir.ExprMem(dst.ptr + m2_expr.ExprInt(size / - 8 * 6, dst.ptr.size), size=16) + ad = ir.ExprMem( + dst.ptr + m2_expr.ExprInt( + size // (8 * 6), + dst.ptr.size + ), + size=16 + ) e.append(m2_expr.ExprAssign(ad, float_ds)) return e, [] @@ -2651,23 +2680,35 @@ def fldenv(ir, instr, src): e.append(m2_expr.ExprAssign(float_control, ad)) # Status word - ad = ir.ExprMem(src.ptr + m2_expr.ExprInt(size / 8 * 1, size=src.ptr.size), - size=16) - e += [m2_expr.ExprAssign(x, y) for x, y in ((float_c0, ad[8:9]), - (float_c1, ad[9:10]), - (float_c2, ad[10:11]), - (float_stack_ptr, ad[11:14]), - (float_c3, ad[14:15])) - ] + ad = ir.ExprMem( + src.ptr + m2_expr.ExprInt( + size // (8 * 1), + size=src.ptr.size + ), + size=16 + ) + e += [ + m2_expr.ExprAssign(x, y) for x, y in ((float_c0, ad[8:9]), + (float_c1, ad[9:10]), + (float_c2, ad[10:11]), + (float_stack_ptr, ad[11:14]), + (float_c3, ad[14:15])) + ] # EIP, CS, Address, DS - for offset, target in ((3, float_eip[:size]), - (4, float_cs), - (5, float_address[:size]), - (6, float_ds)): - ad = ir.ExprMem(src.ptr + m2_expr.ExprInt(size / 8 * offset, - size=src.ptr.size), - size=target.size) + for offset, target in ( + (3, float_eip[:size]), + (4, float_cs), + (5, float_address[:size]), + (6, float_ds) + ): + ad = ir.ExprMem( + src.ptr + m2_expr.ExprInt( + size // ( 8 * offset), + size=src.ptr.size + ), + size=target.size + ) e.append(m2_expr.ExprAssign(target, ad)) return e, [] @@ -3243,7 +3284,7 @@ def sidt(ir, instr, dst): if not isinstance(dst, m2_expr.ExprMem) or dst.size != 32: raise ValueError('not exprmem 32bit instance!!') ptr = dst.ptr - LOG_X86_SEM.warning("DEFAULT SIDT ADDRESS %s!!", str(dst)) + LOG_X86_SEM.warning("DEFAULT SIDT ADDRESS %s!!", dst) e.append(m2_expr.ExprAssign(ir.ExprMem(ptr, 32), m2_expr.ExprInt(0xe40007ff, 32))) e.append( @@ -3253,7 +3294,7 @@ def sidt(ir, instr, dst): def sldt(_, instr, dst): - LOG_X86_SEM.warning("DEFAULT SLDT ADDRESS %s!!", str(dst)) + LOG_X86_SEM.warning("DEFAULT SLDT ADDRESS %s!!", dst) e = [m2_expr.ExprAssign(dst, m2_expr.ExprInt(0, dst.size))] return e, [] @@ -3531,7 +3572,7 @@ def cmpxchg16b(arg1): def lds(ir, instr, dst, src): e = [] e.append(m2_expr.ExprAssign(dst, ir.ExprMem(src.ptr, size=dst.size))) - DS_value = ir.ExprMem(src.ptr + m2_expr.ExprInt(dst.size / 8, src.ptr.size), + DS_value = ir.ExprMem(src.ptr + m2_expr.ExprInt(dst.size // 8, src.ptr.size), size=16) e.append(m2_expr.ExprAssign(DS, DS_value)) return e, [] @@ -3540,7 +3581,7 @@ def lds(ir, instr, dst, src): def les(ir, instr, dst, src): e = [] e.append(m2_expr.ExprAssign(dst, ir.ExprMem(src.ptr, size=dst.size))) - ES_value = ir.ExprMem(src.ptr + m2_expr.ExprInt(dst.size / 8, src.ptr.size), + ES_value = ir.ExprMem(src.ptr + m2_expr.ExprInt(dst.size // 8, src.ptr.size), size=16) e.append(m2_expr.ExprAssign(ES, ES_value)) return e, [] @@ -3549,7 +3590,7 @@ def les(ir, instr, dst, src): def lss(ir, instr, dst, src): e = [] e.append(m2_expr.ExprAssign(dst, ir.ExprMem(src.ptr, size=dst.size))) - SS_value = ir.ExprMem(src.ptr + m2_expr.ExprInt(dst.size / 8, src.ptr.size), + SS_value = ir.ExprMem(src.ptr + m2_expr.ExprInt(dst.size // 8, src.ptr.size), size=16) e.append(m2_expr.ExprAssign(SS, SS_value)) return e, [] @@ -3558,7 +3599,7 @@ def lss(ir, instr, dst, src): def lfs(ir, instr, dst, src): e = [] e.append(m2_expr.ExprAssign(dst, ir.ExprMem(src.ptr, size=dst.size))) - FS_value = ir.ExprMem(src.ptr + m2_expr.ExprInt(dst.size / 8, src.ptr.size), + FS_value = ir.ExprMem(src.ptr + m2_expr.ExprInt(dst.size // 8, src.ptr.size), size=16) e.append(m2_expr.ExprAssign(FS, FS_value)) return e, [] @@ -3567,7 +3608,7 @@ def lfs(ir, instr, dst, src): def lgs(ir, instr, dst, src): e = [] e.append(m2_expr.ExprAssign(dst, ir.ExprMem(src.ptr, size=dst.size))) - GS_value = ir.ExprMem(src.ptr + m2_expr.ExprInt(dst.size / 8, src.ptr.size), + GS_value = ir.ExprMem(src.ptr + m2_expr.ExprInt(dst.size // 8, src.ptr.size), size=16) e.append(m2_expr.ExprAssign(GS, GS_value)) return e, [] @@ -3704,18 +3745,18 @@ def vec_op_clip(op, size, callback=None): def vec_vertical_sem(op, elt_size, reg_size, dst, src, apply_on_output): assert reg_size % elt_size == 0 - n = reg_size / elt_size + n = reg_size // elt_size if op == '-': ops = [ apply_on_output((dst[i * elt_size:(i + 1) * elt_size] - src[i * elt_size:(i + 1) * elt_size])) - for i in xrange(0, n) + for i in range(0, n) ] else: ops = [ apply_on_output(m2_expr.ExprOp(op, dst[i * elt_size:(i + 1) * elt_size], src[i * elt_size:(i + 1) * elt_size])) - for i in xrange(0, n) + for i in range(0, n) ] return m2_expr.ExprCompose(*ops) @@ -3857,7 +3898,7 @@ def pmaddwd(ir, instr, dst, src): sizedst = 32 sizesrc = 16 out = [] - for start in xrange(0, dst.size, sizedst): + for start in range(0, dst.size, sizedst): base = start mul1 = src[base: base + sizesrc].signExtend(sizedst) * dst[base: base + sizesrc].signExtend(sizedst) base += sizesrc @@ -3877,9 +3918,9 @@ def psadbw(ir, instr, dst, src): sizedst = 16 sizesrc = 8 out_dst = [] - for start in xrange(0, dst.size, 64): + for start in range(0, dst.size, 64): out = [] - for src_start in xrange(0, 64, sizesrc): + for src_start in range(0, 64, sizesrc): beg = start + src_start end = beg + sizesrc # Not clear in the doc equations, but in the text, src and dst are: @@ -4311,7 +4352,7 @@ def pshufb(_, instr, dst, src): bit_l = 4 else: raise NotImplementedError("bad size") - for i in xrange(0, src.size, 8): + for i in range(0, src.size, 8): index = src[ i:i + bit_l].zeroExtend(dst.size) << m2_expr.ExprInt(3, dst.size) value = (dst >> index)[:8] @@ -4325,7 +4366,7 @@ def pshufb(_, instr, dst, src): def pshufd(_, instr, dst, src, imm): control = int(imm) out = [] - for i in xrange(4): + for i in range(4): shift = ((control >> (i * 2)) & 3) * 32 # shift is 2 bits long, expr.size is 128 # => shift + 32 <= src.size @@ -4336,7 +4377,7 @@ def pshufd(_, instr, dst, src, imm): def pshuflw(_, instr, dst, src, imm): control = int(imm) out = [] - for i in xrange(4): + for i in range(4): shift = ((control >> (i * 2)) & 3) * 16 out.append(src[shift: shift + 16]) out.append(src[64:]) @@ -4346,7 +4387,7 @@ def pshuflw(_, instr, dst, src, imm): def pshufhw(_, instr, dst, src, imm): control = int(imm) out = [src[:64]] - for i in xrange(4): + for i in range(4): shift = ((control >> (i * 2)) & 3) * 16 out.append(src[shift + 64: shift + 16 + 64]) return [m2_expr.ExprAssign(dst, m2_expr.ExprCompose(*out))], [] @@ -4369,7 +4410,7 @@ def ps_rl_ll(ir, instr, dst, src, op, size): count = expr_simp(count) out = [] - for i in xrange(0, dst.size, size): + for i in range(0, dst.size, size): out.append(m2_expr.ExprOp(op, dst[i:i + size], count)) return [m2_expr.ExprAssign(dst, m2_expr.ExprCompose(*out))], [] @@ -4430,15 +4471,15 @@ def iret(ir, instr): XXX: only support "no-privilege change" """ size = instr.v_opmode() - exprs, _ = retf(ir, instr, m2_expr.ExprInt(size / 8, size=size)) - tmp = mRSP[instr.mode][:size] + m2_expr.ExprInt((2 * size) / 8, size=size) + exprs, _ = retf(ir, instr, m2_expr.ExprInt(size // 8, size=size)) + tmp = mRSP[instr.mode][:size] + m2_expr.ExprInt((2 * size) // 8, size=size) exprs += _tpl_eflags(tmp) return exprs, [] def pcmpeq(_, instr, dst, src, size): e = [] - for i in xrange(0, dst.size, size): + for i in range(0, dst.size, size): test = m2_expr.expr_is_equal(dst[i:i + size], src[i:i + size]) e.append(m2_expr.ExprAssign(dst[i:i + size], m2_expr.ExprCond(test, @@ -4449,7 +4490,7 @@ def pcmpeq(_, instr, dst, src, size): def pcmpgt(_, instr, dst, src, size): e = [] - for i in xrange(0, dst.size, size): + for i in range(0, dst.size, size): test = m2_expr.expr_is_signed_greater(dst[i:i + size], src[i:i + size]) e.append(m2_expr.ExprAssign(dst[i:i + size], m2_expr.ExprCond(test, @@ -4490,7 +4531,7 @@ def pcmpgtq(ir, instr, dst, src): def punpck(_, instr, dst, src, size, off): e = [] slices = [] - for i in xrange(dst.size / (2 * size)): + for i in range(dst.size // (2 * size)): slices.append(dst[size * i + off: size * i + off + size]) slices.append(src[size * i + off: size * i + off + size]) e.append(m2_expr.ExprAssign(dst, m2_expr.ExprCompose(*slices))) @@ -4498,19 +4539,19 @@ def punpck(_, instr, dst, src, size, off): def punpckhbw(ir, instr, dst, src): - return punpck(ir, instr, dst, src, 8, dst.size / 2) + return punpck(ir, instr, dst, src, 8, dst.size // 2) def punpckhwd(ir, instr, dst, src): - return punpck(ir, instr, dst, src, 16, dst.size / 2) + return punpck(ir, instr, dst, src, 16, dst.size // 2) def punpckhdq(ir, instr, dst, src): - return punpck(ir, instr, dst, src, 32, dst.size / 2) + return punpck(ir, instr, dst, src, 32, dst.size // 2) def punpckhqdq(ir, instr, dst, src): - return punpck(ir, instr, dst, src, 64, dst.size / 2) + return punpck(ir, instr, dst, src, 64, dst.size // 2) def punpcklbw(ir, instr, dst, src): @@ -4667,7 +4708,7 @@ def movq2dq(_, instr, dst, src): def sqrt_gen(_, instr, dst, src, size): e = [] out = [] - for i in xrange(src.size / size): + for i in range(src.size // size): out.append(m2_expr.ExprOp('fsqrt', src[i * size: (i + 1) * size])) src = m2_expr.ExprCompose(*out) @@ -4702,7 +4743,7 @@ def sqrtss(_, instr, dst, src): def pmovmskb(_, instr, dst, src): e = [] out = [] - for i in xrange(src.size / 8): + for i in range(src.size // 8): out.append(src[8 * i + 7:8 * (i + 1)]) src = m2_expr.ExprCompose(*out) e.append(m2_expr.ExprAssign(dst, src.zeroExtend(dst.size))) @@ -4807,7 +4848,7 @@ def _unsigned_saturation(expr, dst_size): def packsswb(ir, instr, dst, src): out = [] for source in [dst, src]: - for start in xrange(0, dst.size, 16): + for start in range(0, dst.size, 16): out.append(_signed_saturation(source[start:start + 16], 8)) return [m2_expr.ExprAssign(dst, m2_expr.ExprCompose(*out))], [] @@ -4815,7 +4856,7 @@ def packsswb(ir, instr, dst, src): def packssdw(ir, instr, dst, src): out = [] for source in [dst, src]: - for start in xrange(0, dst.size, 32): + for start in range(0, dst.size, 32): out.append(_signed_saturation(source[start:start + 32], 16)) return [m2_expr.ExprAssign(dst, m2_expr.ExprCompose(*out))], [] @@ -4823,7 +4864,7 @@ def packssdw(ir, instr, dst, src): def packuswb(ir, instr, dst, src): out = [] for source in [dst, src]: - for start in xrange(0, dst.size, 16): + for start in range(0, dst.size, 16): out.append(_unsigned_saturation(source[start:start + 16], 8)) return [m2_expr.ExprAssign(dst, m2_expr.ExprCompose(*out))], [] @@ -4894,13 +4935,13 @@ def maskmovq(ir, instr, src, mask): # For each possibility, check if a write is necessary check_labels = [m2_expr.ExprLoc(ir.loc_db.add_location(), ir.IRDst.size) - for _ in xrange(0, mask.size, 8)] + for _ in range(0, mask.size, 8)] # If the write has to be done, do it (otherwise, nothing happen) write_labels = [m2_expr.ExprLoc(ir.loc_db.add_location(), ir.IRDst.size) - for _ in xrange(0, mask.size, 8)] + for _ in range(0, mask.size, 8)] # Build check blocks - for i, start in enumerate(xrange(0, mask.size, 8)): + for i, start in enumerate(range(0, mask.size, 8)): bit = mask[start + 7: start + 8] cur_label = check_labels[i] next_check_label = check_labels[i + 1] if (i + 1) < len(check_labels) else loc_next_expr @@ -4913,7 +4954,7 @@ def maskmovq(ir, instr, src, mask): # Build write blocks dst_addr = mRDI[instr.mode] - for i, start in enumerate(xrange(0, mask.size, 8)): + for i, start in enumerate(range(0, mask.size, 8)): cur_label = write_labels[i] next_check_label = check_labels[i + 1] if (i + 1) < len(check_labels) else loc_next_expr write_addr = dst_addr + m2_expr.ExprInt(i, dst_addr.size) @@ -4972,7 +5013,7 @@ def _select4(src, control): def shufps(ir, instr, dst, src, imm8): out = [] control = int(imm8) - for i in xrange(4): + for i in range(4): if i < 2: source = dst else: @@ -4990,13 +5031,13 @@ def shufpd(ir, instr, dst, src, imm8): def movmskps(ir, instr, dst, src): out = [] - for i in xrange(4): + for i in range(4): out.append(src[(32 * i) + 31:(32 * i) + 32]) return [m2_expr.ExprAssign(dst, m2_expr.ExprCompose(*out).zeroExtend(dst.size))], [] def movmskpd(ir, instr, dst, src): out = [] - for i in xrange(2): + for i in range(2): out.append(src[(64 * i) + 63:(64 * i) + 64]) return [m2_expr.ExprAssign(dst, m2_expr.ExprCompose(*out).zeroExtend(dst.size))], [] @@ -5720,7 +5761,7 @@ class ir_x86_16(IntermediateRepresentation): irs = [] for assignblk in irblock: new_assignblk = dict(assignblk) - for dst, src in assignblk.iteritems(): + for dst, src in viewitems(assignblk): del new_assignblk[dst] # Special case for 64 bits: # If destination is a 32 bit reg, zero extend the 64 bit reg |