diff options
Diffstat (limited to 'miasm2/arch')
| -rw-r--r-- | miasm2/arch/aarch64/arch.py | 352 | ||||
| -rw-r--r-- | miasm2/arch/aarch64/regs.py | 32 | ||||
| -rw-r--r-- | miasm2/arch/aarch64/sem.py | 25 | ||||
| -rw-r--r-- | miasm2/arch/arm/arch.py | 1244 | ||||
| -rw-r--r-- | miasm2/arch/arm/ira.py | 4 | ||||
| -rw-r--r-- | miasm2/arch/arm/jit.py | 58 | ||||
| -rw-r--r-- | miasm2/arch/arm/regs.py | 19 | ||||
| -rw-r--r-- | miasm2/arch/arm/sem.py | 628 | ||||
| -rw-r--r-- | miasm2/arch/mips32/arch.py | 91 | ||||
| -rw-r--r-- | miasm2/arch/mips32/jit.py | 38 | ||||
| -rw-r--r-- | miasm2/arch/mips32/regs.py | 13 | ||||
| -rw-r--r-- | miasm2/arch/mips32/sem.py | 42 | ||||
| -rw-r--r-- | miasm2/arch/msp430/arch.py | 112 | ||||
| -rw-r--r-- | miasm2/arch/ppc/arch.py | 64 | ||||
| -rw-r--r-- | miasm2/arch/sh4/arch.py | 288 | ||||
| -rw-r--r-- | miasm2/arch/sh4/regs.py | 28 | ||||
| -rw-r--r-- | miasm2/arch/x86/arch.py | 404 |
17 files changed, 2397 insertions, 1045 deletions
diff --git a/miasm2/arch/aarch64/arch.py b/miasm2/arch/aarch64/arch.py index 2712e60a..94be74fd 100644 --- a/miasm2/arch/aarch64/arch.py +++ b/miasm2/arch/aarch64/arch.py @@ -1,6 +1,7 @@ #-*- coding:utf-8 -*- import logging +import math from pyparsing import * from miasm2.expression import expression as m2_expr from miasm2.core.cpu import * @@ -11,7 +12,7 @@ from regs import * from miasm2.core.asmblock import AsmLabel from miasm2.core.cpu import log as log_cpu from miasm2.expression.modint import uint32, uint64, mod_size2int -import math +from miasm2.core.asm_ast import AstInt, AstId, AstMem, AstOp log = logging.getLogger("aarch64dis") console_handler = logging.StreamHandler() @@ -68,43 +69,6 @@ replace_regs = { } -variable, operand, base_expr = gen_base_expr() -_, _, base_expr32 = gen_base_expr() -_, _, base_expr64 = gen_base_expr() - - -def ast_id2expr32(t): - if t in mn_aarch64.regs.all_regs_ids_byname: - t = mn_aarch64.regs.all_regs_ids_byname[t] - if not t.size == 32: - raise StopIteration - return t - -def ast_int2expr32(a): - return m2_expr.ExprInt(a, 32) - - -def ast_id2expr64(t): - if t in mn_aarch64.regs.all_regs_ids_byname: - t = mn_aarch64.regs.all_regs_ids_byname[t] - if not t.size == 64: - raise StopIteration - return t - - -def ast_int2expr64(a): - return m2_expr.ExprInt(a, 64) - -my_var_parser32 = ParseAst(ast_id2expr32, ast_int2expr32, default_size=32) -my_var_parser64 = ParseAst(ast_id2expr64, ast_int2expr64, default_size=64) - -base_expr32.setParseAction(my_var_parser32) -base_expr64.setParseAction(my_var_parser64) - - -int_or_expr = base_expr -int_or_expr32 = base_expr32 -int_or_expr64 = base_expr64 shift2expr_dct = {'LSL': '<<', 'LSR': '>>', 'ASR': 'a>>', 'ROR': '>>>'} @@ -112,121 +76,90 @@ shift_str = ["LSL", "LSR", "ASR", "ROR"] shift_expr = ["<<", ">>", "a>>", '>>>'] -def op_shift2expr(s, l, t): - return shift2expr_dct[t[0]] - +def cb_shift(tokens): + return shift2expr_dct[tokens[0]] -def op_shift2expr_slice_at(s, l, t): - return "slice_at" +def cb_extreg(tokens): + return tokens[0] -def op_ext_reg(s, l, t): - return t[0] - -def shift2expr(t): - if len(t) == 1: - return t[0] - elif len(t) == 3: - if t[0].size == 32 and isinstance(t[2], m2_expr.ExprInt): - t[2] = m2_expr.ExprInt(int(t[2]), 32) - return m2_expr.ExprOp(t[1], t[0], t[2]) +def cb_shiftreg(tokens): + if len(tokens) == 1: + return tokens[0] + elif len(tokens) == 3: + result = AstOp(tokens[1], tokens[0], tokens[2]) + return result else: raise ValueError('bad string') -def shift2expr_sc(t): - if len(t) == 1: - return t[0] - elif len(t) == 3: - if t[0].size == 32 and isinstance(t[2], m2_expr.ExprInt): - t[2] = m2_expr.ExprInt(t[2].arg, 32) - if t[1] != '<<': +def cb_shift_sc(tokens): + if len(tokens) == 1: + return tokens[0] + elif len(tokens) == 3: + if tokens[1] != '<<': raise ValueError('bad op') - return m2_expr.ExprOp("slice_at", t[0], t[2]) + result = AstOp("slice_at", tokens[0], tokens[2]) + return result else: raise ValueError('bad string') -def extend2expr(t): - if len(t) == 1: - return t[0] - return m2_expr.ExprOp(t[1], t[0], t[2]) - +def cb_extend(tokens): + if len(tokens) == 1: + return tokens[0] + result = AstOp(tokens[1], tokens[0], tokens[2]) + return result -def shiftext2expr(t): - if len(t) == 1: - return t[0] - else: - return m2_expr.ExprOp(t[1], t[0], t[2]) -def expr_deref_pc_off(t): - t = t[0] - if len(t) == 2 and t[0] == "PC": - return ExprOp('preinc', PC, t[1]) +def cb_deref_pc_off(tokens): + if len(tokens) == 2 and tokens[0] == "PC": + result = AstOp('preinc', AstId(ExprId('PC', 64)), tokens[1]) + return result raise ValueError('bad string') -def expr_deref_pc_nooff(t): - t = t[0] - if len(t) == 1 and t[0] == "PC": - return ExprOp('preinc', PC) +def cb_deref_pc_nooff(tokens): + if len(tokens) == 1 and tokens[0] == "PC": + result = AstOp('preinc', AstId(PC)) + return result raise ValueError('bad string') -all_binaryop_lsl_t = literal_list( - shift_str).setParseAction(op_shift2expr) +all_binaryop_lsl_t = literal_list(shift_str).setParseAction(cb_shift) -all_binaryop_shiftleft_t = literal_list( - ["LSL"]).setParseAction(op_shift2expr) +all_binaryop_shiftleft_t = literal_list(["LSL"]).setParseAction(cb_shift) extend_lst = ['UXTB', 'UXTH', 'UXTW', 'UXTX', 'SXTB', 'SXTH', 'SXTW', 'SXTX'] extend2_lst = ['UXTW', 'LSL', 'SXTW', 'SXTX'] -all_extend_t = literal_list(extend_lst).setParseAction(op_ext_reg) -all_extend2_t = literal_list(extend2_lst).setParseAction(op_ext_reg) +all_extend_t = literal_list(extend_lst).setParseAction(cb_extreg) +all_extend2_t = literal_list(extend2_lst).setParseAction(cb_extreg) -gpregz32_extend = (gpregsz32_info.parser + Optional( - all_extend_t + int_or_expr32)).setParseAction(extend2expr) -gpregz64_extend = (gpregsz64_info.parser + Optional( - all_extend_t + int_or_expr64)).setParseAction(extend2expr) +gpregz32_extend = (gpregsz32_info.parser + Optional(all_extend_t + base_expr)).setParseAction(cb_extend) +gpregz64_extend = (gpregsz64_info.parser + Optional(all_extend_t + base_expr)).setParseAction(cb_extend) -shift32_off = (gpregsz32_info.parser + Optional(all_binaryop_lsl_t + - (gpregs32_info.parser | int_or_expr))).setParseAction(shift2expr) -shift64_off = (gpregsz64_info.parser + Optional(all_binaryop_lsl_t + - (gpregs64_info.parser | int_or_expr))).setParseAction(shift2expr) +shift32_off = (gpregsz32_info.parser + Optional(all_binaryop_lsl_t + base_expr)).setParseAction(cb_shiftreg) +shift64_off = (gpregsz64_info.parser + Optional(all_binaryop_lsl_t + base_expr)).setParseAction(cb_shiftreg) -shiftimm_imm_sc = (int_or_expr + all_binaryop_shiftleft_t + - int_or_expr).setParseAction(shift2expr_sc) +shiftimm_imm_sc = (base_expr + all_binaryop_shiftleft_t + base_expr).setParseAction(cb_shift_sc) -shiftimm_off_sc = shiftimm_imm_sc | int_or_expr +shiftimm_off_sc = shiftimm_imm_sc | base_expr shift_off = (shift32_off | shift64_off) reg_ext_off = (gpregz32_extend | gpregz64_extend) gpregs_32_64 = (gpregs32_info.parser | gpregs64_info.parser) -gpregsz_32_64 = (gpregsz32_info.parser | gpregsz64_info.parser | int_or_expr) +gpregsz_32_64 = (gpregsz32_info.parser | gpregsz64_info.parser | base_expr) -simdregs = (simd08_info.parser | simd16_info.parser | - simd32_info.parser | simd64_info.parser) +simdregs = (simd08_info.parser | simd16_info.parser | simd32_info.parser | simd64_info.parser) simdregs_h = (simd32_info.parser | simd64_info.parser | simd128_info.parser) -simdregs_h_zero = (simd32_info.parser | - simd64_info.parser | simd128_info.parser | int_or_expr) - - -def ast_id2expr(t): - if not t in mn_aarch64.regs.all_regs_ids_byname: - r = m2_expr.ExprId(AsmLabel(t), 32) - else: - r = mn_aarch64.regs.all_regs_ids_byname[t] - return r - +simdregs_h_zero = (simd32_info.parser | simd64_info.parser | simd128_info.parser | base_expr) -def ast_int2expr(a): - return m2_expr.ExprInt(a, 64) gpregs_info = {32: gpregs32_info, 64: gpregs64_info} @@ -241,72 +174,66 @@ simds_info = {8: simd08_info, 128: simd128_info} -my_var_parser = ParseAst(ast_id2expr, ast_int2expr) -base_expr.setParseAction(my_var_parser) - -def deref2expr_nooff(t): - t = t[0] +def cb_deref_nooff(t): # XXX default - return m2_expr.ExprOp("preinc", t[0], m2_expr.ExprInt(0, 64)) + result = AstOp("preinc", t[0], AstInt(0)) + return result -def deref2expr_post(t): - t = t[0] - if t[1] in regs_module.all_regs_ids: +def cb_deref_post(t): + assert len(t) == 2 + if isinstance(t[1], AstId) and isinstance(t[1].name, ExprId): raise StopIteration - return m2_expr.ExprOp("postinc", t[0], t[1]) + result = AstOp("postinc", *t) + return result -def deref2expr_pre(t): - t = t[0] - if t[1] in regs_module.all_regs_ids: +def cb_deref_pre(t): + assert len(t) == 2 + if isinstance(t[1], AstId) and isinstance(t[1].name, ExprId): raise StopIteration - return m2_expr.ExprOp("preinc", t[0], t[1]) + result = AstOp("preinc", *t) + return result -def deref2expr_pre_wb(t): - t = t[0] - if t[1] in regs_module.all_regs_ids: +def cb_deref_pre_wb(t): + assert len(t) == 2 + if isinstance(t[1], AstId) and isinstance(t[1].name, ExprId): raise StopIteration - return m2_expr.ExprOp("preinc_wb", t[0], t[1]) + result = AstOp("preinc_wb", *t) + return result + LBRACK = Suppress("[") RBRACK = Suppress("]") COMMA = Suppress(",") POSTINC = Suppress("!") -deref_nooff = Group( - LBRACK + gpregs64_info.parser + RBRACK).setParseAction(deref2expr_nooff) -deref_off_post = Group(LBRACK + gpregs64_info.parser + - RBRACK + COMMA + int_or_expr64).setParseAction(deref2expr_post) -deref_off_pre = Group(LBRACK + gpregs64_info.parser + - COMMA + int_or_expr64 + RBRACK).setParseAction(deref2expr_pre) -deref_off_pre_wb = Group(LBRACK + gpregs64_info.parser + COMMA + - int_or_expr64 + RBRACK + POSTINC).setParseAction(deref2expr_pre_wb) +deref_nooff = (LBRACK + gpregs64_info.parser + RBRACK).setParseAction(cb_deref_nooff) +deref_off_post = (LBRACK + gpregs64_info.parser + RBRACK + COMMA + base_expr).setParseAction(cb_deref_post) +deref_off_pre = (LBRACK + gpregs64_info.parser + COMMA + base_expr + RBRACK).setParseAction(cb_deref_pre) +deref_off_pre_wb = (LBRACK + gpregs64_info.parser + COMMA + base_expr + RBRACK + POSTINC).setParseAction(cb_deref_pre_wb) deref = (deref_off_post | deref_off_pre_wb | deref_off_pre | deref_nooff) -deref_pc_off = Group(LBRACK + Literal("PC") + COMMA + int_or_expr64 + RBRACK).setParseAction(expr_deref_pc_off) -deref_pc_nooff = Group(LBRACK + Literal("PC") + RBRACK).setParseAction(expr_deref_pc_nooff) +deref_pc_off = (LBRACK + Literal("PC") + COMMA + base_expr + RBRACK).setParseAction(cb_deref_pc_off) +deref_pc_nooff = (LBRACK + Literal("PC") + RBRACK).setParseAction(cb_deref_pc_nooff) deref_pc = (deref_pc_off | deref_pc_nooff) -def deref_ext2op(t): - t = t[0] +def cb_deref_ext2op(t): if len(t) == 4: - expr = set_imm_to_size(t[1].size, t[3]) - if expr is None: - raise StopIteration - return m2_expr.ExprOp('segm', t[0], m2_expr.ExprOp(t[2], t[1], expr)) + result = AstOp('segm', t[0], AstOp(t[2], t[1], t[3])) + return result elif len(t) == 2: - return m2_expr.ExprOp('segm', t[0], t[1]) + result = AstOp('segm', *t) + return result raise ValueError("cad deref") -deref_ext2 = Group(LBRACK + gpregs_32_64 + COMMA + gpregs_32_64 + - Optional(all_extend2_t + int_or_expr) + RBRACK).setParseAction(deref_ext2op) +deref_ext2 = (LBRACK + gpregs_32_64 + COMMA + gpregs_32_64 + Optional(all_extend2_t + base_expr) + RBRACK).setParseAction(cb_deref_ext2op) class additional_info: @@ -335,6 +262,47 @@ conds_expr, _, conds_info = gen_regs(CONDS, {}) conds_inv_expr, _, conds_inv_info = gen_regs(CONDS_INV, {}) + +class aarch64_arg(m_arg): + def asm_ast_to_expr(self, value, symbol_pool, size_hint=None, fixed_size=None): + if size_hint is None: + size_hint = 64 + if fixed_size is None: + fixed_size = set() + if isinstance(value, AstId): + if value.name in all_regs_ids_byname: + reg = all_regs_ids_byname[value.name] + fixed_size.add(reg.size) + return reg + if isinstance(value.name, ExprId): + fixed_size.add(value.name.size) + return value.name + label = symbol_pool.getby_name_create(value.name) + return ExprId(label, size_hint) + if isinstance(value, AstInt): + assert size_hint is not None + return ExprInt(value.value, size_hint) + if isinstance(value, AstOp): + if value.op == "segm": + segm = self.asm_ast_to_expr(value.args[0], symbol_pool) + ptr = self.asm_ast_to_expr(value.args[1], symbol_pool, None, fixed_size) + return ExprOp('segm', segm, ptr) + + args = [self.asm_ast_to_expr(arg, symbol_pool, None, fixed_size) for arg in value.args] + if len(fixed_size) == 0: + # No fixed size + pass + elif len(fixed_size) == 1: + # One fixed size, regen all + size = list(fixed_size)[0] + args = [self.asm_ast_to_expr(arg, symbol_pool, size, fixed_size) for arg in value.args] + else: + raise ValueError("Size conflict") + + return ExprOp(value.op, *args) + return None + + class instruction_aarch64(instruction): __slots__ = [] delayslot = 0 @@ -567,7 +535,7 @@ class aarch64_gpreg_noarg(reg_noarg): return True -class aarch64_simdreg(reg_noarg, m_arg): +class aarch64_simdreg(reg_noarg, aarch64_arg): parser = simdregs simd_size = [8, 16, 32, 64] @@ -619,7 +587,7 @@ class aarch64_simdreg_32_64_zero(aarch64_simdreg_32_64): return super(aarch64_simdreg_32_64_zero, self).encode() -class aarch64_gpreg_isf(reg_noarg, m_arg): +class aarch64_gpreg_isf(reg_noarg, aarch64_arg): parser = gpregs_32_64 def decode(self, v): @@ -635,7 +603,7 @@ class aarch64_gpreg_isf(reg_noarg, m_arg): return True -class aarch64_gpreg(aarch64_gpreg_noarg, m_arg): +class aarch64_gpreg(aarch64_gpreg_noarg, aarch64_arg): pass @@ -651,12 +619,12 @@ class aarch64_gpreg_n1(aarch64_gpreg): return self.value != 0b11111 -class aarch64_gpregz(aarch64_gpreg_noarg, m_arg): +class aarch64_gpregz(aarch64_gpreg_noarg, aarch64_arg): parser = gpregsz_32_64 gpregs_info = gpregsz_info -class aarch64_gpreg0(bsi, m_arg): +class aarch64_gpreg0(bsi, aarch64_arg): parser = gpregsz_32_64 gpregs_info = gpregsz_info @@ -684,7 +652,7 @@ class aarch64_gpreg0(bsi, m_arg): return True -class aarch64_crreg(reg_noarg, m_arg): +class aarch64_crreg(reg_noarg, aarch64_arg): reg_info = cr_info parser = reg_info.parser @@ -702,7 +670,7 @@ class aarch64_gpreg32_noarg(reg_noarg): parser = reg_info.parser -class aarch64_gpreg32(aarch64_gpreg32_noarg, m_arg): +class aarch64_gpreg32(aarch64_gpreg32_noarg, aarch64_arg): reg_info = gpregs32_info parser = reg_info.parser @@ -712,7 +680,7 @@ class aarch64_gpreg64_noarg(reg_noarg): parser = reg_info.parser -class aarch64_gpreg64(reg_noarg, m_arg): +class aarch64_gpreg64(reg_noarg, aarch64_arg): reg_info = gpregs64_info parser = reg_info.parser @@ -722,7 +690,7 @@ class aarch64_gpregz32_noarg(reg_noarg): parser = reg_info.parser -class aarch64_gpregz32(aarch64_gpreg32_noarg, m_arg): +class aarch64_gpregz32(aarch64_gpreg32_noarg, aarch64_arg): reg_info = gpregsz32_info parser = reg_info.parser @@ -732,7 +700,7 @@ class aarch64_gpregz64_noarg(reg_noarg): parser = reg_info.parser -class aarch64_gpregz64(reg_noarg, m_arg): +class aarch64_gpregz64(reg_noarg, aarch64_arg): reg_info = gpregsz64_info parser = reg_info.parser @@ -742,7 +710,7 @@ class aarch64_simd08_noarg(reg_noarg): parser = reg_info.parser -class aarch64_simd08(aarch64_simd08_noarg, m_arg): +class aarch64_simd08(aarch64_simd08_noarg, aarch64_arg): reg_info = simd08_info parser = reg_info.parser @@ -752,7 +720,7 @@ class aarch64_simd16_noarg(reg_noarg): parser = reg_info.parser -class aarch64_simd16(aarch64_simd16_noarg, m_arg): +class aarch64_simd16(aarch64_simd16_noarg, aarch64_arg): reg_info = simd16_info parser = reg_info.parser @@ -762,7 +730,7 @@ class aarch64_simd32_noarg(reg_noarg): parser = reg_info.parser -class aarch64_simd32(aarch64_simd32_noarg, m_arg): +class aarch64_simd32(aarch64_simd32_noarg, aarch64_arg): reg_info = simd32_info parser = reg_info.parser @@ -772,7 +740,7 @@ class aarch64_simd64_noarg(reg_noarg): parser = reg_info.parser -class aarch64_simd64(aarch64_simd64_noarg, m_arg): +class aarch64_simd64(aarch64_simd64_noarg, aarch64_arg): reg_info = simd64_info parser = reg_info.parser @@ -782,12 +750,12 @@ class aarch64_simd128_noarg(reg_noarg): parser = reg_info.parser -class aarch64_simd128(aarch64_simd128_noarg, m_arg): +class aarch64_simd128(aarch64_simd128_noarg, aarch64_arg): reg_info = simd128_info parser = reg_info.parser -class aarch64_imm_32(imm_noarg, m_arg): +class aarch64_imm_32(imm_noarg, aarch64_arg): parser = base_expr @@ -810,7 +778,7 @@ class aarch64_uint64_noarg(imm_noarg): int2expr = lambda self, x: m2_expr.ExprInt(x, 64) -class aarch64_uint64(aarch64_uint64_noarg, m_arg): +class aarch64_uint64(aarch64_uint64_noarg, aarch64_arg): parser = base_expr @@ -829,8 +797,8 @@ def set_imm_to_size(size, expr): class aarch64_imm_sf(imm_noarg): parser = base_expr - def fromstring(self, s, parser_result=None): - start, stop = super(aarch64_imm_sf, self).fromstring(s, parser_result) + def fromstring(self, text, symbol_pool, parser_result=None): + start, stop = super(aarch64_imm_sf, self).fromstring(text, symbol_pool, parser_result) if start is None: return start, stop size = self.parent.args[0].expr.size @@ -861,7 +829,7 @@ class aarch64_imm_sf(imm_noarg): return True -class aarch64_imm_sft(aarch64_imm_sf, m_arg): +class aarch64_imm_sft(aarch64_imm_sf, aarch64_arg): def encode(self): if not isinstance(self.expr, m2_expr.ExprInt): @@ -895,7 +863,7 @@ OPTION2SIZE = [32, 32, 32, 64, 32, 32, 32, 64] -class aarch64_gpreg_ext(reg_noarg, m_arg): +class aarch64_gpreg_ext(reg_noarg, aarch64_arg): parser = reg_ext_off def encode(self): @@ -934,7 +902,7 @@ EXT2_OP = {0b010: 'UXTW', EXT2_OP_INV = dict([(items[1], items[0]) for items in EXT2_OP.items()]) -class aarch64_gpreg_ext2(reg_noarg, m_arg): +class aarch64_gpreg_ext2(reg_noarg, aarch64_arg): parser = deref_ext2 def get_size(self): @@ -946,6 +914,12 @@ class aarch64_gpreg_ext2(reg_noarg, m_arg): if len(self.expr.args) != 2: return False arg0, arg1 = self.expr.args + if (self.expr.is_op("preinc") and arg0.is_id() and arg1.is_id()): + self.parent.shift.value = 0 + self.parent.rn.value = self.parent.rn.reg_info.expr.index(arg0) + self.value = gpregs_info[arg1.size].expr.index(arg1) + self.parent.option.value = 0b011 + return True if not (isinstance(self.expr, m2_expr.ExprOp) and self.expr.op == 'segm'): return False if not arg0 in self.parent.rn.reg_info.expr: @@ -1022,7 +996,7 @@ def test_set_sf(parent, size): return psize == size -class aarch64_gpreg_sftimm(reg_noarg, m_arg): +class aarch64_gpreg_sftimm(reg_noarg, aarch64_arg): reg_info = gpregsz_info parser = shift_off @@ -1266,7 +1240,7 @@ def EncodeBitMasks(wmask): return immr, imms, immn -class aarch64_imm_nsr(aarch64_imm_sf, m_arg): +class aarch64_imm_nsr(aarch64_imm_sf, aarch64_arg): parser = base_expr def decode(self, v): @@ -1347,7 +1321,7 @@ class aarch64_immhi_page(aarch64_imm_32): return True -class aarch64_imm_hw(m_arg): +class aarch64_imm_hw(aarch64_arg): parser = base_expr shift_op = '<<' @@ -1373,7 +1347,7 @@ class aarch64_imm_hw(m_arg): return False -class aarch64_imm_hw_sc(m_arg): +class aarch64_imm_hw_sc(aarch64_arg): parser = shiftimm_off_sc shift_op = 'slice_at' @@ -1415,7 +1389,7 @@ class aarch64_imm_hw_sc(m_arg): return True -class aarch64_offs(imm_noarg, m_arg): +class aarch64_offs(imm_noarg, aarch64_arg): parser = base_expr def decode(self, v): @@ -1436,7 +1410,7 @@ class aarch64_offs(imm_noarg, m_arg): -class aarch64_offs_pc(imm_noarg, m_arg): +class aarch64_offs_pc(imm_noarg, aarch64_arg): parser = deref_pc def decode(self, v): @@ -1490,7 +1464,7 @@ def get_size(parent): return size -class aarch64_deref(m_arg): +class aarch64_deref(aarch64_arg): parser = deref def decode_w_size(self, off): @@ -1628,17 +1602,17 @@ modf = bs_mod_name(l=1, fname='modf', mn_mod=['', 'S']) sf = bs(l=1, fname='sf', order=-1) -class aarch64_cond_arg(reg_noarg, m_arg): +class aarch64_cond_arg(reg_noarg, aarch64_arg): reg_info = conds_info parser = reg_info.parser -class aarch64_cond_inv_arg(reg_noarg, m_arg): +class aarch64_cond_inv_arg(reg_noarg, aarch64_arg): reg_info = conds_inv_info parser = reg_info.parser -class aarch64_b40(m_arg): +class aarch64_b40(aarch64_arg): parser = base_expr def decode(self, v): @@ -1745,19 +1719,19 @@ imm_sft_12 = bs(l=12, cls=(aarch64_imm_sft,)) imm32_3 = bs(l=3, fname="imm") imm6 = bs(l=6, fname="imm", order=-1) imm3 = bs(l=3, fname="imm", order=-1) -simm6 = bs(l=6, cls=(aarch64_int64_noarg, m_arg), fname="imm", order=-1) +simm6 = bs(l=6, cls=(aarch64_int64_noarg, aarch64_arg), fname="imm", order=-1) simm9 = bs(l=9, cls=(aarch64_int64_noarg,), fname="imm", order=-1) simm7 = bs(l=7, cls=(aarch64_int64_noarg,), fname="imm", order=-1) -nzcv = bs(l=4, cls=(aarch64_uint64_noarg, m_arg), fname="nzcv", order=-1) -uimm5 = bs(l=5, cls=(aarch64_uint64_noarg, m_arg), fname="imm", order=-1) +nzcv = bs(l=4, cls=(aarch64_uint64_noarg, aarch64_arg), fname="nzcv", order=-1) +uimm5 = bs(l=5, cls=(aarch64_uint64_noarg, aarch64_arg), fname="imm", order=-1) uimm12 = bs(l=12, cls=(aarch64_uint64_noarg,), fname="imm", order=-1) -uimm16 = bs(l=16, cls=(aarch64_uint64_noarg, m_arg), fname="imm", order=-1) +uimm16 = bs(l=16, cls=(aarch64_uint64_noarg, aarch64_arg), fname="imm", order=-1) uimm7 = bs(l=7, cls=(aarch64_uint64_noarg,), fname="imm", order=-1) uimm8 = bs(l=8, cls=(aarch64_uint64,), fname="imm", order=-1) -op1 = bs(l=3, cls=(aarch64_uint64, m_arg), fname="op1") -op2 = bs(l=3, cls=(aarch64_uint64, m_arg), fname="op2") +op1 = bs(l=3, cls=(aarch64_uint64, aarch64_arg), fname="op1") +op2 = bs(l=3, cls=(aarch64_uint64, aarch64_arg), fname="op2") imm16 = bs(l=16, fname="imm", order=-1) @@ -1787,8 +1761,8 @@ imm16_hw_sc = bs(l=16, cls=(aarch64_imm_hw_sc,), fname='imm') hw = bs(l=2, fname='hw') -a_imms = bs(l=6, cls=(aarch64_imm_sf, m_arg), fname="imm1", order=-1) -a_immr = bs(l=6, cls=(aarch64_imm_sf, m_arg), fname="imm1", order=-1) +a_imms = bs(l=6, cls=(aarch64_imm_sf, aarch64_arg), fname="imm1", order=-1) +a_immr = bs(l=6, cls=(aarch64_imm_sf, aarch64_arg), fname="imm1", order=-1) diff --git a/miasm2/arch/aarch64/regs.py b/miasm2/arch/aarch64/regs.py index f2655ea7..c9da0653 100644 --- a/miasm2/arch/aarch64/regs.py +++ b/miasm2/arch/aarch64/regs.py @@ -45,9 +45,13 @@ simd128_expr, simd128_init, simd128_info = gen_regs( simd128_str, globals(), 128) -PC, PC_init = gen_reg("PC", globals(), 64) -WZR, WZR_init = gen_reg("WZR", globals(), 32) -XZR, XZR_init = gen_reg("XZR", globals(), 64) +PC, _ = gen_reg("PC", 64) +WZR, _ = gen_reg("WZR", 32) +XZR, _ = gen_reg("XZR", 64) + +PC_init = ExprId("PC_init", 64) +WZR_init = ExprId("WZR_init", 32) +XZR_init = ExprId("XZR_init", 64) reg_zf = 'zf' reg_nf = 'nf' @@ -87,11 +91,12 @@ all_regs_ids = [ X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15, X16, X17, X18, X19, X20, X21, X22, X23, X24, X25, X26, X27, X28, X29, LR, SP, - exception_flags, interrupt_num, + exception_flags, + interrupt_num, PC, WZR, + XZR, zf, nf, of, cf, - XZR ] @@ -105,22 +110,7 @@ attrib_to_regs = { all_regs_ids_byname = dict([(x.name, x) for x in all_regs_ids]) -all_regs_ids_init = (simd08_init + - simd16_init + - simd32_init + - simd64_init + - simd128_init + - gpregs32_init + - gpregs64_init + - [ - ExprInt(0, 32), - PC_init, - WZR_init, - XZR_init, - zf_init, nf_init, of_init, cf_init, - ExprInt(0, 64), ExprInt(0, 32), - ] - ) +all_regs_ids_init = [ExprId("%s_init" % x.name, x.size) for x in all_regs_ids] regs_init = {} for i, r in enumerate(all_regs_ids): diff --git a/miasm2/arch/aarch64/sem.py b/miasm2/arch/aarch64/sem.py index 2799df7a..88b0d0a7 100644 --- a/miasm2/arch/aarch64/sem.py +++ b/miasm2/arch/aarch64/sem.py @@ -124,9 +124,32 @@ def extend_arg(dst, arg): return arg op, (reg, shift) = arg.op, arg.args - if op == 'SXTW': + if op == "SXTB": + base = reg[:8].signExtend(dst.size) + op = "<<" + elif op == "SXTH": + base = reg[:16].signExtend(dst.size) + op = "<<" + elif op == 'SXTW': + base = reg[:32].signExtend(dst.size) + op = "<<" + elif op == "SXTX": base = reg.signExtend(dst.size) op = "<<" + + elif op == "UXTB": + base = reg[:8].zeroExtend(dst.size) + op = "<<" + elif op == "UXTH": + base = reg[:16].zeroExtend(dst.size) + op = "<<" + elif op == 'UXTW': + base = reg[:32].zeroExtend(dst.size) + op = "<<" + elif op == "UXTX": + base = reg.zeroExtend(dst.size) + op = "<<" + elif op in ['<<', '>>', '<<a', 'a>>', '<<<', '>>>']: base = reg.zeroExtend(dst.size) else: diff --git a/miasm2/arch/arm/arch.py b/miasm2/arch/arm/arch.py index 39b4cb14..35574a84 100644 --- a/miasm2/arch/arm/arch.py +++ b/miasm2/arch/arm/arch.py @@ -8,6 +8,7 @@ from collections import defaultdict from miasm2.core.bin_stream import bin_stream import miasm2.arch.arm.regs as regs_module from miasm2.arch.arm.regs import * +from miasm2.core.asm_ast import AstInt, AstId, AstMem, AstOp # A1 encoding @@ -20,7 +21,7 @@ log.setLevel(logging.DEBUG) # arm regs ############## reg_dum = ExprId('DumReg', 32) -gen_reg('PC', globals()) +PC, _ = gen_reg('PC') # GP regs_str = ['R%d' % r for r in xrange(0x10)] @@ -40,6 +41,9 @@ gpregs_nosppc = reg_info(regs_str[:13] + [str(reg_dum), regs_str[14]], gpregs_nopc = reg_info(regs_str[:14], regs_expr[:14]) +gpregs_nosp = reg_info(regs_str[:13] + [str(reg_dum), regs_str[14], regs_str[15]], + regs_expr[:13] + [reg_dum, regs_expr[14], regs_expr[15]]) + # psr sr_flags = "cxsf" @@ -81,15 +85,33 @@ conditional_branch = ["BEQ", "BNE", "BCS", "BCC", "BMI", "BPL", "BVS", unconditional_branch = ["B", "BX", "BL", "BLX"] +barrier_expr = { + 0b1111: ExprId("SY", 32), + 0b1110: ExprId("ST", 32), + 0b1101: ExprId("LD", 32), + 0b1011: ExprId("ISH", 32), + 0b1010: ExprId("ISHST", 32), + 0b1001: ExprId("ISHLD", 32), + 0b0111: ExprId("NSH", 32), + 0b0110: ExprId("NSHST", 32), + 0b0011: ExprId("OSH", 32), + 0b0010: ExprId("OSHST", 32), + 0b0001: ExprId("OSHLD", 32), +} + +barrier_info = reg_info_dct(barrier_expr) + + + # parser helper ########### -def tok_reg_duo(s, l, t): - t = t[0] - i1 = gpregs.expr.index(t[0]) - i2 = gpregs.expr.index(t[1]) +def cb_tok_reg_duo(tokens): + tokens = tokens[0] + i1 = gpregs.expr.index(tokens[0].name) + i2 = gpregs.expr.index(tokens[1].name) o = [] for i in xrange(i1, i2 + 1): - o.append(gpregs.expr[i]) + o.append(AstId(gpregs.expr[i])) return o LPARENTHESIS = Literal("(") @@ -103,14 +125,14 @@ CIRCUNFLEX = Literal("^") def check_bounds(left_bound, right_bound, value): if left_bound <= value and value <= right_bound: - return ExprInt(value, 32) + return AstInt(value) else: raise ValueError('shift operator immediate value out of bound') def check_values(values, value): if value in values: - return ExprInt(value, 32) + return AstInt(value) else: raise ValueError('shift operator immediate value out of bound') @@ -120,11 +142,11 @@ int_1_32 = str_int.copy().setParseAction(lambda v: check_bounds(1, 32, v[0])) int_8_16_24 = str_int.copy().setParseAction(lambda v: check_values([8, 16, 24], v[0])) -def reglistparse(s, l, t): - t = t[0] - if t[-1] == "^": - return ExprOp('sbit', ExprOp('reglist', *t[:-1])) - return ExprOp('reglist', *t) +def cb_reglistparse(tokens): + tokens = tokens[0] + if tokens[-1] == "^": + return AstOp('sbit', AstOp('reglist', *tokens[:-1])) + return AstOp('reglist', *tokens) allshifts = ['<<', '>>', 'a>>', '>>>', 'rrx'] @@ -136,15 +158,15 @@ shift2expr_dct = {'LSL': '<<', 'LSR': '>>', 'ASR': 'a>>', expr2shift_dct = dict([(x[1], x[0]) for x in shift2expr_dct.items()]) -def op_shift2expr(s, l, t): - return shift2expr_dct[t[0]] +def op_shift2expr(tokens): + return shift2expr_dct[tokens[0]] reg_duo = Group(gpregs.parser + MINUS + - gpregs.parser).setParseAction(tok_reg_duo) + gpregs.parser).setParseAction(cb_tok_reg_duo) reg_or_duo = reg_duo | gpregs.parser gpreg_list = Group(LACC + delimitedList( reg_or_duo, delim=',') + RACC + Optional(CIRCUNFLEX)) -gpreg_list.setParseAction(reglistparse) +gpreg_list.setParseAction(cb_reglistparse) LBRACK = Suppress("[") RBRACK = Suppress("]") @@ -166,111 +188,132 @@ gpreg_p = gpregs.parser psr_p = cpsr_regs.parser | spsr_regs.parser -def shift2expr(t): - if len(t) == 1: - return t[0] - elif len(t) == 2: - return ExprOp(t[1], t[0]) - elif len(t) == 3: - return ExprOp(t[1], t[0], t[2]) +def cb_shift(tokens): + if len(tokens) == 1: + ret = tokens[0] + elif len(tokens) == 2: + ret = AstOp(tokens[1], tokens[0]) + elif len(tokens) == 3: + ret = AstOp(tokens[1], tokens[0], tokens[2]) + else: + raise ValueError("Bad arg") + return ret -variable, operand, base_expr = gen_base_expr() +shift_off = (gpregs.parser + Optional( + (all_unaryop_shifts_t) | + (all_binaryop_1_31_shifts_t + (gpregs.parser | int_1_31)) | + (all_binaryop_1_32_shifts_t + (gpregs.parser | int_1_32)) +)).setParseAction(cb_shift) +shift_off |= base_expr -int_or_expr = base_expr +rot2_expr = (gpregs.parser + Optional( + (ror_shifts_t + (int_8_16_24)) +)).setParseAction(cb_shift) -def ast_id2expr(t): - return mn_arm.regs.all_regs_ids_byname.get(t, t) +OP_LSL = Suppress("LSL") -def ast_int2expr(a): - return ExprInt(a, 32) +def cb_deref_reg_reg(tokens): + if len(tokens) != 2: + raise ValueError("Bad mem format") + return AstMem(AstOp('+', tokens[0], tokens[1]), 8) +def cb_deref_reg_reg_lsl_1(tokens): + if len(tokens) != 3: + raise ValueError("Bad mem format") + reg1, reg2, index = tokens + if not isinstance(index, AstInt) or index.value != 1: + raise ValueError("Bad index") + ret = AstMem(AstOp('+', reg1, AstOp('<<', reg2, index)), 16) + return ret -my_var_parser = ParseAst(ast_id2expr, ast_int2expr) -base_expr.setParseAction(my_var_parser) +deref_reg_reg = (LBRACK + gpregs.parser + COMMA + gpregs.parser + RBRACK).setParseAction(cb_deref_reg_reg) +deref_reg_reg_lsl_1 = (LBRACK + gpregs.parser + COMMA + gpregs.parser + OP_LSL + base_expr + RBRACK).setParseAction(cb_deref_reg_reg_lsl_1) -shift_off = (gpregs.parser + Optional( - (all_unaryop_shifts_t) | - (all_binaryop_1_31_shifts_t + (gpregs.parser | int_1_31)) | - (all_binaryop_1_32_shifts_t + (gpregs.parser | int_1_32)) -)).setParseAction(shift2expr) -shift_off |= base_expr -rot2_expr = (gpregs.parser + Optional( +(gpregs.parser + Optional( (ror_shifts_t + (int_8_16_24)) -)).setParseAction(shift2expr) +)).setParseAction(cb_shift) -def deref2expr_nooff(s, l, t): - t = t[0] +reg_or_base = gpregs.parser | base_expr + +def deref2expr_nooff(tokens): + tokens = tokens[0] # XXX default - return ExprOp("preinc", t[0], ExprInt(0, 32)) + return ExprOp("preinc", tokens[0], ExprInt(0, 32)) -def deref2expr_pre(s, l, t): - t = t[0] - if len(t) == 1: - return ExprOp("preinc", t[0], ExprInt(0, 32)) - elif len(t) == 2: - return ExprOp("preinc", t[0], t[1]) +def cb_deref_preinc(tokens): + tokens = tokens[0] + if len(tokens) == 1: + return AstOp("preinc", tokens[0], AstInt(0)) + elif len(tokens) == 2: + return AstOp("preinc", tokens[0], tokens[1]) else: - raise NotImplementedError('len(t) > 2') + raise NotImplementedError('len(tokens) > 2') -def deref2expr_pre_mem(s, l, t): - t = t[0] - if len(t) == 1: - return ExprMem(ExprOp("preinc", t[0], ExprInt(0, 32)), 32) - elif len(t) == 2: - return ExprMem(ExprOp("preinc", t[0], t[1]), 32) +def cb_deref_pre_mem(tokens): + tokens = tokens[0] + if len(tokens) == 1: + return AstMem(AstOp("preinc", tokens[0], AstInt(0)), 32) + elif len(tokens) == 2: + return AstMem(AstOp("preinc", tokens[0], tokens[1]), 32) else: - raise NotImplementedError('len(t) > 2') + raise NotImplementedError('len(tokens) > 2') -def deref2expr_post(s, l, t): - t = t[0] - return ExprOp("postinc", t[0], t[1]) +def cb_deref_post(tokens): + tokens = tokens[0] + return AstOp("postinc", tokens[0], tokens[1]) -def deref_wb(s, l, t): - t = t[0] - if t[-1] == '!': - return ExprMem(ExprOp('wback', *t[:-1]), 32) - return ExprMem(t[0], 32) +def cb_deref_wb(tokens): + tokens = tokens[0] + if tokens[-1] == '!': + return AstMem(AstOp('wback', *tokens[:-1]), 32) + return AstMem(tokens[0], 32) # shift_off.setParseAction(deref_off) deref_nooff = Group( LBRACK + gpregs.parser + RBRACK).setParseAction(deref2expr_nooff) deref_pre = Group(LBRACK + gpregs.parser + Optional( - COMMA + shift_off) + RBRACK).setParseAction(deref2expr_pre) + COMMA + shift_off) + RBRACK).setParseAction(cb_deref_preinc) deref_post = Group(LBRACK + gpregs.parser + RBRACK + - COMMA + shift_off).setParseAction(deref2expr_post) + COMMA + shift_off).setParseAction(cb_deref_post) deref = Group((deref_post | deref_pre | deref_nooff) - + Optional('!')).setParseAction(deref_wb) + + Optional('!')).setParseAction(cb_deref_wb) -def parsegpreg_wb(s, l, t): - t = t[0] - if t[-1] == '!': - return ExprOp('wback', *t[:-1]) - return t[0] +def cb_gpreb_wb(tokens): + assert len(tokens) == 1 + tokens = tokens[0] + if tokens[-1] == '!': + return AstOp('wback', *tokens[:-1]) + return tokens[0] -gpregs_wb = Group(gpregs.parser + Optional('!')).setParseAction(parsegpreg_wb) +gpregs_wb = Group(gpregs.parser + Optional('!')).setParseAction(cb_gpreb_wb) -# +cond_list_full = ['EQ', 'NE', 'CS', 'CC', 'MI', 'PL', 'VS', 'VC', + 'HI', 'LS', 'GE', 'LT', 'GT', 'LE', 'NV'] cond_list = ['EQ', 'NE', 'CS', 'CC', 'MI', 'PL', 'VS', 'VC', 'HI', 'LS', 'GE', 'LT', 'GT', 'LE', ''] # , 'NV'] cond_dct = dict([(x[1], x[0]) for x in enumerate(cond_list)]) -# default_prio = 0x1337 +bm_cond = bs_mod_name(l=4, fname='cond', mn_mod=cond_list) + + + +cond_dct_barmt = dict([(x[0], x[1]) for x in enumerate(cond_list) if x[0] & 0b1110 != 0b1110]) +bm_cond_barmt = bs_mod_name(l=4, fname='cond', mn_mod=cond_dct_barmt) -bm_cond = bs_mod_name(l=4, fname='cond', mn_mod=cond_list) # cond_dct) def permut_args(order, args): @@ -457,7 +500,11 @@ class instruction_armt(instruction_arm): if self.name == 'BLX': ad = e.arg + (self.offset & 0xfffffffc) elif self.name == 'BL': - ad = e.arg + self.offset + self.l + ad = e.arg + self.offset + elif self.name.startswith('BP'): + ad = e.arg + self.offset + elif self.name.startswith('CB'): + ad = e.arg + self.offset + self.l + 2 else: ad = e.arg + self.offset l = symbol_pool.getby_offset_create(ad) @@ -468,7 +515,7 @@ class instruction_armt(instruction_arm): self.args[0] = s def breakflow(self): - if self.name in conditional_branch + unconditional_branch +["CBZ", "CBNZ"]: + if self.name in conditional_branch + unconditional_branch +["CBZ", "CBNZ", 'TBB', 'TBH']: return True if self.name.startswith("LDM") and PC in self.args[1].args: return True @@ -720,7 +767,31 @@ class mn_armt(cls_mn): return 32 -class arm_reg(reg_noarg, m_arg): +class arm_arg(m_arg): + def asm_ast_to_expr(self, arg, symbol_pool): + if isinstance(arg, AstId): + if isinstance(arg.name, ExprId): + return arg.name + if arg.name in gpregs.str: + return None + label = symbol_pool.getby_name_create(arg.name) + return ExprId(label, 32) + if isinstance(arg, AstOp): + args = [self.asm_ast_to_expr(tmp, symbol_pool) for tmp in arg.args] + if None in args: + return None + return ExprOp(arg.op, *args) + if isinstance(arg, AstInt): + return ExprInt(arg.value, 32) + if isinstance(arg, AstMem): + ptr = self.asm_ast_to_expr(arg.ptr, symbol_pool) + if ptr is None: + return None + return ExprMem(ptr, arg.size) + return None + + +class arm_reg(reg_noarg, arm_arg): pass @@ -760,7 +831,7 @@ class arm_reg_wb(arm_reg): return True -class arm_psr(m_arg): +class arm_psr(arm_arg): parser = psr_p def decode(self, v): @@ -796,7 +867,7 @@ class arm_preg(arm_reg): parser = reg_info.parser -class arm_imm(imm_noarg, m_arg): +class arm_imm(imm_noarg, arm_arg): parser = base_expr @@ -840,7 +911,7 @@ class arm_offs(arm_imm): return True -class arm_imm8_12(m_arg): +class arm_imm8_12(arm_arg): parser = deref def decode(self, v): @@ -896,8 +967,8 @@ class arm_imm8_12(m_arg): return True -class arm_imm_4_12(m_arg): - parser = base_expr +class arm_imm_4_12(arm_arg): + parser = reg_or_base def decode(self, v): v = v & self.lmask @@ -916,7 +987,7 @@ class arm_imm_4_12(m_arg): return True -class arm_imm_12_4(m_arg): +class arm_imm_12_4(arm_arg): parser = base_expr def decode(self, v): @@ -936,7 +1007,7 @@ class arm_imm_12_4(m_arg): return True -class arm_op2(m_arg): +class arm_op2(arm_arg): parser = shift_off def str_to_imm_rot_form(self, s, neg=False): @@ -1108,7 +1179,7 @@ class arm_op2imm(arm_imm8_12): # if len(v) <1: # raise ValueError('cannot parse', s) - self.parent.rn.fromstring(e.args[0]) + self.parent.rn.expr = e.args[0] if len(e.args) == 1: self.parent.immop.value = 0 self.value = 0 @@ -1169,7 +1240,7 @@ def reglist2str(rlist): return "{" + ", ".join(out) + '}' -class arm_rlist(m_arg): +class arm_rlist(arm_arg): parser = gpreg_list def encode(self): @@ -1272,6 +1343,18 @@ class bs_lnk(bs_mod_name): return name[:1] + self.args['mn_mod'][i] + name[1:] +class armt_rm_cp(bsi): + + def decode(self, v): + if v != gpregs.expr.index(self.parent.rm.expr): + return False + return True + + def encode(self): + self.value = gpregs.expr.index(self.parent.rm.expr) + return True + + accum = bs(l=1) scc = bs_mod_name(l=1, fname='scc', mn_mod=['', 'S']) dumscc = bs("1") @@ -1280,7 +1363,13 @@ rdl = bs(l=4, cls=(arm_gpreg,)) rn = bs(l=4, cls=(arm_gpreg,), fname="rn") rs = bs(l=4, cls=(arm_gpreg,)) -rm = bs(l=4, cls=(arm_gpreg,)) +rm = bs(l=4, cls=(arm_gpreg,), fname='rm') +ra = bs(l=4, cls=(arm_gpreg,)) +rt = bs(l=4, cls=(arm_gpreg,), fname='rt') +rt2 = bs(l=4, cls=(arm_gpreg,)) + +rm_cp = bs(l=4, cls=(armt_rm_cp,)) + op2 = bs(l=12, cls=(arm_op2,)) lnk = bs_lnk(l=1, fname='lnk', mn_mod=['', 'L']) offs = bs(l=24, cls=(arm_offs,), fname="offs") @@ -1333,8 +1422,10 @@ imm16 = bs(l=16, cls=(arm_imm, m_arg)) imm12_off = bs(l=12, fname="imm") +imm2_noarg = bs(l=2, fname="imm") imm4_noarg = bs(l=4, fname="imm4") + imm_4_12 = bs(l=12, cls=(arm_imm_4_12,)) imm12_noarg = bs(l=12, fname="imm") @@ -1356,7 +1447,7 @@ class mul_part_y(bs_mod_name): mul_x = mul_part_x(l=1, fname='x', mn_mod=['B', 'T']) mul_y = mul_part_y(l=1, fname='y', mn_mod=['B', 'T']) -class arm_immed(m_arg): +class arm_immed(arm_arg): parser = deref def decode(self, v): @@ -1429,7 +1520,7 @@ immedL = bs(l=4, cls=(arm_immed, m_arg), fname='immedL') hb = bs(l=1) -class armt2_rot_rm(m_arg): +class armt2_rot_rm(arm_arg): parser = shift_off def decode(self, v): r = self.parent.rm.expr @@ -1450,7 +1541,7 @@ class armt2_rot_rm(m_arg): rot_rm = bs(l=2, cls=(armt2_rot_rm,), fname="rot_rm") -class arm_mem_rn_imm(m_arg): +class arm_mem_rn_imm(arm_arg): parser = deref def decode(self, v): value = self.parent.imm.value @@ -1550,25 +1641,16 @@ bs_mr_name = bs_name(l=1, name=mr_name) bs_addi = bs(l=1, fname="add_imm") bs_rw = bs_mod_name(l=1, fname='rw', mn_mod=['W', '']) -armop("mul", [bs('000000'), bs('0'), scc, rd, - bs('0000'), rs, bs('1001'), rm], [rd, rm, rs]) -armop("umull", [bs('000010'), - bs('0'), scc, rd, rdl, rs, bs('1001'), rm], [rdl, rd, rm, rs]) -armop("umlal", [bs('000010'), - bs('1'), scc, rd, rdl, rs, bs('1001'), rm], [rdl, rd, rm, rs]) -armop("smull", [bs('000011'), bs('0'), scc, rd, - rdl, rs, bs('1001'), rm], [rdl, rd, rm, rs]) -armop("smlal", [bs('000011'), bs('1'), scc, rd, - rdl, rs, bs('1001'), rm], [rdl, rd, rm, rs]) -armop("mla", [bs('000000'), bs('1'), scc, rd, - rn, rs, bs('1001'), rm], [rd, rm, rs, rn]) -armop("mrs", [bs('00010'), psr, bs('00'), - psr_field, rd, bs('000000000000')], [rd, psr]) -armop("msr", [bs('00010'), psr, bs('10'), psr_field, - bs('1111'), bs('0000'), bs('0000'), rm], [psr_field, rm]) +armop("mul", [bs('000000'), bs('0'), scc, rd, bs('0000'), rs, bs('1001'), rm], [rd, rm, rs]) +armop("umull", [bs('000010'), bs('0'), scc, rd, rdl, rs, bs('1001'), rm], [rdl, rd, rm, rs]) +armop("umlal", [bs('000010'), bs('1'), scc, rd, rdl, rs, bs('1001'), rm], [rdl, rd, rm, rs]) +armop("smull", [bs('000011'), bs('0'), scc, rd, rdl, rs, bs('1001'), rm], [rdl, rd, rm, rs]) +armop("smlal", [bs('000011'), bs('1'), scc, rd, rdl, rs, bs('1001'), rm], [rdl, rd, rm, rs]) +armop("mla", [bs('000000'), bs('1'), scc, rd, rn, rs, bs('1001'), rm], [rd, rm, rs, rn]) +armop("mrs", [bs('00010'), psr, bs('00'), psr_field, rd, bs('000000000000')], [rd, psr]) +armop("msr", [bs('00010'), psr, bs('10'), psr_field, bs('1111'), bs('0000'), bs('0000'), rm], [psr_field, rm]) armop("data", [bs('00'), immop, bs_data_name, scc, rn, rd, op2], [rd, rn, op2]) -armop("data_mov", - [bs('00'), immop, bs_data_mov_name, scc, bs('0000'), rd, op2], [rd, op2]) +armop("data_mov", [bs('00'), immop, bs_data_mov_name, scc, bs('0000'), rd, op2], [rd, op2]) armop("data_test", [bs('00'), immop, bs_data_test_name, dumscc, rn, dumr, op2]) armop("b", [bs('101'), lnk, offs]) @@ -1576,40 +1658,27 @@ armop("smul", [bs('00010110'), rd, bs('0000'), rs, bs('1'), mul_y, mul_x, bs('0' # TODO TEST #armop("und", [bs('011'), imm20, bs('1'), imm4]) -armop("transfer", [bs('01'), immop, ppi, updown, trb, wback_no_t, - bs_transfer_name, rn_noarg, rd, op2imm], [rd, op2imm]) -armop("transferh", [bs('000'), ppi, updown, immop, wback_no_t, - bs_transferh_name, rn_noarg, rd, immedH, bs('1011'), immedL], [rd, immedL]) -armop("ldrd", [bs('000'), ppi, updown, immop, wback_no_t, bs_transfer_ldr_name, - rn_noarg, rd, immedH, bs('1101'), immedL], [rd, immedL]) -armop("ldrsh", [bs('000'), ppi, updown, immop, wback_no_t, bs('1'), rn_noarg, - rd, immedH, bs('1'), bs('1'), bs('1'), bs('1'), immedL], [rd, immedL]) -armop("strd", [bs('000'), ppi, updown, immop, wback_no_t, bs('0'), rn_noarg, - rd, immedH, bs('1'), bs('1'), bs('1'), bs('1'), immedL], [rd, immedL]) -armop("btransfersp", [bs('100'), ppi_b_sp, updown_b_sp, sbit, wback_no_t, - bs_btransfer_name, rn_sp, rlist]) -armop("btransfer", [bs('100'), ppi_b_nosp, updown_b_nosp, sbit, wback_no_t, - bs_btransfer_name, rn_wb, rlist]) +armop("transfer", [bs('01'), immop, ppi, updown, trb, wback_no_t, bs_transfer_name, rn_noarg, rd, op2imm], [rd, op2imm]) +armop("transferh", [bs('000'), ppi, updown, immop, wback_no_t, bs_transferh_name, rn_noarg, rd, immedH, bs('1011'), immedL], [rd, immedL]) +armop("ldrd", [bs('000'), ppi, updown, immop, wback_no_t, bs_transfer_ldr_name, rn_noarg, rd, immedH, bs('1101'), immedL], [rd, immedL]) +armop("ldrsh", [bs('000'), ppi, updown, immop, wback_no_t, bs('1'), rn_noarg, rd, immedH, bs('1'), bs('1'), bs('1'), bs('1'), immedL], [rd, immedL]) +armop("strd", [bs('000'), ppi, updown, immop, wback_no_t, bs('0'), rn_noarg, rd, immedH, bs('1'), bs('1'), bs('1'), bs('1'), immedL], [rd, immedL]) +armop("btransfersp", [bs('100'), ppi_b_sp, updown_b_sp, sbit, wback_no_t, bs_btransfer_name, rn_sp, rlist]) +armop("btransfer", [bs('100'), ppi_b_nosp, updown_b_nosp, sbit, wback_no_t, bs_btransfer_name, rn_wb, rlist]) # TODO: TEST armop("swp", [bs('00010'), trb, bs('00'), rn, rd, bs('0000'), bs('1001'), rm]) armop("svc", [bs('1111'), swi_i]) -armop("cdp", [bs('1110'), opc, crn, crd, cpnum, cp, bs('0'), crm], - [cpnum, opc, crd, crn, crm, cp]) -armop("cdata", [bs('110'), ppi, updown, tl, wback_no_t, bs_ctransfer_name, - rn_noarg, crd, cpnum, imm8_12], [cpnum, crd, imm8_12]) -armop("mr", [bs('1110'), cpopc, bs_mr_name, crn, rd, cpnum, cp, bs('1'), crm], - [cpnum, cpopc, rd, crn, crm, cp]) +armop("cdp", [bs('1110'), opc, crn, crd, cpnum, cp, bs('0'), crm], [cpnum, opc, crd, crn, crm, cp]) +armop("cdata", [bs('110'), ppi, updown, tl, wback_no_t, bs_ctransfer_name, rn_noarg, crd, cpnum, imm8_12], [cpnum, crd, imm8_12]) +armop("mr", [bs('1110'), cpopc, bs_mr_name, crn, rd, cpnum, cp, bs('1'), crm], [cpnum, cpopc, rd, crn, crm, cp]) armop("bkpt", [bs('00010010'), imm12_noarg, bs('0111'), imm_12_4]) armop("bx", [bs('000100101111111111110001'), rn]) armop("mov", [bs('00110000'), imm4_noarg, rd, imm_4_12], [rd, imm_4_12]) armop("movt", [bs('00110100'), imm4_noarg, rd, imm_4_12], [rd, imm_4_12]) -armop("blx", [bs('00010010'), bs('1111'), - bs('1111'), bs('1111'), bs('0011'), rm], [rm]) +armop("blx", [bs('00010010'), bs('1111'), bs('1111'), bs('1111'), bs('0011'), rm], [rm]) armop("blx", [fix_cond, bs('101'), lowb, offs_blx], [offs_blx]) -armop("clz", [bs('00010110'), bs('1111'), - rd, bs('1111'), bs('0001'), rm], [rd, rm]) -armop("qadd", - [bs('00010000'), rn, rd, bs('0000'), bs('0101'), rm], [rd, rm, rn]) +armop("clz", [bs('00010110'), bs('1111'), rd, bs('1111'), bs('0001'), rm], [rd, rm]) +armop("qadd", [bs('00010000'), rn, rd, bs('0000'), bs('0101'), rm], [rd, rm, rn]) armop("uxtb", [bs('01101110'), bs('1111'), rd, rot_rm, bs('00'), bs('0111'), rm_noarg]) armop("uxth", [bs('01101111'), bs('1111'), rd, rot_rm, bs('00'), bs('0111'), rm_noarg]) @@ -1631,11 +1700,13 @@ class arm_widthm1(arm_imm, m_arg): if not isinstance(self.expr, ExprInt): return False v = int(self.expr) + -1 + if v > self.lmask: + return False self.value = v return True -class arm_rm_rot2(m_arg): +class arm_rm_rot2(arm_arg): parser = rot2_expr def decode(self, v): expr = gpregs.expr[v] @@ -1662,18 +1733,47 @@ class arm_rm_rot2(m_arg): self.parent.rot2.value = value / 8 return True -class arm_gpreg_nopc(arm_reg): +class arm_gpreg_nopc(reg_noarg): reg_info = gpregs_nopc parser = reg_info.parser + def decode(self, v): + ret = super(arm_gpreg_nopc, self).decode(v) + if ret is False: + return False + if self.expr == reg_dum: + return False + return True + + +class arm_gpreg_nosp(reg_noarg): + reg_info = gpregs_nosp + parser = reg_info.parser + + def decode(self, v): + ret = super(arm_gpreg_nosp, self).decode(v) + if ret is False: + return False + if self.expr == reg_dum: + return False + return True + + rm_rot2 = bs(l=4, cls=(arm_rm_rot2,), fname="rm") rot2 = bs(l=2, fname="rot2") widthm1 = bs(l=5, cls=(arm_widthm1, m_arg)) lsb = bs(l=5, cls=(arm_imm, m_arg)) -rn_nopc = bs(l=4, cls=(arm_gpreg_nopc,), fname="rn") +rd_nopc = bs(l=4, cls=(arm_gpreg_nopc, arm_arg), fname="rd") +rn_nopc = bs(l=4, cls=(arm_gpreg_nopc, arm_arg), fname="rn") +ra_nopc = bs(l=4, cls=(arm_gpreg_nopc, arm_arg), fname="ra") +rt_nopc = bs(l=4, cls=(arm_gpreg_nopc, arm_arg), fname="rt") + +rn_nosp = bs(l=4, cls=(arm_gpreg_nosp, arm_arg), fname="rn") + +rn_nopc_noarg = bs(l=4, cls=(arm_gpreg_nopc,), fname="rn") armop("ubfx", [bs('0111111'), widthm1, rd, lsb, bs('101'), rn], [rd, rn, lsb, widthm1]) @@ -1693,18 +1793,23 @@ gpregs_h = reg_info(regs_str[8:], regs_expr[8:]) gpregs_sppc = reg_info(regs_str[-1:] + regs_str[13:14], regs_expr[-1:] + regs_expr[13:14]) +deref_reg_imm = Group(LBRACK + gpregs.parser + Optional( + COMMA + shift_off) + RBRACK).setParseAction(cb_deref_pre_mem) deref_low = Group(LBRACK + gpregs_l.parser + Optional( - COMMA + shift_off) + RBRACK).setParseAction(deref2expr_pre_mem) + COMMA + shift_off) + RBRACK).setParseAction(cb_deref_pre_mem) deref_pc = Group(LBRACK + gpregs_pc.parser + Optional( - COMMA + shift_off) + RBRACK).setParseAction(deref2expr_pre_mem) + COMMA + shift_off) + RBRACK).setParseAction(cb_deref_pre_mem) deref_sp = Group(LBRACK + gpregs_sp.parser + COMMA + - shift_off + RBRACK).setParseAction(deref2expr_pre_mem) + shift_off + RBRACK).setParseAction(cb_deref_pre_mem) gpregs_l_wb = Group( - gpregs_l.parser + Optional('!')).setParseAction(parsegpreg_wb) + gpregs_l.parser + Optional('!')).setParseAction(cb_gpreb_wb) -class arm_offreg(m_arg): +gpregs_l_13 = reg_info(regs_str[:13], regs_expr[:13]) + + +class arm_offreg(arm_arg): parser = deref_pc def decodeval(self, v): @@ -1815,9 +1920,8 @@ class arm_off7(arm_imm): def encodeval(self, v): return v >> 2 - -class arm_deref(m_arg): - parser = deref_low +class arm_deref_reg_imm(arm_arg): + parser = deref_reg_imm def decode(self, v): v = v & self.lmask @@ -1827,6 +1931,7 @@ class arm_deref(m_arg): return True def encode(self): + self.parent.off.expr = None e = self.expr if not isinstance(e, ExprMem): return False @@ -1848,6 +1953,9 @@ class arm_deref(m_arg): return False return True +class arm_derefl(arm_deref_reg_imm): + parser = deref_low + class arm_offbw(imm_noarg): @@ -1867,6 +1975,26 @@ class arm_offbw(imm_noarg): log.debug('off must be aligned %r', v) return False v >>= 2 + if v > self.lmask: + return False + self.value = v + return True + + + +class arm_off(imm_noarg): + + def decode(self, v): + v = v & self.lmask + self.expr = ExprInt(v, 32) + return True + + def encode(self): + if not isinstance(self.expr, ExprInt): + return False + v = int(self.expr) + if v > self.lmask: + return False self.value = v return True @@ -1887,11 +2015,13 @@ class arm_offh(imm_noarg): log.debug('off must be aligned %r', v) return False v >>= 1 + if v > self.lmask: + return False self.value = v return True -class armt_rlist(m_arg): +class armt_rlist(arm_arg): parser = gpreg_list def encode(self): @@ -1916,6 +2046,102 @@ class armt_rlist(m_arg): return True +class armt_rlist13(armt_rlist): + parser = gpreg_list + + def encode(self): + e = self.expr + rlist = [] + reg_l = list(e.args) + + self.parent.pclr.value = 0 + if self.parent.name.startswith('PUSH'): + if regs_expr[14] in reg_l: + reg_l.remove(regs_expr[14]) + self.parent.pclr.value = 1 + else: + if regs_expr[15] in reg_l: + reg_l.remove(regs_expr[15]) + self.parent.pclr.value = 1 + + for reg in reg_l: + if reg not in gpregs_l_13.expr: + return False + rlist.append(gpregs_l_13.expr.index(reg)) + v = 0 + for r in rlist: + v |= 1 << r + self.value = v + return True + + def decode(self, v): + v = v & self.lmask + out = [] + for i in xrange(13): + if 1 << i & v: + out.append(gpregs_l_13.expr[i]) + + if self.parent.pclr.value == 1: + if self.parent.name.startswith("PUSH"): + out += [regs_expr[14]] + else: + out += [regs_expr[15]] + + if not out: + return False + e = ExprOp('reglist', *out) + self.expr = e + return True + + + +class armt_rlist13_pc_lr(armt_rlist): + parser = gpreg_list + + def encode(self): + e = self.expr + rlist = [] + reg_l = list(e.args) + + self.parent.pc_in.value = 0 + self.parent.lr_in.value = 0 + if regs_expr[14] in reg_l: + reg_l.remove(regs_expr[14]) + self.parent.lr_in.value = 1 + if regs_expr[15] in reg_l: + reg_l.remove(regs_expr[15]) + self.parent.pc_in.value = 1 + + for reg in reg_l: + if reg not in gpregs_l_13.expr: + return False + rlist.append(gpregs_l_13.expr.index(reg)) + v = 0 + for r in rlist: + v |= 1 << r + self.value = v + return True + + def decode(self, v): + v = v & self.lmask + out = [] + for i in xrange(13): + if 1 << i & v: + out.append(gpregs_l_13.expr[i]) + + if self.parent.lr_in.value == 1: + out += [regs_expr[14]] + if self.parent.pc_in.value == 1: + out += [regs_expr[15]] + + if not out: + return False + e = ExprOp('reglist', *out) + self.expr = e + return True + + + class armt_rlist_pclr(armt_rlist): def encode(self): @@ -1936,6 +2162,8 @@ class armt_rlist_pclr(armt_rlist): v = 0 for r in rlist: v |= 1 << r + if v > self.lmask: + return False self.value = v return True @@ -2016,7 +2244,7 @@ rsl = bs(l=3, cls=(arm_gpreg_l,), fname="rs") rml = bs(l=3, cls=(arm_gpreg_l,), fname="rm") rol = bs(l=3, cls=(arm_gpreg_l,), fname="ro") rbl = bs(l=3, cls=(arm_gpreg_l,), fname="rb") -rbl_deref = bs(l=3, cls=(arm_deref,), fname="rb") +rbl_deref = bs(l=3, cls=(arm_derefl,), fname="rb") dumrh = bs(l=3, default_val="000") rdh = bs(l=3, cls=(arm_gpreg_h,), fname="rd") @@ -2030,8 +2258,16 @@ off5bw = bs(l=5, cls=(arm_offbw,), fname="off") off5h = bs(l=5, cls=(arm_offh,), fname="off") sppc = bs(l=1, cls=(arm_sppc,)) +off12 = bs(l=12, cls=(arm_off,), fname="off", order=-1) +rn_deref = bs(l=4, cls=(arm_deref_reg_imm,), fname="rt") + -pclr = bs(l=1, fname='pclr') + +pclr = bs(l=1, fname='pclr', order=-2) + + +pc_in = bs(l=1, fname='pc_in', order=-2) +lr_in = bs(l=1, fname='lr_in', order=-2) sp = bs(l=0, cls=(arm_sp,)) @@ -2040,6 +2276,9 @@ sp = bs(l=0, cls=(arm_sp,)) off8s = bs(l=8, cls=(arm_offs,), fname="offs") trlistpclr = bs(l=8, cls=(armt_rlist_pclr,)) trlist = bs(l=8, cls=(armt_rlist,), fname="trlist", order = -1) +trlist13 = bs(l=13, cls=(armt_rlist13,), fname="trlist", order = -1) +trlist13pclr = bs(l=13, cls=(armt_rlist13_pc_lr,), fname="trlist", order = -1) + rbl_wb = bs(l=3, cls=(armt_reg_wb,), fname='rb') @@ -2097,43 +2336,29 @@ bs_br_name = bs_name(l=4, name=br_name) armtop("mshift", [bs('000'), bs_mshift_name, off5, rsl, rdl], [rdl, rsl, off5]) -armtop("addsubr", - [bs('000110'), bs_addsub_name, rnl, rsl, rdl], [rdl, rsl, rnl]) -armtop("addsubi", - [bs('000111'), bs_addsub_name, off3, rsl, rdl], [rdl, rsl, off3]) +armtop("addsubr", [bs('000110'), bs_addsub_name, rnl, rsl, rdl], [rdl, rsl, rnl]) +armtop("addsubi", [bs('000111'), bs_addsub_name, off3, rsl, rdl], [rdl, rsl, off3]) armtop("mcas", [bs('001'), bs_mov_cmp_add_sub_name, rnl, off8]) armtop("alu", [bs('010000'), bs_alu_name, rsl, rdl], [rdl, rsl]) # should not be used ?? -armtop("hiregop00", - [bs('010001'), bs_hiregop_name, bs('00'), rsl, rdl], [rdl, rsl]) -armtop("hiregop01", - [bs('010001'), bs_hiregop_name, bs('01'), rsh, rdl], [rdl, rsh]) -armtop("hiregop10", - [bs('010001'), bs_hiregop_name, bs('10'), rsl, rdh], [rdh, rsl]) -armtop("hiregop11", - [bs('010001'), bs_hiregop_name, bs('11'), rsh, rdh], [rdh, rsh]) +armtop("hiregop00", [bs('010001'), bs_hiregop_name, bs('00'), rsl, rdl], [rdl, rsl]) +armtop("hiregop01", [bs('010001'), bs_hiregop_name, bs('01'), rsh, rdl], [rdl, rsh]) +armtop("hiregop10", [bs('010001'), bs_hiregop_name, bs('10'), rsl, rdh], [rdh, rsl]) +armtop("hiregop11", [bs('010001'), bs_hiregop_name, bs('11'), rsh, rdh], [rdh, rsh]) armtop("bx", [bs('010001'), bs('11'), bs('00'), rsl, dumrh]) armtop("bx", [bs('010001'), bs('11'), bs('01'), rsh, dumrh]) armtop("ldr", [bs('01001'), rdl, offpc8]) -armtop("ldrstr", [bs('0101'), bs_ldr_str_name, - trb, bs('0'), rol_noarg, rbl_deref, rdl], [rdl, rbl_deref]) -armtop("strh", [bs('0101'), bs('00'), bs('1'), - rol_noarg, rbl_deref, rdl], [rdl, rbl_deref]) -armtop("ldrh", [bs('0101'), bs('10'), bs('1'), - rol_noarg, rbl_deref, rdl], [rdl, rbl_deref]) -armtop("ldsb", [bs('0101'), bs('01'), bs('1'), - rol_noarg, rbl_deref, rdl], [rdl, rbl_deref]) -armtop("ldsh", [bs('0101'), bs('11'), bs('1'), - rol_noarg, rbl_deref, rdl], [rdl, rbl_deref]) -armtop("ldst", [bs('011'), trb, - bs_ldr_str_name, off5bw, rbl_deref, rdl], [rdl, rbl_deref]) -armtop("ldhsth", - [bs('1000'), bs_ldrh_strh_name, off5h, rbl_deref, rdl], [rdl, rbl_deref]) +armtop("ldrstr", [bs('0101'), bs_ldr_str_name, trb, bs('0'), rol_noarg, rbl_deref, rdl], [rdl, rbl_deref]) +armtop("strh", [bs('0101'), bs('00'), bs('1'), rol_noarg, rbl_deref, rdl], [rdl, rbl_deref]) +armtop("ldrh", [bs('0101'), bs('10'), bs('1'), rol_noarg, rbl_deref, rdl], [rdl, rbl_deref]) +armtop("ldsb", [bs('0101'), bs('01'), bs('1'), rol_noarg, rbl_deref, rdl], [rdl, rbl_deref]) +armtop("ldsh", [bs('0101'), bs('11'), bs('1'), rol_noarg, rbl_deref, rdl], [rdl, rbl_deref]) +armtop("ldst", [bs('011'), trb, bs_ldr_str_name, off5bw, rbl_deref, rdl], [rdl, rbl_deref]) +armtop("ldhsth", [bs('1000'), bs_ldrh_strh_name, off5h, rbl_deref, rdl], [rdl, rbl_deref]) armtop("ldstsp", [bs('1001'), bs_ldstsp_name, rdl, offsp8], [rdl, offsp8]) armtop("add", [bs('1010'), sppc, rdl, off8sppc], [rdl, sppc, off8sppc]) armtop("addsp", [bs('10110000'), bs_addsubsp_name, sp, off7], [sp, off7]) -armtop("pushpop", - [bs('1011'), bs_pushpop_name, bs('10'), pclr, trlistpclr], [trlistpclr]) +armtop("pushpop", [bs('1011'), bs_pushpop_name, bs('10'), pclr, trlistpclr], [trlistpclr]) armtop("btransfersp", [bs('1100'), bs_tbtransfer_name, rbl_wb, trlist]) armtop("br", [bs('1101'), bs_br_name, offs8]) armtop("blx", [bs("01000111"), bs('10'), rnl, bs('000')]) @@ -2141,6 +2366,7 @@ armtop("svc", [bs('11011111'), imm8]) armtop("b", [bs('11100'), offs11]) armtop("und", [bs('1101'), bs('1110'), imm8_d1]) +armtop("rev", [bs('10111010'), bs('00'), rsl, rdl], [rdl, rsl]) armtop("uxtb", [bs('10110010'), bs('11'), rml, rdl], [rdl, rml]) armtop("uxth", [bs('10110010'), bs('10'), rml, rdl], [rdl, rml]) @@ -2149,18 +2375,25 @@ armtop("sxth", [bs('10110010'), bs('00'), rml, rdl], [rdl, rml]) # thumb2 ###################### # - # ARM Architecture Reference Manual Thumb-2 Supplement -armt_gpreg_shift_off = Group( - gpregs_nosppc.parser + allshifts_t_armt + base_expr -).setParseAction(shift2expr) +armt_gpreg_shift_off = (gpregs_nosppc.parser + allshifts_t_armt + (gpregs.parser | int_1_31)).setParseAction(cb_shift) + + armt_gpreg_shift_off |= gpregs_nosppc.parser class arm_gpreg_nosppc(arm_reg): reg_info = gpregs_nosppc + parser = reg_info.parser + def decode(self, v): + ret = super(arm_gpreg_nosppc, self).decode(v) + if ret is False: + return False + if self.expr == reg_dum: + return False + return True class armt_gpreg_rm_shift_off(arm_reg): @@ -2171,6 +2404,8 @@ class armt_gpreg_rm_shift_off(arm_reg): if v >= len(gpregs_nosppc.expr): return False r = gpregs_nosppc.expr[v] + if r == reg_dum: + return False i = int(self.parent.imm5_3.value) << 2 i |= int(self.parent.imm5_2.value) @@ -2185,11 +2420,15 @@ class armt_gpreg_rm_shift_off(arm_reg): def encode(self): e = self.expr if isinstance(e, ExprId): - self.value = gpregs_nosppc.index(e) + if e not in gpregs_nosppc.expr: + return False + self.value = gpregs_nosppc.expr.index(e) self.parent.stype.value = 0 self.parent.imm5_3.value = 0 self.parent.imm5_2.value = 0 return True + if not e.is_op(): + return False shift = e.op r = gpregs_nosppc.expr.index(e.args[0]) self.value = r @@ -2239,11 +2478,13 @@ class armt2_imm12(arm_imm): self.expr = ExprInt((v << 24) | (v << 16) | (v << 8) | v, 32) return True r = v >> 7 - v = v & 0xFF + v = 0x80 | (v & 0x7F) self.expr = ExprInt(myror32(v, r), 32) return True def encode(self): + if not self.expr.is_int(): + return False v = int(self.expr) value = None # simple encoding @@ -2265,8 +2506,8 @@ class armt2_imm12(arm_imm): # rol encoding for i in xrange(32): o = myrol32(v, i) - if 0 <= o < 0x100 and o & 0x80: - value = (i << 7) | o + if 0x80 <= o <= 0xFF: + value = (i << 7) | (o & 0x7F) break if value is None: log.debug('cannot encode imm12') @@ -2277,6 +2518,108 @@ class armt2_imm12(arm_imm): return True + + +class armt4_imm12(arm_imm): + + def decode(self, v): + v = v & self.lmask + v |= int(self.parent.imm12_3.value) << 8 + v |= int(self.parent.imm12_1.value) << 11 + self.expr = ExprInt(v, 32) + return True + + def encode(self): + if not self.expr.is_int(): + return False + value = int(self.expr) + self.value = value & self.lmask + self.parent.imm12_3.value = (value >> 8) & self.parent.imm12_3.lmask + self.parent.imm12_1.value = (value >> 11) & self.parent.imm12_1.lmask + return True + + + + +class armt2_imm16(arm_imm): + + def decode(self, v): + v = v & self.lmask + v |= int(self.parent.imm16_3.value) << 8 + v |= int(self.parent.imm16_1.value) << 11 + v |= int(self.parent.imm16_4.value) << 12 + self.expr = ExprInt(v, 32) + return True + + def encode(self): + if not self.expr.is_int(): + return False + value = int(self.expr) + self.value = value & self.lmask + self.parent.imm16_3.value = (value >> 8) & self.parent.imm16_3.lmask + self.parent.imm16_1.value = (value >> 11) & self.parent.imm16_1.lmask + self.parent.imm16_4.value = (value >> 12) & self.parent.imm16_4.lmask + return True + + +class armt2_lsb5(arm_imm): + + def decode(self, v): + v = v & self.lmask + v |= int(self.parent.lsb5_3.value) << 2 + self.expr = ExprInt(v, 32) + return True + + def encode(self): + if not self.expr.is_int(): + return False + value = int(self.expr) + self.value = value & self.lmask + self.parent.lsb5_3.value = (value >> 2) & self.parent.lsb5_3.lmask + return True + + +class armt_widthm1(arm_imm): + parser = base_expr + + def decodeval(self, v): + return v + 1 + + def encodeval(self, v): + if v <= 0: + return False + return v - 1 + + + + +class armt2_off20(arm_imm): + + def decode(self, v): + v = v & self.lmask + v <<= 1 + v |= int(self.parent.off20_6.value) << 12 + v |= int(self.parent.off20_j1.value) << 18 + v |= int(self.parent.off20_j2.value) << 19 + v |= int(self.parent.off20_s.value) << 20 + self.expr = ExprInt(v, 32) + return True + + def encode(self): + if not self.expr.is_int(): + return False + value = int(self.expr) + if value & 1: + return False + self.value = (value >> 1) & self.lmask + self.parent.off20_6.value = (value >> 12) & self.parent.off20_6.lmask + self.parent.off20_j1.value = (value >> 18) & self.parent.off20_j1.lmask + self.parent.off20_j2.value = (value >> 19) & self.parent.off20_j2.lmask + self.parent.off20_s.value = (value >> 20) & self.parent.off20_s.lmask + return True + + + class armt2_imm10l(arm_imm): def decode(self, v): @@ -2289,8 +2632,7 @@ class armt2_imm10l(arm_imm): i1, i2 = j1 ^ s ^ 1, j2 ^ s ^ 1 - v = (s << 24) | (i1 << 23) | ( - i2 << 22) | (imm10h << 12) | (imm10l << 2) + v = (s << 24) | (i1 << 23) | (i2 << 22) | (imm10h << 12) | (imm10l << 2) v = sign_ext(v, 25, 32) self.expr = ExprInt(v, 32) return True @@ -2305,8 +2647,7 @@ class armt2_imm10l(arm_imm): v = (-v) & 0xffffffff if v > (1 << 26): return False - i1, i2, imm10h, imm10l = (v >> 23) & 1, ( - v >> 22) & 1, (v >> 12) & 0x3ff, (v >> 2) & 0x3ff + i1, i2, imm10h, imm10l = (v >> 23) & 1, (v >> 22) & 1, (v >> 12) & 0x3ff, (v >> 2) & 0x3ff j1, j2 = i1 ^ s ^ 1, i2 ^ s ^ 1 self.parent.sign.value = s self.parent.j1.value = j1 @@ -2328,24 +2669,24 @@ class armt2_imm11l(arm_imm): i1, i2 = j1 ^ s ^ 1, j2 ^ s ^ 1 - v = (s << 24) | (i1 << 23) | ( - i2 << 22) | (imm10h << 12) | (imm11l << 1) + v = (s << 24) | (i1 << 23) | (i2 << 22) | (imm10h << 12) | (imm11l << 1) v = sign_ext(v, 25, 32) - self.expr = ExprInt(v, 32) + self.expr = ExprInt(v + 4, 32) return True def encode(self): if not isinstance(self.expr, ExprInt): return False - v = self.expr.arg.arg + v = self.expr.arg.arg - 4 s = 0 if v & 0x80000000: s = 1 v = (-v) & 0xffffffff - if v > (1 << 26): + if v >= (1 << 26): + return False + if v & 1: return False - i1, i2, imm10h, imm11l = (v >> 23) & 1, ( - v >> 22) & 1, (v >> 12) & 0x3ff, (v >> 1) & 0x7ff + i1, i2, imm10h, imm11l = (v >> 23) & 1, (v >> 22) & 1, (v >> 12) & 0x3ff, (v >> 1) & 0x7ff j1, j2 = i1 ^ s ^ 1, i2 ^ s ^ 1 self.parent.sign.value = s self.parent.j1.value = j1 @@ -2355,22 +2696,86 @@ class armt2_imm11l(arm_imm): return True + +class armt2_imm6_11l(arm_imm): + + def decode(self, v): + v = v & self.lmask + s = self.parent.sign.value + j1 = self.parent.j1.value + j2 = self.parent.j2.value + imm6h = self.parent.imm6h.value + imm11l = v + + v = (s << 20) | (j2 << 19) | (j1 << 18) | (imm6h << 12) | (imm11l << 1) + v = sign_ext(v, 21, 32) + self.expr = ExprInt(v + 4, 32) + return True + + def encode(self): + if not isinstance(self.expr, ExprInt): + return False + v = self.expr.arg.arg - 4 + s = 0 + if v & 0x80000000: + s = 1 + v = (-v) & 0xffffffff + if v >= (1 << 22): + return False + if v & 1: + return False + i2, i1, imm6h, imm11l = (v >> 19) & 1, (v >> 18) & 1, (v >> 12) & 0x3f, (v >> 1) & 0x7ff + self.parent.sign.value = s + self.parent.j1.value = i1 + self.parent.j2.value = i2 + self.parent.imm6h.value = imm6h + self.value = imm11l + return True + + + imm12_1 = bs(l=1, fname="imm12_1", order=1) imm12_3 = bs(l=3, fname="imm12_3", order=1) imm12_8 = bs(l=8, cls=(armt2_imm12,), fname="imm", order=2) +imm12_8_t4 = bs(l=8, cls=(armt4_imm12,), fname="imm", order=2) + + +imm16_1 = bs(l=1, fname="imm16_1", order=1) +imm16_3 = bs(l=3, fname="imm16_3", order=1) +imm16_4 = bs(l=4, fname="imm16_4", order=1) +imm16_8 = bs(l=8, cls=(armt2_imm16,), fname="imm", order=2) + + imm5_3 = bs(l=3, fname="imm5_3") imm5_2 = bs(l=2, fname="imm5_2") imm_stype = bs(l=2, fname="stype") +imm_stype_00 = bs('00', fname="stype") +imm_stype_11 = bs('11', fname="stype") + + imm1 = bs(l=1, fname="imm1") + +off20_6 = bs(l=6, fname="off20_6", order=1) +off20_11 = bs(l=11, cls=(armt2_off20,), fname="imm", order=2) + + + +lsb5_3 = bs(l=3, fname="lsb5_3", order=1) +lsb5_2 = bs(l=2, cls=(armt2_lsb5,), fname="imm", order=2) + +widthm1 = bs(l=5, cls=(armt_widthm1,), fname="imm", order=2) + + + class armt_imm5_1(arm_imm): def decode(self, v): - v = sign_ext(((self.parent.imm1.value << 5) | v) << 1, 7, 32) + v = ((self.parent.imm1.value << 5) | v) << 1 self.expr = ExprInt(v, 32) return True @@ -2378,8 +2783,8 @@ class armt_imm5_1(arm_imm): if not isinstance(self.expr, ExprInt): return False v = self.expr.arg.arg - if v & 0x80000000: - v &= (1 << 7) - 1 + if v & 0x1: + return False self.parent.imm1.value = (v >> 6) & 1 self.value = (v >> 1) & 0x1f return True @@ -2389,7 +2794,7 @@ aif_expr = [ExprId(x, 32) if x != None else None for x in aif_str] aif_reg = reg_info(aif_str, aif_expr) -class armt_aif(reg_noarg, m_arg): +class armt_aif(reg_noarg, arm_arg): reg_info = aif_reg parser = reg_info.parser @@ -2404,12 +2809,292 @@ class armt_aif(reg_noarg, m_arg): return ret return self.value != 0 - def fromstring(self, s, parser_result=None): - start, stop = super(armt_aif, self).fromstring(s, parser_result) + def fromstring(self, text, symbol_pool, parser_result=None): + start, stop = super(armt_aif, self).fromstring(text, symbol_pool, parser_result) if self.expr.name == "X": return None, None return start, stop + +class armt_it_arg(arm_arg): + arg_E = ExprId('E', 1) + arg_NE = ExprId('NE', 1) + + def decode(self, v): + if v: + return self.arg_E + else: + return self.arg_NE + + def encode(self): + if self.expr == self.arg_E: + return 1 + elif self.expr == self.arg_NE: + return 0 + +class armt_itmask(bs_divert): + prio = 2 + + def divert(self, i, candidates): + out = [] + for cls, _, bases, dct, fields in candidates: + for value in xrange(1, 0x10): + nfields = fields[:] + s = int2bin(value, self.args['l']) + args = dict(self.args) + args.update({'strbits': s}) + f = bs(**args) + nfields[i] = f + inv = nfields[-2].value + ndct = dict(dct) + ndct['name'] = self.modname(ndct['name'], value, inv) + out.append((cls, ndct['name'], bases, ndct, nfields)) + return out + + def modname(self, name, value, inv): + count = 0 + while value & (1 << count) == 0: + count += 1 + out = [] + values = ['E', 'T'] + if inv== 1: + values.reverse() + for index in xrange(3 - count): + if value & (1 << (3 - index)): + out.append(values[0]) + else: + out.append(values[1]) + return name + "".join(out) + + + +class armt_cond_lsb(bs_divert): + prio = 2 + + def divert(self, i, candidates): + out = [] + for cls, _, bases, dct, fields in candidates: + for value in xrange(2): + nfields = fields[:] + s = int2bin(value, self.args['l']) + args = dict(self.args) + args.update({'strbits': s}) + f = bs(**args) + nfields[i] = f + ndct = dict(dct) + out.append((cls, ndct['name'], bases, ndct, nfields)) + return out + + +cond_expr = [ExprId(x, 32) for x in cond_list_full] +cond_info = reg_info(cond_list_full, cond_expr) + +class armt_cond_arg(arm_arg): + parser = cond_info.parser + + def decode(self, v): + v = (v << 1) | self.parent.condlsb.value + self.expr = ExprId(cond_list_full[v], 32) + return True + + def encode(self): + index = cond_list_full.index(self.expr.name) + self.value = index >> 1 + if index & 1 != self.parent.condlsb.value: + return False + return True + + +class armt_op2imm(arm_imm8_12): + parser = deref + + def str_to_imm_rot_form(self, s, neg=False): + if neg: + s = -s & 0xffffffff + if 0 <= s < (1 << 12): + return s + return None + + def decodeval(self, v): + return v + + def encodeval(self, v): + return v + + def decode(self, v): + val = v & self.lmask + val = self.decodeval(val) + if val is False: + return False + imm = val + if self.parent.updown.value == 0: + imm = -imm + if self.parent.ppi.value == 0 and self.parent.wback.value == 0: + return False + if self.parent.ppi.value: + e = ExprOp('preinc', self.parent.rn.expr, ExprInt(imm, 32)) + if self.parent.wback.value == 1: + e = ExprOp('wback', e) + else: + e = ExprOp('postinc', self.parent.rn.expr, ExprInt(imm, 32)) + self.expr = ExprMem(e, 32) + return True + + def encode(self): + self.parent.updown.value = 1 + self.parent.wback.value = 0 + + e = self.expr + assert(isinstance(e, ExprMem)) + e = e.arg + if e.op == 'wback': + self.parent.wback.value = 1 + e = e.args[0] + if e.op == "postinc": + self.parent.ppi.value = 0 + self.parent.wback.value = 1 + elif e.op == "preinc": + self.parent.ppi.value = 1 + else: + # XXX default + self.parent.ppi.value = 1 + + self.parent.rn.expr = e.args[0] + + if len(e.args) == 1: + self.value = 0 + return True + # pure imm + if isinstance(e.args[1], ExprInt): + val = self.str_to_imm_rot_form(int(e.args[1])) + if val is None: + val = self.str_to_imm_rot_form(int(e.args[1]), True) + if val is None: + log.debug('cannot encode inm') + return False + self.parent.updown.value = 0 + val = self.encodeval(val) + if val is False: + return False + self.value = val + return True + # pure reg + if isinstance(e.args[1], ExprId): + rm = gpregs.expr.index(e.args[1]) + shift_kind = 0 + shift_type = 0 + amount = 0 + val = (((((amount << 2) | shift_type) << 1) | shift_kind) << 4) | rm + val = self.encodeval(val) + if val is False: + return False + self.value = val + return True + return False + + +class armt_op2imm00(armt_op2imm): + + def decodeval(self, v): + return v << 2 + + def encodeval(self, v): + if v & 3: + return False + return v >> 2 + + +class armt_deref_reg(arm_imm8_12): + parser = deref + + def decode(self, v): + base = self.parent.rn.expr + off = gpregs.expr[v] + if self.parent.imm.value != 0: + off = off << ExprInt(self.parent.imm.value, 32) + e = ExprMem(ExprOp('preinc', base, off), 8) + self.expr = e + return True + + def encode(self): + if not isinstance(self.expr, ExprMem): + return False + ptr = self.expr.arg + if not ptr.is_op('preinc'): + return False + if len(ptr.args) != 2: + return False + base, off = ptr.args + if base.is_id() and off.is_id(): + self.parent.rn.expr = base + self.parent.imm.value = 0 + self.value = gpregs.expr.index(off) + elif off.is_int(): + return False + elif off.is_op('<<'): + if len(off.args) != 2: + return False + reg, off = off.args + self.parent.rn.expr = base + self.parent.imm.value = 0 + self.value = gpregs.expr.index(reg) + off = int(off) + if off > self.parent.imm.lmask: + return False + self.parent.imm.value = off + return True + + +class armt_deref_reg_reg(arm_arg): + parser = deref_reg_reg + reg_info = gpregs + + def decode(self, v): + expr = self.reg_info.expr[v] + expr = ExprMem(self.parent.rn.expr + expr, 8) + self.expr = expr + return True + + def encode(self): + expr = self.expr + if not expr.is_mem(): + return False + ptr = expr.arg + if not ptr.is_op('+') or len(ptr.args) != 2: + return False + reg1, reg2 = ptr.args + self.parent.rn.expr = reg1 + self.value = self.reg_info.expr.index(reg2) + return True + + +class armt_deref_reg_reg_lsl_1(arm_reg): + parser = deref_reg_reg_lsl_1 + reg_info = gpregs + + def decode(self, v): + expr = self.reg_info.expr[v] + expr = ExprMem(self.parent.rn.expr + (expr << ExprInt(1, 32)), 16) + self.expr = expr + return True + + def encode(self): + expr = self.expr + if not expr.is_mem(): + return False + ptr = expr.arg + if not ptr.is_op('+') or len(ptr.args) != 2: + return False + reg1, reg_shift = ptr.args + self.parent.rn.expr = reg1 + if not reg_shift.is_op('<<') or len(reg_shift.args) != 2: + return False + if reg_shift.args[1] != ExprInt(1, 32): + return False + self.value = self.reg_info.expr.index(reg_shift.args[0]) + return True + + aif = bs(l=3, cls=(armt_aif,)) @@ -2419,25 +3104,160 @@ tsign = bs(l=1, fname="sign") tj1 = bs(l=1, fname="j1") tj2 = bs(l=1, fname="j2") +timm6h = bs(l=6, fname="imm6h") timm10H = bs(l=10, fname="imm10h") timm10L = bs(l=10, cls=(armt2_imm10l,), fname="imm10l") timm11L = bs(l=11, cls=(armt2_imm11l,), fname="imm11l") +timm6h11l = bs(l=11, cls=(armt2_imm6_11l,), fname="imm6h11l") + +itcond = bs(l=4, fname="itcond") +itmask = armt_itmask(l=4, fname="itmask") +bs_cond_arg_msb = bs(l=3, cls=(armt_cond_arg,)) + + +condlsb = armt_cond_lsb(l=1, fname="condlsb") + +deref_immpuw = bs(l=8, cls=(armt_op2imm,)) +deref_immpuw00 = bs(l=8, cls=(armt_op2imm00,)) + -armtop("adc", [bs('11110'), imm12_1, bs('0'), bs('1010'), scc, rn_nosppc, - bs('0'), imm12_3, rd_nosppc, imm12_8]) -armtop("adc", [bs('11101'), bs('01'), bs('1010'), scc, rn_nosppc, - bs('0'), imm5_3, rd_nosppc, imm5_2, imm_stype, rm_sh]) -armtop("bl", [bs('11110'), tsign, timm10H, - bs('11'), tj1, bs('1'), tj2, timm11L]) -armtop("blx", [bs('11110'), tsign, timm10H, - bs('11'), tj1, bs('0'), tj2, timm10L, bs('0')]) +rm_deref_reg = bs(l=4, cls=(armt_deref_reg,)) + +bs_deref_reg_reg = bs(l=4, cls=(armt_deref_reg_reg,)) +bs_deref_reg_reg_lsl_1 = bs(l=4, cls=(armt_deref_reg_reg_lsl_1,)) + + +class armt_barrier_option(reg_noarg, arm_arg): + reg_info = barrier_info + parser = reg_info.parser + + def decode(self, v): + v = v & self.lmask + if v not in self.reg_info.dct_expr: + return False + self.expr = self.reg_info.dct_expr[v] + return True + + def encode(self): + if not self.expr in self.reg_info.dct_expr_inv: + log.debug("cannot encode reg %r", self.expr) + return False + self.value = self.reg_info.dct_expr_inv[self.expr] + if self.value > self.lmask: + log.debug("cannot encode field value %x %x", + self.value, self.lmask) + return False + return True + + def check_fbits(self, v): + return v & self.fmask == self.fbits + +barrier_option = bs(l=4, cls=(armt_barrier_option,)) + +armtop("adc", [bs('11110'), imm12_1, bs('0'), bs('1010'), scc, rn_nosppc, bs('0'), imm12_3, rd_nosppc, imm12_8]) +armtop("adc", [bs('11101'), bs('01'), bs('1010'), scc, rn_nosppc, bs('0'), imm5_3, rd_nosppc, imm5_2, imm_stype, rm_sh]) +armtop("bl", [bs('11110'), tsign, timm10H, bs('11'), tj1, bs('1'), tj2, timm11L]) +armtop("blx", [bs('11110'), tsign, timm10H, bs('11'), tj1, bs('0'), tj2, timm10L, bs('0')]) armtop("cbz", [bs('101100'), imm1, bs('1'), imm5_off, rnl], [rnl, imm5_off]) armtop("cbnz", [bs('101110'), imm1, bs('1'), imm5_off, rnl], [rnl, imm5_off]) armtop("bkpt", [bs('1011'), bs('1110'), imm8]) + +armtop("it", [bs('10111111'), bs_cond_arg_msb, condlsb, itmask]) + + armtop("nop", [bs8(0xBF),bs8(0x0)]) armtop("wfi", [bs8(0xBF),bs8(0x30)]) armtop("cpsid", [bs8(0xB6),bs('0111'), bs('0'), aif], [aif]) armtop("cpsie", [bs8(0xB6),bs('0110'), bs('0'), aif], [aif]) + +armtop("push", [bs('1110100'), bs('10'), bs('0'), bs('1'), bs('0'), bs('1101'), bs('0'), pclr, bs('0'), trlist13], [trlist13]) +armtop("pop", [bs('1110100'), bs('01'), bs('0'), bs('1'), bs('1'), bs('1101'), pc_in, lr_in, bs('0'), trlist13pclr], [trlist13pclr]) +armtop("mov", [bs('11110'), imm12_1, bs('00010'), scc, bs('1111'), bs('0'), imm12_3, rd_nosppc, imm12_8]) +armtop("asr", [bs('11111010'), bs('0100'), rm, bs('1111'), rd, bs('0000'), rs], [rd, rm, rs]) +armtop("lsl", [bs('11111010'), bs('0000'), rm, bs('1111'), rd, bs('0000'), rs], [rd, rm, rs]) +armtop("sel", [bs('11111010'), bs('1010'), rm, bs('1111'), rd, bs('1000'), rs], [rd, rm, rs]) +armtop("rev", [bs('11111010'), bs('1001'), rm, bs('1111'), rd, bs('1000'), rm_cp], [rd, rm]) +armtop("uadd8", [bs('111110101000'), rn, bs('1111'), rd, bs('0100'), rm], [rd, rn, rm]) +armtop("mvn", [bs('11101010011'), scc, bs('11110'), imm5_3, rd_nosppc, imm5_2, imm_stype, rm_sh] ) +armtop("and", [bs('11101010000'), scc, rn_nosppc, bs('0'), imm5_3, rd_nosppc, imm5_2, imm_stype, rm_sh], [rd_nosppc, rn_nosppc, rm_sh] ) +armtop("orr", [bs('11101010010'), scc, rn_nosppc, bs('0'), imm5_3, rd_nosppc, imm5_2, imm_stype, rm_sh], [rd_nosppc, rn_nosppc, rm_sh] ) +armtop("bic", [bs('11101010001'), scc, rn_nosppc, bs('0'), imm5_3, rd_nosppc, imm5_2, imm_stype, rm_sh], [rd_nosppc, rn_nosppc, rm_sh] ) +armtop("add", [bs('11101011000'), scc, rn_nosppc, bs('0'), imm5_3, rd_nosppc, imm5_2, imm_stype, rm_sh], [rd_nosppc, rn_nosppc, rm_sh] ) +armtop("sub", [bs('11101011101'), scc, rn_nosppc, bs('0'), imm5_3, rd_nosppc, imm5_2, imm_stype, rm_sh], [rd_nosppc, rn_nosppc, rm_sh] ) +armtop("eor", [bs('11101010100'), scc, rn_nosppc, bs('0'), imm5_3, rd_nosppc, imm5_2, imm_stype, rm_sh], [rd_nosppc, rn_nosppc, rm_sh] ) +armtop("rsb", [bs('11101011110'), scc, rn, bs('0'), imm5_3, rd, imm5_2, imm_stype, rm_sh], [rd, rn, rm_sh] ) +armtop("orn", [bs('11101010011'), scc, rn_nopc, bs('0'), imm5_3, rd, imm5_2, imm_stype, rm_sh], [rd, rn_nopc, rm_sh] ) +# lsl +armtop("mov", [bs('11101010010'), scc, bs('1111'), bs('0'), imm5_3, rd_nosppc, imm5_2, imm_stype_00, rm_sh], [rd_nosppc, rm_sh] ) +armtop("mov", [bs('11101010010'), scc, bs('1111'), bs('0'), imm5_3, rd_nosppc, imm5_2, imm_stype_11, rm_sh], [rd_nosppc, rm_sh] ) + + +armtop("orr", [bs('11110'), imm12_1, bs('00010'), scc, rn_nosppc, bs('0'), imm12_3, rd, imm12_8] ) +armtop("add", [bs('11110'), imm12_1, bs('01000'), scc, rn, bs('0'), imm12_3, rd, imm12_8], [rd, rn, imm12_8]) +armtop("bic", [bs('11110'), imm12_1, bs('00001'), scc, rn_nosppc, bs('0'), imm12_3, rd, imm12_8], [rd, rn_nosppc, imm12_8]) +armtop("and", [bs('11110'), imm12_1, bs('00000'), scc, rn, bs('0'), imm12_3, rd_nopc, imm12_8], [rd_nopc, rn, imm12_8]) +armtop("sub", [bs('11110'), imm12_1, bs('01101'), scc, rn, bs('0'), imm12_3, rd_nopc, imm12_8], [rd_nopc, rn, imm12_8]) +armtop("add", [bs('11110'), imm12_1, bs('10000'), scc, rn_nosppc, bs('0'), imm12_3, rd, imm12_8_t4], [rd, rn_nosppc, imm12_8_t4]) +armtop("cmp", [bs('11110'), imm12_1, bs('01101'), bs('1'), rn, bs('0'), imm12_3, bs('1111'), imm12_8] ) + + +armtop("mvn", [bs('11110'), imm12_1, bs('00011'), scc, bs('1111'), bs('0'), imm12_3, rd, imm12_8]) +armtop("rsb", [bs('11110'), imm12_1, bs('01110'), scc, rn_nosppc, bs('0'), imm12_3, rd, imm12_8], [rd, rn_nosppc, imm12_8]) +armtop("sub", [bs('11110'), imm12_1, bs('101010'), rn_nosppc, bs('0'), imm12_3, rd, imm12_8_t4], [rd, rn_nosppc, imm12_8_t4]) +armtop("tst", [bs('11110'), imm12_1, bs('000001'), rn, bs('0'), imm12_3, bs('1111'), imm12_8], [rn, imm12_8]) + +armtop("mov", [bs('11110'), imm16_1, bs('100100'), imm16_4, bs('0'), imm16_3, rd, imm16_8] ) +armtop("movt", [bs('11110'), imm16_1, bs('101100'), imm16_4, bs('0'), imm16_3, rd, imm16_8] ) + +armtop("sdiv", [bs('111110111001'), rn, bs('1111'), rd, bs('1111'), rm], [rd, rn, rm] ) +armtop("udiv", [bs('111110111011'), rn, bs('1111'), rd, bs('1111'), rm], [rd, rn, rm] ) +armtop("mls", [bs('111110110000'), rn, ra, rd, bs('0001'), rm], [rd, rn, rm, ra] ) +armtop("mla", [bs('111110110000'), rn, ra_nopc, rd, bs('0000'), rm], [rd, rn, rm, ra_nopc] ) +armtop("mul", [bs('111110110000'), rn, bs('1111'), rd, bs('0000'), rm], [rd, rn, rm] ) + +armtop("smlabb", [bs('111110110001'), rn, ra_nopc, rd, bs('00'), bs('00'), rm], [rd, rn, rm, ra_nopc]) +armtop("smlabt", [bs('111110110001'), rn, ra_nopc, rd, bs('00'), bs('01'), rm], [rd, rn, rm, ra_nopc]) +armtop("smlatb", [bs('111110110001'), rn, ra_nopc, rd, bs('00'), bs('10'), rm], [rd, rn, rm, ra_nopc]) +armtop("smlatt", [bs('111110110001'), rn, ra_nopc, rd, bs('00'), bs('11'), rm], [rd, rn, rm, ra_nopc]) + +armtop("b", [bs('11110'), tsign, bm_cond_barmt, timm6h, bs('10'), tj1, bs('0'), tj2, timm6h11l], [timm6h11l]) +armtop("b", [bs('11110'), tsign, timm10H, bs('10'), tj1, bs('1'), tj2, timm11L], [timm11L]) + +armtop("ubfx", [bs('111100111100'), rn, bs('0'), lsb5_3, rd, lsb5_2, bs('0'), widthm1], [rd, rn, lsb5_2, widthm1]) +armtop("uxth", [bs('111110100001'), bs('1111'), bs('1111'), rd, bs('10'), rot2, rm_rot2], [rd, rm_rot2]) + + + +armtop("str", [bs('111110001100'), rn_deref, rt, off12], [rt, rn_deref]) +armtop("str", [bs('111110000100'), rn_noarg, rt, bs('000000'), imm2_noarg, rm_deref_reg], [rt, rm_deref_reg]) +armtop("str", [bs('111110000100'), rn_noarg, rt, bs('1'), ppi, updown, wback_no_t, deref_immpuw], [rt, deref_immpuw]) +armtop("strb", [bs('111110001000'), rn_deref, rt, off12], [rt, rn_deref]) +armtop("strb", [bs('111110000000'), rn_noarg, rt, bs('1'), ppi, updown, wback_no_t, deref_immpuw], [rt, deref_immpuw]) +armtop("strh", [bs('111110001010'), rn_deref, rt, off12], [rt, rn_deref]) +armtop("strh", [bs('111110000010'), rn_noarg, rt, bs('1'), ppi, updown, wback_no_t, deref_immpuw], [rt, deref_immpuw]) + +armtop("strd", [bs('1110100'), ppi, updown, bs('1'), wback_no_t, bs('0'), rn_nopc_noarg, rt, rt2, deref_immpuw00], [rt, rt2, deref_immpuw00]) +armtop("ldrd", [bs('1110100'), ppi, updown, bs('1'), wback_no_t, bs('1'), rn_nopc_noarg, rt, rt2, deref_immpuw00], [rt, rt2, deref_immpuw00]) + + +armtop("ldr", [bs('111110001101'), rn_deref, rt, off12], [rt, rn_deref]) +armtop("ldr", [bs('111110000101'), rn_noarg, rt, bs('1'), ppi, updown, wback_no_t, deref_immpuw], [rt, deref_immpuw]) +armtop("ldr", [bs('111110000101'), rn_noarg, rt, bs('000000'), imm2_noarg, rm_deref_reg], [rt, rm_deref_reg]) +armtop("ldrb", [bs('111110000001'), rn_noarg, rt, bs('000000'), imm2_noarg, rm_deref_reg], [rt, rm_deref_reg]) +armtop("ldrb", [bs('111110000001'), rn_noarg, rt, bs('1'), ppi, updown, wback_no_t, deref_immpuw], [rt, deref_immpuw]) +armtop("ldrb", [bs('111110001001'), rn_deref, rt_nopc, off12], [rt_nopc, rn_deref]) +armtop("ldrsb",[bs('111110011001'), rn_deref, rt, off12], [rt, rn_deref]) +armtop("ldrsh",[bs('111110011011'), rn_deref, rt, off12], [rt, rn_deref]) +armtop("ldrh", [bs('111110001011'), rn_deref, rt, off12], [rt, rn_deref]) +armtop("ldrh", [bs('111110000011'), rn_noarg, rt, bs('1'), ppi, updown, wback_no_t, deref_immpuw], [rt, deref_immpuw]) + +armtop("pld", [bs('111110001001'), rn_deref, bs('1111'), off12], [rn_deref]) +armtop("pldw", [bs('111110001011'), rn_deref, bs('1111'), off12], [rn_deref]) + +armtop("clz", [bs('111110101011'), rm, bs('1111'), rd, bs('1000'), rm_cp], [rd, rm]) +armtop("tbb", [bs('111010001101'), rn_noarg, bs('11110000000'), bs('0'), bs_deref_reg_reg], [bs_deref_reg_reg]) +armtop("tbh", [bs('111010001101'), rn_noarg, bs('11110000000'), bs('1'), bs_deref_reg_reg_lsl_1], [bs_deref_reg_reg_lsl_1]) +armtop("dsb", [bs('111100111011'), bs('1111'), bs('1000'), bs('1111'), bs('0100'), barrier_option]) diff --git a/miasm2/arch/arm/ira.py b/miasm2/arch/arm/ira.py index bfa9bad2..cfcb294c 100644 --- a/miasm2/arch/arm/ira.py +++ b/miasm2/arch/arm/ira.py @@ -47,11 +47,11 @@ class ir_a_armb(ir_a_armb_base, ir_a_arml): class ir_a_armtl(ir_armtl, ir_a_arml): - def __init__(self, symbol_pool): + def __init__(self, symbol_pool=None): ir_armtl.__init__(self, symbol_pool) self.ret_reg = self.arch.regs.R0 class ir_a_armtb(ir_a_armtl, ir_armtb, ir_a_armb): - def __init__(self, symbol_pool): + def __init__(self, symbol_pool=None): ir_armtb.__init__(self, symbol_pool) self.ret_reg = self.arch.regs.R0 diff --git a/miasm2/arch/arm/jit.py b/miasm2/arch/arm/jit.py index b07f2a38..1a37b7f1 100644 --- a/miasm2/arch/arm/jit.py +++ b/miasm2/arch/arm/jit.py @@ -3,7 +3,10 @@ import logging from miasm2.jitter.jitload import jitter, named_arguments from miasm2.core import asmblock from miasm2.core.utils import pck32, upck32 -from miasm2.arch.arm.sem import ir_armb, ir_arml +from miasm2.arch.arm.sem import ir_armb, ir_arml, ir_armtl, ir_armtb, cond_dct_inv, tab_cond +from miasm2.jitter.codegen import CGen +from miasm2.expression.expression import ExprId, ExprAff, ExprCond +from miasm2.ir.ir import IRBlock, AssignBlock log = logging.getLogger('jit_arm') hnd = logging.StreamHandler() @@ -11,7 +14,49 @@ hnd.setFormatter(logging.Formatter("[%(levelname)s]: %(message)s")) log.addHandler(hnd) log.setLevel(logging.CRITICAL) + + +class arm_CGen(CGen): + def __init__(self, ir_arch): + self.ir_arch = ir_arch + self.PC = self.ir_arch.arch.regs.PC + self.init_arch_C() + + + def block2assignblks(self, block): + """ + Return the list of irblocks for a native @block + @block: AsmBlock + """ + irblocks_list = [] + index = -1 + while index + 1 < len(block.lines): + index += 1 + instr = block.lines[index] + + if instr.name.startswith("IT"): + assignments = [] + label = self.ir_arch.get_instr_label(instr) + irblocks = [] + index, irblocks = self.ir_arch.do_it_block(label, index, block, assignments, True) + irblocks_list += irblocks + continue + + + assignblk_head, assignblks_extra = self.ir_arch.instr2ir(instr) + # Keep result in ordered list as first element is the assignblk head + # The remainings order is not really important + irblock_head = self.assignblk_to_irbloc(instr, assignblk_head) + irblocks = [irblock_head] + assignblks_extra + + for irblock in irblocks: + assert irblock.dst is not None + irblocks_list.append(irblocks) + return irblocks_list + + class jitter_arml(jitter): + C_Gen = arm_CGen def __init__(self, *args, **kwargs): sp = asmblock.AsmSymbolPool() @@ -69,9 +114,20 @@ class jitter_arml(jitter): jitter.init_run(self, *args, **kwargs) self.cpu.PC = self.pc + class jitter_armb(jitter_arml): + C_Gen = arm_CGen def __init__(self, *args, **kwargs): sp = asmblock.AsmSymbolPool() jitter.__init__(self, ir_armb(sp), *args, **kwargs) self.vm.set_big_endian() + + +class jitter_armtl(jitter_arml): + C_Gen = arm_CGen + + def __init__(self, *args, **kwargs): + sp = asmblock.AsmSymbolPool() + jitter.__init__(self, ir_armtl(sp), *args, **kwargs) + self.vm.set_little_endian() diff --git a/miasm2/arch/arm/regs.py b/miasm2/arch/arm/regs.py index 8587d7c2..dce4cb98 100644 --- a/miasm2/arch/arm/regs.py +++ b/miasm2/arch/arm/regs.py @@ -63,9 +63,27 @@ of_init = ExprId("of_init", size=1) cf_init = ExprId("cf_init", size=1) +reg_ge0 = 'ge0' +reg_ge1 = 'ge1' +reg_ge2 = 'ge2' +reg_ge3 = 'ge3' + +ge0 = ExprId(reg_ge0, size=1) +ge1 = ExprId(reg_ge1, size=1) +ge2 = ExprId(reg_ge2, size=1) +ge3 = ExprId(reg_ge3, size=1) + +ge0_init = ExprId("ge0_init", size=1) +ge1_init = ExprId("ge1_init", size=1) +ge2_init = ExprId("ge2_init", size=1) +ge3_init = ExprId("ge3_init", size=1) + +ge_regs = [ge0, ge1, ge2, ge3] + all_regs_ids = [ R0, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, SP, LR, PC, zf, nf, of, cf, + ge0, ge1, ge2, ge3, exception_flags, bp_num ] @@ -83,6 +101,7 @@ all_regs_ids_init = [R0_init, R1_init, R2_init, R3_init, R8_init, R9_init, R10_init, R11_init, R12_init, SP_init, LR_init, PC_init, zf_init, nf_init, of_init, cf_init, + ge0_init, ge1_init, ge2_init, ge3_init, ExprInt(0, 32), ExprInt(0, 32) ] diff --git a/miasm2/arch/arm/sem.py b/miasm2/arch/arm/sem.py index 395eb1cb..9e4da3f6 100644 --- a/miasm2/arch/arm/sem.py +++ b/miasm2/arch/arm/sem.py @@ -3,6 +3,7 @@ from miasm2.ir.ir import IntermediateRepresentation, IRBlock, AssignBlock from miasm2.arch.arm.arch import mn_arm, mn_armt from miasm2.arch.arm.regs import * +from miasm2.jitter.csts import EXCEPT_DIV_BY_ZERO # liris.cnrs.fr/~mmrissa/lib/exe/fetch.php?media=armv7-a-r-manual.pdf EXCEPT_SOFT_BP = (1 << 1) @@ -114,7 +115,7 @@ def adc(ir, instr, a, b, c=None): dst = get_dst(a) if dst is not None: e.append(ExprAff(ir.IRDst, r)) - return e + return e, [] def add(ir, instr, a, b, c=None): @@ -129,7 +130,7 @@ def add(ir, instr, a, b, c=None): dst = get_dst(a) if dst is not None: e.append(ExprAff(ir.IRDst, r)) - return e + return e, [] def l_and(ir, instr, a, b, c=None): @@ -143,7 +144,7 @@ def l_and(ir, instr, a, b, c=None): dst = get_dst(a) if dst is not None: e.append(ExprAff(ir.IRDst, r)) - return e + return e, [] def sub(ir, instr, a, b, c=None): @@ -155,7 +156,7 @@ def sub(ir, instr, a, b, c=None): dst = get_dst(a) if dst is not None: e.append(ExprAff(ir.IRDst, r)) - return e + return e, [] def subs(ir, instr, a, b, c=None): @@ -169,7 +170,7 @@ def subs(ir, instr, a, b, c=None): dst = get_dst(a) if dst is not None: e.append(ExprAff(ir.IRDst, r)) - return e + return e, [] def eor(ir, instr, a, b, c=None): @@ -181,7 +182,7 @@ def eor(ir, instr, a, b, c=None): dst = get_dst(a) if dst is not None: e.append(ExprAff(ir.IRDst, r)) - return e + return e, [] def eors(ir, instr, a, b, c=None): @@ -194,7 +195,7 @@ def eors(ir, instr, a, b, c=None): dst = get_dst(a) if dst is not None: e.append(ExprAff(ir.IRDst, r)) - return e + return e, [] def rsb(ir, instr, a, b, c=None): @@ -206,7 +207,7 @@ def rsb(ir, instr, a, b, c=None): dst = get_dst(a) if dst is not None: e.append(ExprAff(ir.IRDst, r)) - return e + return e, [] def rsbs(ir, instr, a, b, c=None): @@ -220,7 +221,7 @@ def rsbs(ir, instr, a, b, c=None): dst = get_dst(a) if dst is not None: e.append(ExprAff(ir.IRDst, r)) - return e + return e, [] def sbc(ir, instr, a, b, c=None): @@ -232,7 +233,7 @@ def sbc(ir, instr, a, b, c=None): dst = get_dst(a) if dst is not None: e.append(ExprAff(ir.IRDst, r)) - return e + return e, [] def sbcs(ir, instr, a, b, c=None): @@ -246,7 +247,7 @@ def sbcs(ir, instr, a, b, c=None): dst = get_dst(a) if dst is not None: e.append(ExprAff(ir.IRDst, r)) - return e + return e, [] def rsc(ir, instr, a, b, c=None): @@ -258,7 +259,7 @@ def rsc(ir, instr, a, b, c=None): dst = get_dst(a) if dst is not None: e.append(ExprAff(ir.IRDst, r)) - return e + return e, [] def rscs(ir, instr, a, b, c=None): @@ -273,16 +274,14 @@ def rscs(ir, instr, a, b, c=None): dst = get_dst(a) if dst is not None: e.append(ExprAff(ir.IRDst, r)) - return e + return e, [] -def tst(ir, instr, a, b, c=None): +def tst(ir, instr, a, b): e = [] - if c is None: - b, c = a, b - r = b & c + r = a & b e += update_flag_logic(r) - return e + return e, [] def teq(ir, instr, a, b, c=None): @@ -291,7 +290,7 @@ def teq(ir, instr, a, b, c=None): b, c = a, b r = b ^ c e += update_flag_logic(r) - return e + return e, [] def l_cmp(ir, instr, a, b, c=None): @@ -301,7 +300,7 @@ def l_cmp(ir, instr, a, b, c=None): r = b - c e += update_flag_arith(r) e += update_flag_sub(b, c, r) - return e + return e, [] def cmn(ir, instr, a, b, c=None): @@ -311,7 +310,7 @@ def cmn(ir, instr, a, b, c=None): r = b + c e += update_flag_arith(r) e += update_flag_add(b, c, r) - return e + return e, [] def orr(ir, instr, a, b, c=None): @@ -323,7 +322,19 @@ def orr(ir, instr, a, b, c=None): dst = get_dst(a) if dst is not None: e.append(ExprAff(ir.IRDst, r)) - return e + return e, [] + + +def orn(ir, instr, a, b, c=None): + e = [] + if c is None: + b, c = a, b + r = ~(b | c) + e.append(ExprAff(a, r)) + dst = get_dst(a) + if dst is not None: + e.append(ExprAff(ir.IRDst, r)) + return e, [] def orrs(ir, instr, a, b, c=None): @@ -336,7 +347,7 @@ def orrs(ir, instr, a, b, c=None): dst = get_dst(a) if dst is not None: e.append(ExprAff(ir.IRDst, r)) - return e + return e, [] def mov(ir, instr, a, b): @@ -344,7 +355,7 @@ def mov(ir, instr, a, b): dst = get_dst(a) if dst is not None: e.append(ExprAff(ir.IRDst, b)) - return e + return e, [] def movt(ir, instr, a, b): @@ -353,7 +364,7 @@ def movt(ir, instr, a, b): dst = get_dst(a) if dst is not None: e.append(ExprAff(ir.IRDst, r)) - return e + return e, [] def movs(ir, instr, a, b): @@ -364,7 +375,7 @@ def movs(ir, instr, a, b): dst = get_dst(a) if dst is not None: e.append(ExprAff(ir.IRDst, b)) - return e + return e, [] def mvn(ir, instr, a, b): @@ -373,7 +384,7 @@ def mvn(ir, instr, a, b): dst = get_dst(a) if dst is not None: e.append(ExprAff(ir.IRDst, r)) - return e + return e, [] def mvns(ir, instr, a, b): @@ -385,7 +396,7 @@ def mvns(ir, instr, a, b): dst = get_dst(a) if dst is not None: e.append(ExprAff(ir.IRDst, r)) - return e + return e, [] def neg(ir, instr, a, b): @@ -395,11 +406,10 @@ def neg(ir, instr, a, b): dst = get_dst(a) if dst is not None: e.append(ExprAff(ir.IRDst, r)) - return e + return e, [] def negs(ir, instr, a, b): - e = subs(ir, instr, a, ExprInt(0, b.size), b) - return e + return subs(ir, instr, a, ExprInt(0, b.size), b) def bic(ir, instr, a, b, c=None): e = [] @@ -410,7 +420,7 @@ def bic(ir, instr, a, b, c=None): dst = get_dst(a) if dst is not None: e.append(ExprAff(ir.IRDst, r)) - return e + return e, [] def bics(ir, instr, a, b, c=None): @@ -423,7 +433,70 @@ def bics(ir, instr, a, b, c=None): dst = get_dst(a) if dst is not None: e.append(ExprAff(ir.IRDst, r)) - return e + return e, [] + + +def sdiv(ir, instr, a, b, c=None): + e = [] + if c is None: + b, c = a, b + + lbl_div = ExprId(ir.gen_label(), ir.IRDst.size) + lbl_except = ExprId(ir.gen_label(), ir.IRDst.size) + lbl_next = ExprId(ir.get_next_label(instr), ir.IRDst.size) + + e.append(ExprAff(ir.IRDst, ExprCond(c, lbl_div, lbl_except))) + + do_except = [] + do_except.append(ExprAff(exception_flags, ExprInt(EXCEPT_DIV_BY_ZERO, exception_flags.size))) + do_except.append(ExprAff(ir.IRDst, lbl_next)) + blk_except = IRBlock(lbl_except.name, [AssignBlock(do_except, instr)]) + + + + r = ExprOp("idiv", b, c) + do_div = [] + do_div.append(ExprAff(a, r)) + dst = get_dst(a) + if dst is not None: + do_div.append(ExprAff(ir.IRDst, r)) + + do_div.append(ExprAff(ir.IRDst, lbl_next)) + blk_div = IRBlock(lbl_div.name, [AssignBlock(do_div, instr)]) + + return e, [blk_div, blk_except] + + +def udiv(ir, instr, a, b, c=None): + e = [] + if c is None: + b, c = a, b + + + + lbl_div = ExprId(ir.gen_label(), ir.IRDst.size) + lbl_except = ExprId(ir.gen_label(), ir.IRDst.size) + lbl_next = ExprId(ir.get_next_label(instr), ir.IRDst.size) + + e.append(ExprAff(ir.IRDst, ExprCond(c, lbl_div, lbl_except))) + + do_except = [] + do_except.append(ExprAff(exception_flags, ExprInt(EXCEPT_DIV_BY_ZERO, exception_flags.size))) + do_except.append(ExprAff(ir.IRDst, lbl_next)) + blk_except = IRBlock(lbl_except.name, [AssignBlock(do_except, instr)]) + + + r = ExprOp("udiv", b, c) + do_div = [] + do_div.append(ExprAff(a, r)) + dst = get_dst(a) + if dst is not None: + do_div.append(ExprAff(ir.IRDst, r)) + + do_div.append(ExprAff(ir.IRDst, lbl_next)) + blk_div = IRBlock(lbl_div.name, [AssignBlock(do_div, instr)]) + + return e, [blk_div, blk_except] def mla(ir, instr, a, b, c, d): @@ -433,7 +506,7 @@ def mla(ir, instr, a, b, c, d): dst = get_dst(a) if dst is not None: e.append(ExprAff(ir.IRDst, r)) - return e + return e, [] def mlas(ir, instr, a, b, c, d): @@ -444,10 +517,20 @@ def mlas(ir, instr, a, b, c, d): dst = get_dst(a) if dst is not None: e.append(ExprAff(ir.IRDst, r)) - return e + return e, [] + + +def mls(ir, instr, a, b, c, d): + e = [] + r = d - (b * c) + e.append(ExprAff(a, r)) + dst = get_dst(a) + if dst is not None: + e.append(ExprAff(ir.IRDst, r)) + return e, [] -def mul(ir, instr, a, b, c = None): +def mul(ir, instr, a, b, c=None): e = [] if c is None: b, c = a, b @@ -456,10 +539,10 @@ def mul(ir, instr, a, b, c = None): dst = get_dst(a) if dst is not None: e.append(ExprAff(ir.IRDst, r)) - return e + return e, [] -def muls(ir, instr, a, b, c = None): +def muls(ir, instr, a, b, c=None): e = [] if c is None: b, c = a, b @@ -469,7 +552,7 @@ def muls(ir, instr, a, b, c = None): dst = get_dst(a) if dst is not None: e.append(ExprAff(ir.IRDst, r)) - return e + return e, [] def umull(ir, instr, a, b, c, d): e = [] @@ -477,7 +560,7 @@ def umull(ir, instr, a, b, c, d): e.append(ExprAff(a, r[0:32])) e.append(ExprAff(b, r[32:64])) # r15/IRDst not allowed as output - return e + return e, [] def umlal(ir, instr, a, b, c, d): e = [] @@ -485,7 +568,7 @@ def umlal(ir, instr, a, b, c, d): e.append(ExprAff(a, r[0:32])) e.append(ExprAff(b, r[32:64])) # r15/IRDst not allowed as output - return e + return e, [] def smull(ir, instr, a, b, c, d): e = [] @@ -493,7 +576,7 @@ def smull(ir, instr, a, b, c, d): e.append(ExprAff(a, r[0:32])) e.append(ExprAff(b, r[32:64])) # r15/IRDst not allowed as output - return e + return e, [] def smlal(ir, instr, a, b, c, d): e = [] @@ -501,13 +584,13 @@ def smlal(ir, instr, a, b, c, d): e.append(ExprAff(a, r[0:32])) e.append(ExprAff(b, r[32:64])) # r15/IRDst not allowed as output - return e + return e, [] def b(ir, instr, a): e = [] e.append(ExprAff(PC, a)) e.append(ExprAff(ir.IRDst, a)) - return e + return e, [] def bl(ir, instr, a): @@ -516,14 +599,14 @@ def bl(ir, instr, a): e.append(ExprAff(PC, a)) e.append(ExprAff(ir.IRDst, a)) e.append(ExprAff(LR, l)) - return e + return e, [] def bx(ir, instr, a): e = [] e.append(ExprAff(PC, a)) e.append(ExprAff(ir.IRDst, a)) - return e + return e, [] def blx(ir, instr, a): @@ -532,10 +615,10 @@ def blx(ir, instr, a): e.append(ExprAff(PC, a)) e.append(ExprAff(ir.IRDst, a)) e.append(ExprAff(LR, l)) - return e + return e, [] -def st_ld_r(ir, instr, a, b, store=False, size=32, s_ext=False, z_ext=False): +def st_ld_r(ir, instr, a, a2, b, store=False, size=32, s_ext=False, z_ext=False): e = [] wb = False b = b.copy() @@ -558,6 +641,9 @@ def st_ld_r(ir, instr, a, b, store=False, size=32, s_ext=False, z_ext=False): else: ad = base + off + # PC base lookup uses PC 4 byte alignemnt + ad = ad.replace_expr({PC: PC & ExprInt(0xFFFFFFFC, 32)}) + dmem = False if size in [8, 16]: if store: @@ -573,9 +659,9 @@ def st_ld_r(ir, instr, a, b, store=False, size=32, s_ext=False, z_ext=False): m = ExprMem(ad, size=size) pass elif size == 64: + assert a2 is not None m = ExprMem(ad, size=32) dmem = True - a2 = ir.arch.regs.all_regs_ids[ir.arch.regs.all_regs_ids.index(a) + 1] size = 32 else: raise ValueError('the size DOES matter') @@ -596,55 +682,53 @@ def st_ld_r(ir, instr, a, b, store=False, size=32, s_ext=False, z_ext=False): # XXX TODO check multiple write cause by wb if wb or postinc: e.append(ExprAff(base, base + off)) - return e + return e, [] def ldr(ir, instr, a, b): - return st_ld_r(ir, instr, a, b, store=False) + return st_ld_r(ir, instr, a, None, b, store=False) -def ldrd(ir, instr, a, b): - e = st_ld_r(ir, instr, a, b, store=False, size=64) - return e +def ldrd(ir, instr, a, b, c=None): + if c is None: + a2 = ir.arch.regs.all_regs_ids[ir.arch.regs.all_regs_ids.index(a) + 1] + else: + a2 = b + b = c + return st_ld_r(ir, instr, a, a2, b, store=False, size=64) def l_str(ir, instr, a, b): - return st_ld_r(ir, instr, a, b, store=True) + return st_ld_r(ir, instr, a, None, b, store=True) -def l_strd(ir, instr, a, b): - e = st_ld_r(ir, instr, a, b, store=True, size=64) - return e - +def l_strd(ir, instr, a, b, c=None): + if c is None: + a2 = ir.arch.regs.all_regs_ids[ir.arch.regs.all_regs_ids.index(a) + 1] + else: + a2 = b + b = c + return st_ld_r(ir, instr, a, a2, b, store=True, size=64) def ldrb(ir, instr, a, b): - e = st_ld_r(ir, instr, a, b, store=False, size=8, z_ext=True) - return e + return st_ld_r(ir, instr, a, None, b, store=False, size=8, z_ext=True) def ldrsb(ir, instr, a, b): - e = st_ld_r( - ir, instr, a, b, store=False, size=8, s_ext=True, z_ext=False) - return e + return st_ld_r(ir, instr, a, None, b, store=False, size=8, s_ext=True, z_ext=False) def strb(ir, instr, a, b): - e = st_ld_r(ir, instr, a, b, store=True, size=8) - return e - + return st_ld_r(ir, instr, a, None, b, store=True, size=8) def ldrh(ir, instr, a, b): - e = st_ld_r(ir, instr, a, b, store=False, size=16, z_ext=True) - return e + return st_ld_r(ir, instr, a, None, b, store=False, size=16, z_ext=True) def strh(ir, instr, a, b): - e = st_ld_r(ir, instr, a, b, store=True, size=16, z_ext=True) - return e + return st_ld_r(ir, instr, a, None, b, store=True, size=16, z_ext=True) def ldrsh(ir, instr, a, b): - e = st_ld_r( - ir, instr, a, b, store=False, size=16, s_ext=True, z_ext=False) - return e + return st_ld_r(ir, instr, a, None, b, store=False, size=16, s_ext=True, z_ext=False) def st_ld_m(ir, instr, a, b, store=False, postinc=False, updown=False): @@ -688,7 +772,7 @@ def st_ld_m(ir, instr, a, b, store=False, postinc=False, updown=False): else: assert(isinstance(b, ExprOp) and b.op == "reglist") - return e + return e, [] def ldmia(ir, instr, a, b): @@ -727,16 +811,16 @@ def svc(ir, instr, a): # XXX TODO implement e = [ ExprAff(exception_flags, ExprInt(EXCEPT_PRIV_INSN, 32))] - return e + return e, [] def und(ir, instr, a, b): # XXX TODO implement e = [] - return e + return e, [] # TODO XXX implement correct CF for shifters -def lsr(ir, instr, a, b, c = None): +def lsr(ir, instr, a, b, c=None): e = [] if c is None: b, c = a, b @@ -745,10 +829,10 @@ def lsr(ir, instr, a, b, c = None): dst = get_dst(a) if dst is not None: e.append(ExprAff(ir.IRDst, r)) - return e + return e, [] -def lsrs(ir, instr, a, b, c = None): +def lsrs(ir, instr, a, b, c=None): e = [] if c is None: b, c = a, b @@ -758,7 +842,7 @@ def lsrs(ir, instr, a, b, c = None): dst = get_dst(a) if dst is not None: e.append(ExprAff(ir.IRDst, r)) - return e + return e, [] def asr(ir, instr, a, b, c=None): e = [] @@ -769,9 +853,9 @@ def asr(ir, instr, a, b, c=None): dst = get_dst(a) if dst is not None: e.append(ExprAff(ir.IRDst, r)) - return e + return e, [] -def asrs(ir, instr, a, b, c): +def asrs(ir, instr, a, b, c=None): e = [] if c is None: b, c = a, b @@ -781,9 +865,9 @@ def asrs(ir, instr, a, b, c): dst = get_dst(a) if dst is not None: e.append(ExprAff(ir.IRDst, r)) - return e + return e, [] -def lsl(ir, instr, a, b, c = None): +def lsl(ir, instr, a, b, c=None): e = [] if c is None: b, c = a, b @@ -792,10 +876,10 @@ def lsl(ir, instr, a, b, c = None): dst = get_dst(a) if dst is not None: e.append(ExprAff(ir.IRDst, r)) - return e + return e, [] -def lsls(ir, instr, a, b, c = None): +def lsls(ir, instr, a, b, c=None): e = [] if c is None: b, c = a, b @@ -805,18 +889,29 @@ def lsls(ir, instr, a, b, c = None): dst = get_dst(a) if dst is not None: e.append(ExprAff(ir.IRDst, r)) - return e + return e, [] + + +def rors(ir, instr, a, b): + e = [] + r = ExprOp(">>>", a, b) + e.append(ExprAff(a, r)) + e += update_flag_logic(r) + dst = get_dst(a) + if dst is not None: + e.append(ExprAff(ir.IRDst, r)) + return e, [] def push(ir, instr, a): e = [] regs = list(a.args) for i in xrange(len(regs)): - r = SP + ExprInt(-4 * (i + 1), 32) + r = SP + ExprInt(-4 * len(regs) + 4 * i, 32) e.append(ExprAff(ExprMem(r, 32), regs[i])) r = SP + ExprInt(-4 * len(regs), 32) e.append(ExprAff(SP, r)) - return e + return e, [] def pop(ir, instr, a): @@ -832,21 +927,21 @@ def pop(ir, instr, a): e.append(ExprAff(SP, r)) if dst is not None: e.append(ExprAff(ir.IRDst, dst)) - return e + return e, [] def cbz(ir, instr, a, b): e = [] lbl_next = ExprId(ir.get_next_label(instr), 32) e.append(ExprAff(ir.IRDst, ExprCond(a, lbl_next, b))) - return e + return e, [] def cbnz(ir, instr, a, b): e = [] lbl_next = ExprId(ir.get_next_label(instr), 32) - e.append(ir.IRDst, ExprCond(a, b, lbl_next)) - return e + e.append(ExprAff(ir.IRDst, ExprCond(a, b, lbl_next))) + return e, [] @@ -858,7 +953,7 @@ def uxtb(ir, instr, a, b): if PC in a.get_r(): dst = PC e.append(ExprAff(ir.IRDst, r)) - return e + return e, [] def uxth(ir, instr, a, b): e = [] @@ -868,7 +963,7 @@ def uxth(ir, instr, a, b): if PC in a.get_r(): dst = PC e.append(ExprAff(ir.IRDst, r)) - return e + return e, [] def sxtb(ir, instr, a, b): e = [] @@ -878,7 +973,7 @@ def sxtb(ir, instr, a, b): if PC in a.get_r(): dst = PC e.append(ExprAff(ir.IRDst, r)) - return e + return e, [] def sxth(ir, instr, a, b): e = [] @@ -888,7 +983,7 @@ def sxth(ir, instr, a, b): if PC in a.get_r(): dst = PC e.append(ExprAff(ir.IRDst, r)) - return e + return e, [] def ubfx(ir, instr, a, b, c, d): @@ -901,7 +996,7 @@ def ubfx(ir, instr, a, b, c, d): if PC in a.get_r(): dst = PC e.append(ExprAff(ir.IRDst, r)) - return e + return e, [] def bfc(ir, instr, a, b, c): e = [] @@ -923,34 +1018,41 @@ def bfc(ir, instr, a, b, c): if PC in a.get_r(): dst = PC e.append(ExprAff(ir.IRDst, r)) - return e + return e, [] def rev(ir, instr, a, b): e = [] c = ExprCompose(b[24:32], b[16:24], b[8:16], b[:8]) e.append(ExprAff(a, c)) - return e + return e, [] def pld(ir, instr, a): - return [] + e = [] + return e, [] + + +def pldw(ir, instr, a): + e = [] + return e, [] def clz(ir, instr, a, b): e = [] e.append(ExprAff(a, ExprOp('clz', b))) - return e + return e, [] def uxtab(ir, instr, a, b, c): e = [] e.append(ExprAff(a, b + (c & ExprInt(0xff, 32)))) - return e + return e, [] def bkpt(ir, instr, a): e = [] e.append(ExprAff(exception_flags, ExprInt(EXCEPT_SOFT_BP, 32))) e.append(ExprAff(bp_num, a)) - return e + return e, [] + def _extract_s16(arg, part): if part == 'B': # bottom 16 bits @@ -958,12 +1060,131 @@ def _extract_s16(arg, part): elif part == 'T': # top 16 bits return arg[16:32] + def smul(ir, instr, a, b, c): - return [ExprAff(a, _extract_s16(b, instr.name[4]).signExtend(32) * _extract_s16(c, instr.name[5]).signExtend(32))] + e = [] + e.append(ExprAff(a, _extract_s16(b, instr.name[4]).signExtend(32) * _extract_s16(c, instr.name[5]).signExtend(32))) + return e, [] + def smulw(ir, instr, a, b, c): + e = [] prod = b.signExtend(48) * _extract_s16(c, instr.name[5]).signExtend(48) - return [ExprAff(a, prod[16:48])] # signed most significant 32 bits of the 48-bit result + e.append(ExprAff(a, prod[16:48])) + return e, [] # signed most significant 32 bits of the 48-bit result + + +def tbb(ir, instr, a): + e = [] + dst = PC + ExprInt(2, 32) * a.zeroExtend(32) + e.append(ExprAff(PC, dst)) + e.append(ExprAff(ir.IRDst, dst)) + return e, [] + + +def tbh(ir, instr, a): + e = [] + dst = PC + ExprInt(2, 32) * a.zeroExtend(32) + e.append(ExprAff(PC, dst)) + e.append(ExprAff(ir.IRDst, dst)) + return e, [] + + +def smlabb(ir, instr, a, b, c, d): + e = [] + result = (b[:16].signExtend(32) * c[:16].signExtend(32)) + d + e.append(ExprAff(a, result)) + return e, [] + + +def smlabt(ir, instr, a, b, c, d): + e = [] + result = (b[:16].signExtend(32) * c[16:32].signExtend(32)) + d + e.append(ExprAff(a, result)) + return e, [] + + +def smlatb(ir, instr, a, b, c, d): + e = [] + result = (b[16:32].signExtend(32) * c[:16].signExtend(32)) + d + e.append(ExprAff(a, result)) + return e, [] + + +def smlatt(ir, instr, a, b, c, d): + e = [] + result = (b[16:32].signExtend(32) * c[16:32].signExtend(32)) + d + e.append(ExprAff(a, result)) + return e, [] + + +def uadd8(ir, instr, a, b, c): + e = [] + sums = [] + ges = [] + for i in xrange(0, 32, 8): + sums.append(b[i:i+8] + c[i:i+8]) + ges.append((b[i:i+8].zeroExtend(9) + c[i:i+8].zeroExtend(9))[8:9]) + + e.append(ExprAff(a, ExprCompose(*sums))) + + for i, value in enumerate(ges): + e.append(ExprAff(ge_regs[i], value)) + return e, [] + + +def sel(ir, instr, a, b, c): + e = [] + cond = nf ^ of ^ ExprInt(1, 1) + parts = [] + for i in xrange(4): + parts.append(ExprCond(ge_regs[i], b[i*8:(i+1)*8], c[i*8:(i+1)*8])) + result = ExprCompose(*parts) + e.append(ExprAff(a, result)) + return e, [] + + +def rev(ir, instr, a, b): + e = [] + result = ExprCompose(b[24:32], b[16:24], b[8:16], b[:8]) + e.append(ExprAff(a, result)) + return e, [] + + +def nop(ir, instr): + e = [] + return e, [] + + +def dsb(ir, instr, a): + # XXX TODO + e = [] + return e, [] + + +def cpsie(ir, instr, a): + # XXX TODO + e = [] + return e, [] + + +def cpsid(ir, instr, a): + # XXX TODO + e = [] + return e, [] + + +def wfe(ir, instr): + # XXX TODO + e = [] + return e, [] + + +def wfi(ir, instr): + # XXX TODO + e = [] + return e, [] + COND_EQ = 0 COND_NE = 1 @@ -1001,6 +1222,7 @@ cond_dct = { # COND_NV: "NV", } +cond_dct_inv = dict((name, num) for num, name in cond_dct.iteritems()) tab_cond = {COND_EQ: zf, COND_NE: ExprCond(zf, ExprInt(0, 1), ExprInt(1, 1)), @@ -1035,9 +1257,9 @@ def is_pc_written(ir, instr_ir): return False, None -def add_condition_expr(ir, instr, cond, instr_ir): +def add_condition_expr(ir, instr, cond, instr_ir, extra_ir): if cond == COND_AL: - return instr_ir, [] + return instr_ir, extra_ir if not cond in tab_cond: raise ValueError('unknown condition %r' % cond) cond = tab_cond[cond] @@ -1057,7 +1279,7 @@ def add_condition_expr(ir, instr, cond, instr_ir): instr_ir.append(ExprAff(ir.IRDst, lbl_next)) e_do = IRBlock(lbl_do.name, [AssignBlock(instr_ir, instr)]) e = [ExprAff(ir.IRDst, dst_cond)] - return e, [e_do] + return e, [e_do] + extra_ir mnemo_func = {} mnemo_func_cond = {} @@ -1081,6 +1303,9 @@ mnemo_condm0 = {'add': add, 'mvn': mvn, 'neg': neg, + 'sdiv': sdiv, + 'udiv': udiv, + 'mul': mul, 'umull': umull, 'umlal': umlal, @@ -1134,6 +1359,7 @@ mnemo_condm1 = {'adds': add, 'negs': negs, 'muls': muls, + 'mls': mls, 'mlas': mlas, 'blx': blx, @@ -1170,6 +1396,7 @@ mnemo_nocond = {'lsr': lsr, 'lsrs': lsrs, 'lsl': lsl, 'lsls': lsls, + 'rors': rors, 'push': push, 'pop': pop, 'asr': asr, @@ -1177,7 +1404,24 @@ mnemo_nocond = {'lsr': lsr, 'cbz': cbz, 'cbnz': cbnz, 'pld': pld, + 'pldw': pldw, + 'tbb': tbb, + 'tbh': tbh, + 'nop': nop, + 'dsb': dsb, + 'cpsie': cpsie, + 'cpsid': cpsid, + 'wfe': wfe, + 'wfi': wfi, + 'orn': orn, + 'smlabb': smlabb, + 'smlabt': smlabt, + 'smlatb': smlatb, + 'smlatt': smlatt, + 'uadd8': uadd8, + 'sel': sel, } + mn_cond_x = [mnemo_condm0, mnemo_condm1, mnemo_condm2] @@ -1215,8 +1459,8 @@ def get_mnemo_expr(ir, instr, *args): if not instr.name.lower() in mnemo_func_cond: raise ValueError('unknown mnemo %s' % instr) cond, mf = mnemo_func_cond[instr.name.lower()] - instr_ir = mf(ir, instr, *args) - instr, extra_ir = add_condition_expr(ir, instr, cond, instr_ir) + instr_ir, extra_ir = mf(ir, instr, *args) + instr, extra_ir = add_condition_expr(ir, instr, cond, instr_ir, extra_ir) return instr, extra_ir get_arm_instr_expr = get_mnemo_expr @@ -1235,6 +1479,24 @@ class ir_arml(IntermediateRepresentation): self.IRDst = ExprId('IRDst', 32) self.addrsize = 32 + + + def mod_pc(self, instr, instr_ir, extra_ir): + # fix PC (+8 for arm) + pc_fixed = {self.pc: ExprInt(instr.offset + 8, 32)} + + for i, expr in enumerate(instr_ir): + dst, src = expr.dst, expr.src + if dst != self.pc: + dst = dst.replace_expr(pc_fixed) + src = src.replace_expr(pc_fixed) + instr_ir[i] = ExprAff(dst, src) + + for idx, irblock in enumerate(extra_ir): + extra_ir[idx] = irblock.modify_exprs(lambda expr: expr.replace_expr(pc_fixed) \ + if expr != self.pc else expr, + lambda expr: expr.replace_expr(pc_fixed)) + def get_ir(self, instr): args = instr.args # ir = get_mnemo_expr(self, self.name.lower(), *args) @@ -1248,14 +1510,120 @@ class ir_arml(IntermediateRepresentation): args[-1].args[-1][:8].zeroExtend(32)) instr_ir, extra_ir = get_mnemo_expr(self, instr, *args) - pc_fixed = {self.pc: ExprInt(instr.offset + 8, 32)} - for i, expr in enumerate(instr_ir): - instr_ir[i] = ExprAff(expr.dst, expr.src.replace_expr(pc_fixed)) - - new_extra_ir = [irblock.modify_exprs(mod_src=lambda expr: expr.replace_expr(pc_fixed)) - for irblock in extra_ir] + self.mod_pc(instr, instr_ir, extra_ir) + return instr_ir, extra_ir + + def parse_itt(self, instr): + name = instr.name + assert name.startswith('IT') + name = name[1:] + out = [] + for hint in name: + if hint == 'T': + out.append(0) + elif hint == "E": + out.append(1) + else: + raise ValueError("IT name invalid %s" % instr) + return out, instr.args[0] + + def do_it_block(self, label, index, block, assignments, gen_pc_updt): + instr = block.lines[index] + it_hints, it_cond = self.parse_itt(instr) + cond_num = cond_dct_inv[it_cond.name] + cond_eq = tab_cond[cond_num] + + if not index + len(it_hints) <= len(block.lines): + raise NotImplementedError("Splitted IT block non supported yet") + + ir_blocks_all = [] + + # Gen dummy irblock for IT instr + label_next = self.get_next_label(instr) + dst = ExprAff(self.IRDst, ExprId(label_next, 32)) + dst_blk = AssignBlock([dst], instr) + assignments.append(dst_blk) + irblock = IRBlock(label, assignments) + ir_blocks_all.append([irblock]) + + label = label_next + assignments = [] + for hint in it_hints: + irblocks = [] + index += 1 + instr = block.lines[index] + + # Add conditionnal jump to current irblock + label_do = self.symbol_pool.gen_label() + label_next = self.get_next_label(instr) + + if hint: + local_cond = ~cond_eq + else: + local_cond = cond_eq + dst = ExprAff(self.IRDst, ExprCond(local_cond, ExprId(label_do, 32), ExprId(label_next, 32))) + dst_blk = AssignBlock([dst], instr) + assignments.append(dst_blk) + irblock = IRBlock(label, assignments) + + irblocks.append(irblock) + + assignments = [] + label = label_do + split = self.add_instr_to_irblock(block, instr, assignments, + irblocks, gen_pc_updt) + if split: + raise NotImplementedError("Unsupported instr in IT block (%s)" % instr) + + dst = ExprAff(self.IRDst, ExprId(label_next, 32)) + dst_blk = AssignBlock([dst], instr) + assignments.append(dst_blk) + irblock = IRBlock(label, assignments) + irblocks.append(irblock) + label = label_next + assignments = [] + ir_blocks_all.append(irblocks) + return index, ir_blocks_all + + def add_block(self, block, gen_pc_updt=False): + """ + Add a native block to the current IR + @block: native assembly block + @gen_pc_updt: insert PC update effects between instructions + """ + + it_hints = None + it_cond = None + label = None + ir_blocks_all = [] + index = -1 + while index + 1 < len(block.lines): + index += 1 + instr = block.lines[index] + if label is None: + assignments = [] + label = self.get_instr_label(instr) + if instr.name.startswith("IT"): + index, irblocks_it = self.do_it_block(label, index, block, assignments, gen_pc_updt) + for irblocks in irblocks_it: + ir_blocks_all += irblocks + label = None + continue + + split = self.add_instr_to_irblock(block, instr, assignments, + ir_blocks_all, gen_pc_updt) + if split: + ir_blocks_all.append(IRBlock(label, assignments)) + label = None + assignments = [] + if label is not None: + ir_blocks_all.append(IRBlock(label, assignments)) + + new_ir_blocks_all = self.post_add_block(block, ir_blocks_all) + for irblock in new_ir_blocks_all: + self.blocks[irblock.label] = irblock + return new_ir_blocks_all - return instr_ir, new_extra_ir class ir_armb(ir_arml): @@ -1266,7 +1634,8 @@ class ir_armb(ir_arml): self.IRDst = ExprId('IRDst', 32) self.addrsize = 32 -class ir_armtl(IntermediateRepresentation): + +class ir_armtl(ir_arml): def __init__(self, symbol_pool=None): IntermediateRepresentation.__init__(self, mn_armt, "l", symbol_pool) self.pc = PC @@ -1274,8 +1643,23 @@ class ir_armtl(IntermediateRepresentation): self.IRDst = ExprId('IRDst', 32) self.addrsize = 32 - def get_ir(self, instr): - return get_mnemo_expr(self, instr, *instr.args) + + def mod_pc(self, instr, instr_ir, extra_ir): + # fix PC (+4 for thumb) + pc_fixed = {self.pc: ExprInt(instr.offset + 4, 32)} + + for i, expr in enumerate(instr_ir): + dst, src = expr.dst, expr.src + if dst != self.pc: + dst = dst.replace_expr(pc_fixed) + src = src.replace_expr(pc_fixed) + instr_ir[i] = ExprAff(dst, src) + + for idx, irblock in enumerate(extra_ir): + extra_ir[idx] = irblock.modify_exprs(lambda expr: expr.replace_expr(pc_fixed) \ + if expr != self.pc else expr, + lambda expr: expr.replace_expr(pc_fixed)) + class ir_armtb(ir_armtl): def __init__(self, symbol_pool=None): diff --git a/miasm2/arch/mips32/arch.py b/miasm2/arch/mips32/arch.py index 3abdc053..15c59cf0 100644 --- a/miasm2/arch/mips32/arch.py +++ b/miasm2/arch/mips32/arch.py @@ -5,11 +5,13 @@ from collections import defaultdict from pyparsing import Literal, Group, Optional -from miasm2.expression.expression import ExprMem, ExprInt, ExprId +from miasm2.expression.expression import ExprMem, ExprInt, ExprId, ExprOp from miasm2.core.bin_stream import bin_stream import miasm2.arch.mips32.regs as regs import miasm2.core.cpu as cpu +from miasm2.core.asm_ast import AstInt, AstId, AstMem, AstOp + log = logging.getLogger("mips32dis") console_handler = logging.StreamHandler() console_handler.setFormatter(logging.Formatter("%(levelname)-5s: %(message)s")) @@ -20,48 +22,26 @@ log.setLevel(logging.DEBUG) gpregs = cpu.reg_info(regs.regs32_str, regs.regs32_expr) - LPARENTHESIS = Literal("(") RPARENTHESIS = Literal(")") -def deref2expr(s, l, t): - t = t[0] - if len(t) != 4: +def cb_deref(tokens): + if len(tokens) != 4: raise NotImplementedError("TODO") + return AstMem(tokens[2] + tokens[0], 32) - return ExprMem(t[2] + t[0], 32) - -def deref2expr_nooff(s, l, t): - t = t[0] - if len(t) != 3: +def cb_deref_nooff(tokens): + if len(tokens) != 3: raise NotImplementedError("TODO") - return ExprMem(t[1], 32) + return AstMem(tokens[1], 32) base_expr = cpu.base_expr -deref_off = Group(Optional(cpu.base_expr) + LPARENTHESIS + gpregs.parser + \ - RPARENTHESIS).setParseAction(deref2expr) -deref_nooff = Group(LPARENTHESIS + gpregs.parser + \ - RPARENTHESIS).setParseAction(deref2expr_nooff) +deref_off = (Optional(base_expr) + LPARENTHESIS + gpregs.parser + RPARENTHESIS).setParseAction(cb_deref) +deref_nooff = (LPARENTHESIS + gpregs.parser + RPARENTHESIS).setParseAction(cb_deref_nooff) deref = deref_off | deref_nooff -variable, operand, base_expr = cpu.gen_base_expr() - -int_or_expr = base_expr - - -def ast_id2expr(t): - return mn_mips32.regs.all_regs_ids_byname.get(t, t) - - -def ast_int2expr(a): - return ExprInt(a, 32) - - -my_var_parser = cpu.ParseAst(ast_id2expr, ast_int2expr) -base_expr.setParseAction(my_var_parser) - class additional_info: def __init__(self): self.except_on_instr = False @@ -274,8 +254,31 @@ def mips32op(name, fields, args=None, alias=False): type(name, (mn_mips32,), dct) #type(name, (mn_mips32b,), dct) - -class mips32_reg(cpu.reg_noarg, cpu.m_arg): +class mips32_arg(cpu.m_arg): + def asm_ast_to_expr(self, arg, symbol_pool): + if isinstance(arg, AstId): + if isinstance(arg.name, ExprId): + return arg.name + if arg.name in gpregs.str: + return None + label = symbol_pool.getby_name_create(arg.name) + return ExprId(label, 32) + if isinstance(arg, AstOp): + args = [self.asm_ast_to_expr(tmp, symbol_pool) for tmp in arg.args] + if None in args: + return None + return ExprOp(arg.op, *args) + if isinstance(arg, AstInt): + return ExprInt(arg.value, 32) + if isinstance(arg, AstMem): + ptr = self.asm_ast_to_expr(arg.ptr, symbol_pool) + if ptr is None: + return None + return ExprMem(ptr, arg.size) + return None + + +class mips32_reg(cpu.reg_noarg, mips32_arg): pass class mips32_gpreg(mips32_reg): @@ -335,14 +338,14 @@ class mips32_soff_noarg(mips32_imm): return True -class mips32_s16imm(mips32_s16imm_noarg, cpu.m_arg): +class mips32_s16imm(mips32_s16imm_noarg, mips32_arg): pass -class mips32_soff(mips32_soff_noarg, cpu.m_arg): +class mips32_soff(mips32_soff_noarg, mips32_arg): pass -class mips32_instr_index(mips32_imm, cpu.m_arg): +class mips32_instr_index(mips32_imm, mips32_arg): def decode(self, v): v = v & self.lmask self.expr = ExprInt(v<<2, 32) @@ -361,7 +364,7 @@ class mips32_instr_index(mips32_imm, cpu.m_arg): return True -class mips32_u16imm(mips32_imm, cpu.m_arg): +class mips32_u16imm(mips32_imm, mips32_arg): def decode(self, v): v = v & self.lmask self.expr = ExprInt(v, 32) @@ -375,7 +378,7 @@ class mips32_u16imm(mips32_imm, cpu.m_arg): self.value = v return True -class mips32_dreg_imm(cpu.m_arg): +class mips32_dreg_imm(mips32_arg): parser = deref def decode(self, v): imm = self.parent.imm.expr @@ -408,7 +411,7 @@ class mips32_dreg_imm(cpu.m_arg): assert(len(arg.args) == 2 and arg.op == '+') return "%s(%s)"%(arg.args[1], arg.args[0]) -class mips32_esize(mips32_imm, cpu.m_arg): +class mips32_esize(mips32_imm, mips32_arg): def decode(self, v): v = v & self.lmask self.expr = ExprInt(v+1, 32) @@ -422,7 +425,7 @@ class mips32_esize(mips32_imm, cpu.m_arg): self.value = v return True -class mips32_eposh(mips32_imm, cpu.m_arg): +class mips32_eposh(mips32_imm, mips32_arg): def decode(self, v): self.expr = ExprInt(v-int(self.parent.epos.expr)+1, 32) return True @@ -437,7 +440,7 @@ class mips32_eposh(mips32_imm, cpu.m_arg): -class mips32_cpr(cpu.m_arg): +class mips32_cpr(mips32_arg): parser = regs.regs_cpr0_info.parser def decode(self, v): index = int(self.parent.cpr0.expr) << 3 @@ -605,6 +608,8 @@ bs_bcc = cpu.bs_name(l=5, name = {"BGEZ": 0b00001, }) +bs_code = cpu.bs(l=10) + mips32op("addi", [cpu.bs('001000'), rs, rt, s16imm], [rt, rs, s16imm]) mips32op("addiu", [cpu.bs('001001'), rs, rt, s16imm], [rt, rs, s16imm]) @@ -740,3 +745,7 @@ mips32op("tlbp", [cpu.bs('010000'), cpu.bs('1'), cpu.bs('0'*19), cpu.bs('001000')]) mips32op("tlbwi", [cpu.bs('010000'), cpu.bs('1'), cpu.bs('0'*19), cpu.bs('000010')]) + + +mips32op("teq", [cpu.bs('000000'), rs, rt, bs_code, cpu.bs('110100')], + [rs, rt]) diff --git a/miasm2/arch/mips32/jit.py b/miasm2/arch/mips32/jit.py index 1d2ec483..16d88067 100644 --- a/miasm2/arch/mips32/jit.py +++ b/miasm2/arch/mips32/jit.py @@ -1,6 +1,6 @@ import logging -from miasm2.jitter.jitload import jitter +from miasm2.jitter.jitload import jitter, named_arguments from miasm2.core import asmblock from miasm2.core.utils import pck32, upck32 from miasm2.arch.mips32.sem import ir_mips32l, ir_mips32b @@ -104,6 +104,42 @@ class jitter_mips32l(jitter): jitter.init_run(self, *args, **kwargs) self.cpu.PC = self.pc + # calling conventions + + @named_arguments + def func_args_stdcall(self, n_args): + args = [self.get_arg_n_stdcall(i) for i in xrange(n_args)] + ret_ad = self.cpu.RA + return ret_ad, args + + def func_ret_stdcall(self, ret_addr, ret_value1=None, ret_value2=None): + self.pc = self.cpu.PC = ret_addr + if ret_value1 is not None: + self.cpu.V0 = ret_value1 + if ret_value2 is not None: + self.cpu.V1 = ret_value2 + return True + + def func_prepare_stdcall(self, ret_addr, *args): + for index in xrange(min(len(args), 4)): + setattr(self.cpu, 'A%d' % index, args[index]) + for index in xrange(4, len(args)): + self.vm.set_mem(self.cpu.SP + 4 * (index - 4), pck32(args[index])) + self.cpu.RA = ret_addr + + def get_arg_n_stdcall(self, index): + if index < 4: + arg = getattr(self.cpu, 'A%d' % index) + else: + arg = self.get_stack_arg(index-4) + return arg + + + func_args_systemv = func_args_stdcall + func_ret_systemv = func_ret_stdcall + func_prepare_systemv = func_prepare_stdcall + get_arg_n_systemv = get_arg_n_stdcall + class jitter_mips32b(jitter_mips32l): diff --git a/miasm2/arch/mips32/regs.py b/miasm2/arch/mips32/regs.py index afade869..7ff949f2 100644 --- a/miasm2/arch/mips32/regs.py +++ b/miasm2/arch/mips32/regs.py @@ -4,11 +4,11 @@ from miasm2.expression.expression import ExprId from miasm2.core.cpu import gen_reg, gen_regs -gen_reg('PC', globals()) -gen_reg('PC_FETCH', globals()) +PC, _ = gen_reg('PC') +PC_FETCH, _ = gen_reg('PC_FETCH') -gen_reg('R_LO', globals()) -gen_reg('R_HI', globals()) +R_LO, _ = gen_reg('R_LO') +R_HI, _ = gen_reg('R_HI') exception_flags = ExprId('exception_flags', 32) @@ -55,11 +55,10 @@ regs_flt_expr, regs_flt_init, fltregs = gen_regs(regs_flt_str, globals(), sz=64) regs_fcc_expr, regs_fcc_init, fccregs = gen_regs(regs_fcc_str, globals()) -all_regs_ids = [PC, PC_FETCH, R_LO, R_HI] + gpregs_expr + regs_flt_expr + \ +all_regs_ids = [PC, PC_FETCH, R_LO, R_HI, exception_flags] + gpregs_expr + regs_flt_expr + \ regs_fcc_expr + regs_cpr0_expr all_regs_ids_byname = dict([(x.name, x) for x in all_regs_ids]) -all_regs_ids_init = [PC_init, PC_FETCH_init, R_LO_init, R_HI_init] + \ - gpregs_init + regs_flt_init + regs_fcc_init + regs_cpr0_init +all_regs_ids_init = [ExprId("%s_init" % reg.name, reg.size) for reg in all_regs_ids] all_regs_ids_no_alias = all_regs_ids[:] attrib_to_regs = { diff --git a/miasm2/arch/mips32/sem.py b/miasm2/arch/mips32/sem.py index 789491f6..99c81a33 100644 --- a/miasm2/arch/mips32/sem.py +++ b/miasm2/arch/mips32/sem.py @@ -1,8 +1,9 @@ import miasm2.expression.expression as m2_expr -from miasm2.ir.ir import IntermediateRepresentation, IRBlock +from miasm2.ir.ir import IntermediateRepresentation, IRBlock, AssignBlock from miasm2.arch.mips32.arch import mn_mips32 -from miasm2.arch.mips32.regs import R_LO, R_HI, PC, RA +from miasm2.arch.mips32.regs import R_LO, R_HI, PC, RA, exception_flags from miasm2.core.sembuilder import SemBuilder +from miasm2.jitter.csts import EXCEPT_DIV_BY_ZERO # SemBuilder context @@ -377,6 +378,18 @@ def multu(arg1, arg2): R_HI = result[32:] @sbuild.parse +def div(arg1, arg2): + """Divide (signed) @arg1 by @arg2 and stores the remaining/result in $R_HI/$R_LO""" + R_LO = ExprOp('idiv' ,arg1, arg2) + R_HI = ExprOp('imod', arg1, arg2) + +@sbuild.parse +def divu(arg1, arg2): + """Divide (unsigned) @arg1 by @arg2 and stores the remaining/result in $R_HI/$R_LO""" + R_LO = ExprOp('udiv', arg1, arg2) + R_HI = ExprOp('umod', arg1, arg2) + +@sbuild.parse def mfhi(arg1): "The contents of register $R_HI are moved to the specified register @arg1." arg1 = R_HI @@ -398,6 +411,30 @@ def ei(arg1): def ehb(arg1): "NOP" + +def teq(ir, instr, arg1, arg2): + e = [] + + lbl_except, lbl_except_expr = ir.gen_label_and_expr(ir.IRDst.size) + lbl_next = ir.get_next_label(instr) + lbl_next_expr = m2_expr.ExprId(lbl_next, ir.IRDst.size) + + do_except = [] + do_except.append(m2_expr.ExprAff(exception_flags, m2_expr.ExprInt( + EXCEPT_DIV_BY_ZERO, exception_flags.size))) + do_except.append(m2_expr.ExprAff(ir.IRDst, lbl_next_expr)) + blk_except = IRBlock(lbl_except, [AssignBlock(do_except, instr)]) + + cond = arg1 - arg2 + + + e = [] + e.append(m2_expr.ExprAff(ir.IRDst, + m2_expr.ExprCond(cond, lbl_next_expr, lbl_except_expr))) + + return e, [blk_except] + + mnemo_func = sbuild.functions mnemo_func.update({ 'add.d': add_d, @@ -423,6 +460,7 @@ mnemo_func.update({ 'subu': l_sub, 'xor': l_xor, 'xori': l_xor, + 'teq': teq, }) def get_mnemo_expr(ir, instr, *args): diff --git a/miasm2/arch/msp430/arch.py b/miasm2/arch/msp430/arch.py index 9728d776..e4d03edb 100644 --- a/miasm2/arch/msp430/arch.py +++ b/miasm2/arch/msp430/arch.py @@ -8,6 +8,7 @@ from collections import defaultdict from miasm2.core.bin_stream import bin_stream import miasm2.arch.msp430.regs as regs_module from miasm2.arch.msp430.regs import * +from miasm2.core.asm_ast import AstInt, AstId, AstMem, AstOp log = logging.getLogger("msp430dis") console_handler = logging.StreamHandler() @@ -19,79 +20,70 @@ conditional_branch = ['jnz', 'jz', 'jnc', 'jc', 'jn', 'jge', 'jl'] unconditional_branch = ['jmp'] -def deref2expr_nooff(s, l, t): - t = t[0] - if len(t) == 1 and isinstance(t[0], ExprId): - return ExprMem(t[0], 16) - elif len(t) == 1 and isinstance(t[0], ExprInt): - return ExprMem(t[0], 16) - raise NotImplementedError('not fully functional') +def cb_deref_nooff(tokens): + assert len(tokens) == 1 + result = AstMem(tokens[0], 16) + return result -def deref2expr_pinc(s, l, t): - t = t[0] - if len(t) == 1 and isinstance(t[0], ExprId): - return ExprOp('autoinc', t[0]) - raise NotImplementedError('not fully functional') +def cb_deref_pinc(tokens): + assert len(tokens) == 1 + result = AstOp('autoinc', *tokens) + return result -def deref2expr_off(s, l, t): - t = t[0] - if len(t) == 2 and isinstance(t[1], ExprId): - return ExprMem(t[1] + t[0], 16) - raise NotImplementedError('not fully functional') +def cb_deref_off(tokens): + assert len(tokens) == 2 + result = AstMem(tokens[1] + tokens[0], 16) + return result -def deref_expr(s, l, t): - t = t[0] - assert(len(t) == 1) - t = t[0] - if isinstance(t, ExprId) or \ - isinstance(t, ExprInt) or \ - isinstance(t, ExprMem) or \ - (isinstance(t, ExprOp) and t.op == "autoinc"): - return t - raise NotImplementedError('not fully functional') +def cb_expr(tokens): + assert(len(tokens) == 1) + result = tokens[0] + return result -def f_reg2expr(t): - t = t[0] - i = regs16_str.index(t) - r = regs16_expr[i] - return r - -# gpregs.parser.setParseAction(f_reg2expr) - ARO = Suppress("@") LPARENT = Suppress("(") RPARENT = Suppress(")") PINC = Suppress("+") - -def ast_id2expr(t): - return mn_msp430.regs.all_regs_ids_byname.get(t, t) - - -def ast_int2expr(a): - return ExprInt(a, 16) - - -variable, operand, base_expr = gen_base_expr() - -my_var_parser = ParseAst(ast_id2expr, ast_int2expr) -base_expr.setParseAction(my_var_parser) - - -deref_nooff = Group(ARO + base_expr).setParseAction(deref2expr_nooff) -deref_pinc = Group(ARO + base_expr + PINC).setParseAction(deref2expr_pinc) -deref_off = Group(base_expr + LPARENT + - gpregs.parser + RPARENT).setParseAction(deref2expr_off) - - -sreg_p = Group(deref_pinc | deref_nooff | - deref_off | base_expr).setParseAction(deref_expr) +deref_nooff = (ARO + base_expr).setParseAction(cb_deref_nooff) +deref_pinc = (ARO + base_expr + PINC).setParseAction(cb_deref_pinc) +deref_off = (base_expr + LPARENT + gpregs.parser + RPARENT).setParseAction(cb_deref_off) +sreg_p = (deref_pinc | deref_nooff | deref_off | base_expr).setParseAction(cb_expr) + + + +class msp430_arg(m_arg): + def asm_ast_to_expr(self, value, symbol_pool): + if isinstance(value, AstId): + name = value.name + if isinstance(name, Expr): + return name + assert isinstance(name, str) + if name in gpregs.str: + index = gpregs.str.index(name) + reg = gpregs.expr[index] + return reg + label = symbol_pool.getby_name_create(value.name) + return ExprId(label, 16) + if isinstance(value, AstOp): + args = [self.asm_ast_to_expr(tmp, symbol_pool) for tmp in value.args] + if None in args: + return None + return ExprOp(value.op, *args) + if isinstance(value, AstInt): + return ExprInt(value.value, 16) + if isinstance(value, AstMem): + ptr = self.asm_ast_to_expr(value.ptr, symbol_pool) + if ptr is None: + return None + return ExprMem(ptr, value.size) + return None class additional_info: @@ -310,7 +302,7 @@ class bw_mn(bs_mod_name): mn_mod = ['.w', '.b'] -class msp430_sreg_arg(reg_noarg, m_arg): +class msp430_sreg_arg(reg_noarg, msp430_arg): prio = default_prio + 1 reg_info = gpregs parser = sreg_p @@ -512,7 +504,7 @@ class bs_cond_off_d(bs_cond_off_s): raise NotImplementedError("unknown value v[a_d] = %d" % v['a_d']) -class msp430_offs(imm_noarg, m_arg): +class msp430_offs(imm_noarg, msp430_arg): parser = base_expr def int2expr(self, v): diff --git a/miasm2/arch/ppc/arch.py b/miasm2/arch/ppc/arch.py index 672c0c6a..945824a0 100644 --- a/miasm2/arch/ppc/arch.py +++ b/miasm2/arch/ppc/arch.py @@ -8,7 +8,7 @@ from miasm2.core.bin_stream import bin_stream from miasm2.core.asmblock import asm_label import miasm2.arch.ppc.regs as regs_module from miasm2.arch.ppc.regs import * -from pdb import pm +from miasm2.core.asm_ast import AstInt, AstId, AstMem, AstOp log = logging.getLogger("ppcdis") console_handler = logging.StreamHandler() @@ -19,37 +19,43 @@ log.setLevel(logging.DEBUG) LPARENTHESIS = Suppress(Literal("(")) RPARENTHESIS = Suppress(Literal(")")) -def deref2expr_imm_reg(s, l, t): - t = t[0] - if len(t) == 1: - return ExprMem(t[0]) - elif len(t) == 2: - return ExprMem(t[1] + t[0]) +def cb_deref_imm_reg(tokens): + if len(tokens) == 1: + return AstMem(tokens[0], 32) + elif len(tokens) == 2: + return AstMem(tokens[1] + tokens[0], 32) else: - raise NotImplementedError('len(t) > 2') + raise NotImplementedError('len(tokens) > 2') -variable, operand, base_expr = gen_base_expr() -int_or_expr = base_expr - - -def ast_id2expr(t): - if not t in mn_ppc.regs.all_regs_ids_byname: - r = ExprId(asm_label(t)) - else: - r = mn_ppc.regs.all_regs_ids_byname[t] - return r - -def ast_int2expr(a): - return ExprInt(a, 32) - -deref_reg_disp = Group(Optional(int_or_expr) + LPARENTHESIS + gpregs.parser + RPARENTHESIS).setParseAction(deref2expr_imm_reg) -deref_reg = Group(LPARENTHESIS + gpregs.parser + RPARENTHESIS).setParseAction(deref2expr_imm_reg) +deref_reg_disp = (Optional(base_expr) + LPARENTHESIS + gpregs.parser + RPARENTHESIS).setParseAction(cb_deref_imm_reg) +deref_reg = (LPARENTHESIS + gpregs.parser + RPARENTHESIS).setParseAction(cb_deref_imm_reg) deref = deref_reg | deref_reg_disp -my_var_parser = ParseAst(ast_id2expr, ast_int2expr) -base_expr.setParseAction(my_var_parser) + +class ppc_arg(m_arg): + def asm_ast_to_expr(self, arg, symbol_pool): + if isinstance(arg, AstId): + if isinstance(arg.name, ExprId): + return arg.name + if arg.name in gpregs.str: + return None + label = symbol_pool.getby_name_create(arg.name) + return ExprId(label, 32) + if isinstance(arg, AstOp): + args = [self.asm_ast_to_expr(tmp, symbol_pool) for tmp in arg.args] + if None in args: + return None + return ExprOp(arg.op, *args) + if isinstance(arg, AstInt): + return ExprInt(arg.value, 32) + if isinstance(arg, AstMem): + ptr = self.asm_ast_to_expr(arg.ptr, symbol_pool) + if ptr is None: + return None + return ExprMem(ptr, arg.size) + return None class additional_info: @@ -278,7 +284,7 @@ class mn_ppc(cls_mn): return 32 -class ppc_reg(reg_noarg, m_arg): +class ppc_reg(reg_noarg, ppc_arg): pass @@ -324,7 +330,7 @@ class ppc_crfreg(ppc_reg): reg_info = crfregs parser = reg_info.parser -class ppc_imm(imm_noarg, m_arg): +class ppc_imm(imm_noarg, ppc_arg): parser = base_expr class ppc_s14imm_branch(ppc_imm): @@ -491,7 +497,7 @@ class ppc_divert_conditional_branch(bs_divert): return out -class ppc_deref32(m_arg): +class ppc_deref32(ppc_arg): parser = deref def decode(self, v): diff --git a/miasm2/arch/sh4/arch.py b/miasm2/arch/sh4/arch.py index ecfc9502..14f46265 100644 --- a/miasm2/arch/sh4/arch.py +++ b/miasm2/arch/sh4/arch.py @@ -7,6 +7,9 @@ from collections import defaultdict import miasm2.arch.sh4.regs as regs_module from miasm2.arch.sh4.regs import * + +from miasm2.core.asm_ast import AstInt, AstId, AstMem, AstOp + jra = ExprId('jra', 32) jrb = ExprId('jrb', 32) jrc = ExprId('jrc', 32) @@ -25,99 +28,112 @@ LPARENT = Suppress("(") RPARENT = Suppress(")") -def parse_deref_pcimm(t): - t = t[0] - return t[0] + t[1] - - -def parse_pcandimmimm(t): - t = t[0] - return (t[0] & t[1]) + t[2] - -def ast_id2expr(t): - return mn_sh4.regs.all_regs_ids_byname.get(t, t) +def cb_deref_pcimm(tokens): + return tokens[0] + tokens[1] -def ast_int2expr(a): - return ExprInt(a, 32) +def cb_pcandimmimm(tokens): + return (tokens[0] & tokens[1]) + tokens[2] -my_var_parser = ParseAst(ast_id2expr, ast_int2expr) -base_expr.setParseAction(my_var_parser) -int_or_expr = base_expr -ref_pc = Group(LPARENT + regi_pc.parser + COMMA + - int_or_expr + RPARENT).setParseAction(parse_deref_pcimm) -ref_pcandimm = Group( - LPARENT + regi_pc.parser + AND + int_or_expr + - COMMA + int_or_expr + RPARENT).setParseAction(parse_pcandimmimm) - - -pcdisp = Group(regi_pc.parser + AND + int_or_expr + - PLUS + int_or_expr).setParseAction(parse_pcandimmimm) +ref_pc = (LPARENT + reg_info_pc.parser + COMMA + base_expr + RPARENT).setParseAction(cb_deref_pcimm) +ref_pcandimm = (LPARENT + reg_info_pc.parser + AND + base_expr + COMMA + base_expr + RPARENT).setParseAction(cb_pcandimmimm) +pcdisp = (reg_info_pc.parser + AND + base_expr + PLUS + base_expr).setParseAction(cb_pcandimmimm) PTR = Suppress('PTR') -def parse_deref_mem(s, l, t): - t = t[0] - e = ExprMem(t[0], 32) - return e +def cb_deref_mem(tokens): + assert len(tokens) == 1 + result = AstMem(tokens[0], 32) + return result -def parse_predec(s, l, t): - t = t[0] - e = ExprMem(ExprOp('predec', t[0]), 32) - return e +def cb_predec(tokens): + assert len(tokens) == 1 + result = AstMem(AstOp('predec', tokens[0]), 32) + return result -def parse_postinc(s, l, t): - t = t[0] - e = ExprMem(ExprOp('postinc', t[0]), 32) - return e +def cb_postinc(tokens): + assert len(tokens) == 1 + result = AstMem(AstOp('postinc', tokens[0]), 32) + return result -def parse_regdisp(t): - t = t[0] - e = ExprMem(t[0] + t[1], 32) - return e +def cb_regdisp(tokens): + assert len(tokens) == 2 + result = AstMem(tokens[0] + tokens[1], 32) + return result -def parse_regreg(t): - t = t[0] - e = ExprMem(t[0] + t[1], 32) - return e +def cb_regreg(tokens): + assert len(tokens) == 2 + result = AstMem(tokens[0] + tokens[1], 32) + return result -deref_pc = Group(DEREF + ref_pc).setParseAction(parse_deref_mem) -deref_pcimm = Group(DEREF + ref_pcandimm).setParseAction(parse_deref_mem) +deref_pc = (DEREF + ref_pc).setParseAction(cb_deref_mem) +deref_pcimm = (DEREF + ref_pcandimm).setParseAction(cb_deref_mem) -dgpregs_base = Group(DEREF + gpregs.parser).setParseAction(parse_deref_mem) -dgpregs_predec = Group( - DEREF + MINUS + gpregs.parser).setParseAction(parse_predec) -dgpregs_postinc = Group( - DEREF + gpregs.parser + PLUS).setParseAction(parse_postinc) +dgpregs_base = (DEREF + gpregs.parser).setParseAction(cb_deref_mem) +dgpregs_predec = (DEREF + MINUS + gpregs.parser).setParseAction(cb_predec) +dgpregs_postinc = (DEREF + gpregs.parser + PLUS).setParseAction(cb_postinc) dgpregs = dgpregs_base | dgpregs_predec | dgpregs_postinc -d_gpreg_gpreg = Group(DEREF + - LPARENT + gpregs.parser + COMMA + gpregs.parser + RPARENT - ).setParseAction(parse_regdisp) +d_gpreg_gpreg = (DEREF + LPARENT + gpregs.parser + COMMA + gpregs.parser + RPARENT).setParseAction(cb_regdisp) dgpregs_p = dgpregs_predec | dgpregs_postinc -dgpregs_ir = Group(DEREF + LPARENT + gpregs.parser + - COMMA + int_or_expr + RPARENT).setParseAction(parse_regdisp) +dgpregs_ir = (DEREF + LPARENT + gpregs.parser + COMMA + base_expr + RPARENT).setParseAction(cb_regdisp) dgpregs_ir |= d_gpreg_gpreg -dgbr_imm = Group(DEREF + LPARENT + regi_gbr.parser + - COMMA + int_or_expr + RPARENT).setParseAction(parse_regdisp) - -dgbr_reg = Group(DEREF + LPARENT + regi_gbr.parser + - COMMA + gpregs.parser + RPARENT).setParseAction(parse_regreg) - - -class sh4_reg(reg_noarg, m_arg): +dgbr_imm = (DEREF + LPARENT + reg_info_gbr.parser + COMMA + base_expr + RPARENT).setParseAction(cb_regdisp) + +dgbr_reg = (DEREF + LPARENT + reg_info_gbr.parser + COMMA + gpregs.parser + RPARENT).setParseAction(cb_regreg) + + +class sh4_arg(m_arg): + def asm_ast_to_expr(self, arg, symbol_pool): + if isinstance(arg, AstId): + if isinstance(arg.name, ExprId): + return arg.name + if arg.name in gpregs.str: + return None + label = symbol_pool.getby_name_create(arg.name) + return ExprId(label, 32) + if isinstance(arg, AstOp): + args = [self.asm_ast_to_expr(tmp, symbol_pool) for tmp in arg.args] + if None in args: + return None + return ExprOp(arg.op, *args) + if isinstance(arg, AstInt): + return ExprInt(arg.value, 32) + if isinstance(arg, AstMem): + ptr = self.asm_ast_to_expr(arg.ptr, symbol_pool) + if ptr is None: + return None + return ExprMem(ptr, arg.size) + return None + + +_, bs_pr = gen_reg_bs('PR', reg_info_pr, (m_reg, sh4_arg,)) +_, bs_r0 = gen_reg_bs('R0', reg_info_r0, (m_reg, sh4_arg,)) +_, bs_sr = gen_reg_bs('SR', reg_info_sr, (m_reg, sh4_arg,)) +_, bs_gbr = gen_reg_bs('GBR', reg_info_gbr, (m_reg, sh4_arg,)) +_, bs_vbr = gen_reg_bs('VBR', reg_info_vbr, (m_reg, sh4_arg,)) +_, bs_ssr = gen_reg_bs('SSR', reg_info_ssr, (m_reg, sh4_arg,)) +_, bs_spc = gen_reg_bs('SPC', reg_info_spc, (m_reg, sh4_arg,)) +_, bs_sgr = gen_reg_bs('SGR', reg_info_sgr, (m_reg, sh4_arg,)) +_, bs_dbr = gen_reg_bs('dbr', reg_info_dbr, (m_reg, sh4_arg,)) +_, bs_mach = gen_reg_bs('mach', reg_info_mach, (m_reg, sh4_arg,)) +_, bs_macl = gen_reg_bs('macl', reg_info_macl, (m_reg, sh4_arg,)) +_, bs_fpul = gen_reg_bs('fpul', reg_info_fpul, (m_reg, sh4_arg,)) +_, bs_fr0 = gen_reg_bs('fr0', reg_info_fr0, (m_reg, sh4_arg,)) + +class sh4_reg(reg_noarg, sh4_arg): pass @@ -146,12 +162,12 @@ class sh4_freg(sh4_reg): parser = reg_info.parser -class sh4_dgpreg(m_arg): +class sh4_dgpreg(sh4_arg): parser = dgpregs_base - def fromstring(self, s, parser_result=None): - start, stop = super(sh4_dgpreg, self).fromstring(s, parser_result) - if start is None: + def fromstring(self, text, symbol_pool, parser_result=None): + start, stop = super(sh4_dgpreg, self).fromstring(text, symbol_pool, parser_result) + if start is None or self.expr == [None]: return start, stop self.expr = ExprMem(self.expr.arg, self.sz) return start, stop @@ -172,12 +188,12 @@ class sh4_dgpreg(m_arg): return True -class sh4_dgpregpinc(m_arg): +class sh4_dgpregpinc(sh4_arg): parser = dgpregs_p - def fromstring(self, s, parser_result=None): - start, stop = super(sh4_dgpregpinc, self).fromstring(s, parser_result) - if self.expr is None: + def fromstring(self, text, symbol_pool, parser_result=None): + start, stop = super(sh4_dgpregpinc, self).fromstring(text, symbol_pool, parser_result) + if self.expr == [None]: return None, None if not isinstance(self.expr.arg, ExprOp): return None, None @@ -207,7 +223,7 @@ class sh4_dgpregpinc(m_arg): return True -class sh4_dgpregpdec(m_arg): +class sh4_dgpregpdec(sh4_arg): parser = dgpregs_postinc op = "preinc" @@ -252,7 +268,7 @@ class sh4_dgpreg_imm(sh4_dgpreg): return True -class sh4_imm(imm_noarg, m_arg): +class sh4_imm(imm_noarg, sh4_arg): parser = base_expr pass @@ -354,7 +370,7 @@ class sh4_dpc32imm(sh4_dpc16imm): return True -class sh4_pc32imm(m_arg): +class sh4_pc32imm(sh4_arg): parser = pcdisp def decode(self, v): @@ -666,11 +682,11 @@ addop("mov_w", [bs('0110', fname="opc"), rn, d16rmpinc, bs('0101')], [d16rmpinc, rn]) addop("mov_l", [bs('0110', fname="opc"), rn, d32rmpinc, bs('0110')], [d32rmpinc, rn]) -addop("mov_b", [bs('10000000', fname='opc'), bsr0, d08rnimm, dimm4]) -addop("mov_w", [bs('10000001', fname='opc'), bsr0, d16rnimm, dimm4]) +addop("mov_b", [bs('10000000', fname='opc'), bs_r0, d08rnimm, dimm4]) +addop("mov_w", [bs('10000001', fname='opc'), bs_r0, d16rnimm, dimm4]) addop("mov_l", [bs('0001', fname='opc'), d32rnimm, rm, dimm4], [rm, d32rnimm]) -addop("mov_b", [bs('10000100', fname='opc'), d08rmimm, dimm4, bsr0]) -addop("mov_w", [bs('10000101', fname='opc'), d16rmimm, dimm4, bsr0]) +addop("mov_b", [bs('10000100', fname='opc'), d08rmimm, dimm4, bs_r0]) +addop("mov_w", [bs('10000101', fname='opc'), d16rmimm, dimm4, bs_r0]) addop("mov_l", [bs('0101', fname='opc'), rn, d32rmimm, dimm4], [d32rmimm, rn]) addop("mov_b", [bs('0000', fname='opc'), bd08r0gp, rm, bs('0100')], [rm, bd08r0gp]) @@ -685,15 +701,15 @@ addop("mov_w", addop("mov_l", [bs('0000', fname='opc'), rn, bd32r0gp, bs('1110')], [bd32r0gp, rn]) -addop("mov_b", [bs('11000000'), bsr0, d08gbrimm8]) -addop("mov_w", [bs('11000001'), bsr0, d16gbrimm8]) -addop("mov_l", [bs('11000010'), bsr0, d32gbrimm8]) +addop("mov_b", [bs('11000000'), bs_r0, d08gbrimm8]) +addop("mov_w", [bs('11000001'), bs_r0, d16gbrimm8]) +addop("mov_l", [bs('11000010'), bs_r0, d32gbrimm8]) -addop("mov_b", [bs('11000100'), d08gbrimm8, bsr0]) -addop("mov_w", [bs('11000101'), d16gbrimm8, bsr0]) -addop("mov_l", [bs('11000110'), d32gbrimm8, bsr0]) +addop("mov_b", [bs('11000100'), d08gbrimm8, bs_r0]) +addop("mov_w", [bs('11000101'), d16gbrimm8, bs_r0]) +addop("mov_l", [bs('11000110'), d32gbrimm8, bs_r0]) -addop("mov", [bs('11000111'), pc32imm, bsr0]) +addop("mov", [bs('11000111'), pc32imm, bs_r0]) addop("swapb", [bs('0110'), rn, rm, bs('1000')], [rm, rn]) addop("swapw", [bs('0110'), rn, rm, bs('1001')], [rm, rn]) @@ -706,7 +722,7 @@ addop("addc", [bs('0011'), rn, rm, bs('1110')], [rm, rn]) addop("addv", [bs('0011'), rn, rm, bs('1111')], [rm, rn]) -addop("cmpeq", [bs('10001000'), s08imm, bsr0]) +addop("cmpeq", [bs('10001000'), s08imm, bs_r0]) addop("cmpeq", [bs('0011'), rn, rm, bs('0000')], [rm, rn]) @@ -754,24 +770,24 @@ addop("subc", [bs('0011'), rn, rm, bs('1010')], [rm, rn]) addop("subv", [bs('0011'), rn, rm, bs('1011')], [rm, rn]) addop("and", [bs('0010'), rn, rm, bs('1001')], [rm, rn]) -addop("and", [bs('11001001'), u08imm, bsr0]) +addop("and", [bs('11001001'), u08imm, bs_r0]) addop("and_b", [bs('11001101'), u08imm, dr0gbr]) addop("not", [bs('0110'), rn, rm, bs('0111')], [rm, rn]) addop("or", [bs('0010'), rn, rm, bs('1011')], [rm, rn]) -addop("or", [bs('11001011'), u08imm, bsr0]) +addop("or", [bs('11001011'), u08imm, bs_r0]) addop("or_b", [bs('11001111'), u08imm, dr0gbr]) addop("tas_b", [bs('0100'), d08gpreg, bs('00011011')]) addop("tst", [bs('0010'), rn, rm, bs('1000')], [rm, rn]) -addop("tst", [bs('11001000'), u08imm, bsr0]) +addop("tst", [bs('11001000'), u08imm, bs_r0]) addop("tst_b", [bs('11001100'), u08imm, dr0gbr]) addop("xor", [bs('0010'), rn, rm, bs('1010')], [rm, rn]) -addop("xor", [bs('11001010'), u08imm, bsr0]) +addop("xor", [bs('11001010'), u08imm, bs_r0]) addop("xor_b", [bs('11001110'), u08imm, dr0gbr]) addop("rotl", [bs('0100'), rn, bs('00000100')]) @@ -883,29 +899,29 @@ addop("clrs", [bs('0000000001001000')]) addop("clrt", [bs('0000000000001000')]) -addop("ldc", [bs('0100'), rm, bssr, bs('00001110')]) -addop("ldc", [bs('0100'), rm, bsgbr, bs('00011110')]) -addop("ldc", [bs('0100'), rm, bsvbr, bs('00101110')]) -addop("ldc", [bs('0100'), rm, bsssr, bs('00111110')]) -addop("ldc", [bs('0100'), rm, bsspc, bs('01001110')]) -addop("ldc", [bs('0100'), rm, bsdbr, bs('11111010')]) +addop("ldc", [bs('0100'), rm, bs_sr, bs('00001110')]) +addop("ldc", [bs('0100'), rm, bs_gbr, bs('00011110')]) +addop("ldc", [bs('0100'), rm, bs_vbr, bs('00101110')]) +addop("ldc", [bs('0100'), rm, bs_ssr, bs('00111110')]) +addop("ldc", [bs('0100'), rm, bs_spc, bs('01001110')]) +addop("ldc", [bs('0100'), rm, bs_dbr, bs('11111010')]) addop("ldc", [bs('0100'), rm, bs('1'), brn, bs('1110')], [rm, brn]) -addop("ldc_l", [bs('0100'), d32rmpinc, bssr, bs('00000111')]) -addop("ldc_l", [bs('0100'), d32rmpinc, bsgbr, bs('00010111')]) -addop("ldc_l", [bs('0100'), d32rmpinc, bsvbr, bs('00100111')]) -addop("ldc_l", [bs('0100'), d32rmpinc, bsssr, bs('00110111')]) -addop("ldc_l", [bs('0100'), d32rmpinc, bsspc, bs('01000111')]) -addop("ldc_l", [bs('0100'), d32rmpinc, bsdbr, bs('11110110')]) +addop("ldc_l", [bs('0100'), d32rmpinc, bs_sr, bs('00000111')]) +addop("ldc_l", [bs('0100'), d32rmpinc, bs_gbr, bs('00010111')]) +addop("ldc_l", [bs('0100'), d32rmpinc, bs_vbr, bs('00100111')]) +addop("ldc_l", [bs('0100'), d32rmpinc, bs_ssr, bs('00110111')]) +addop("ldc_l", [bs('0100'), d32rmpinc, bs_spc, bs('01000111')]) +addop("ldc_l", [bs('0100'), d32rmpinc, bs_dbr, bs('11110110')]) addop("ldc_l", [bs('0100'), d32rmpinc, bs('1'), brn, bs('0111')]) -addop("lds", [bs('0100'), rm, bsmach, bs('00001010')]) -addop("lds", [bs('0100'), rm, bsmacl, bs('00011010')]) -addop("lds", [bs('0100'), rm, bspr, bs('00101010')]) -addop("lds_l", [bs('0100'), d32rmpinc, bsmach, bs('00000110')]) -addop("lds_l", [bs('0100'), d32rmpinc, bsmacl, bs('00010110')]) -addop("lds_l", [bs('0100'), d32rmpinc, bspr, bs('00100110')]) +addop("lds", [bs('0100'), rm, bs_mach, bs('00001010')]) +addop("lds", [bs('0100'), rm, bs_macl, bs('00011010')]) +addop("lds", [bs('0100'), rm, bs_pr, bs('00101010')]) +addop("lds_l", [bs('0100'), d32rmpinc, bs_mach, bs('00000110')]) +addop("lds_l", [bs('0100'), d32rmpinc, bs_macl, bs('00010110')]) +addop("lds_l", [bs('0100'), d32rmpinc, bs_pr, bs('00100110')]) addop("ldtlb", [bs('0000000000111000')]) -addop("movca_l", [bs('0000'), bsr0, d32gpreg, bs('11000011')]) +addop("movca_l", [bs('0000'), bs_r0, d32gpreg, bs('11000011')]) addop("nop", [bs('0000000000001001')]) addop("ocbi_l", [bs('0000'), d32gpreg, bs('10010011')]) addop("ocbp_l", [bs('0000'), d32gpreg, bs('10100011')]) @@ -917,33 +933,33 @@ addop("rte", [bs('0000000000101011')]) addop("sets", [bs('0000000001011000')]) addop("sett", [bs('0000000000011000')]) addop("sleep", [bs('0000000000011011')]) -addop("stc", [bs('0000'), bssr, rn, bs('00000010')]) -addop("stc", [bs('0000'), bsgbr, rn, bs('00010010')]) -addop("stc", [bs('0000'), bsvbr, rn, bs('00100010')]) -addop("stc", [bs('0000'), bsssr, rn, bs('00110010')]) -addop("stc", [bs('0000'), bsspc, rn, bs('01000010')]) -addop("stc", [bs('0000'), bssgr, rn, bs('00111010')]) -addop("stc", [bs('0000'), bsdbr, rn, bs('11111010')]) +addop("stc", [bs('0000'), bs_sr, rn, bs('00000010')]) +addop("stc", [bs('0000'), bs_gbr, rn, bs('00010010')]) +addop("stc", [bs('0000'), bs_vbr, rn, bs('00100010')]) +addop("stc", [bs('0000'), bs_ssr, rn, bs('00110010')]) +addop("stc", [bs('0000'), bs_spc, rn, bs('01000010')]) +addop("stc", [bs('0000'), bs_sgr, rn, bs('00111010')]) +addop("stc", [bs('0000'), bs_dbr, rn, bs('11111010')]) addop("stc", [bs('0000'), rn, bs('1'), brm, bs('0010')], [brm, rn]) -addop("stc_l", [bs('0100'), bssr, d32rmpdec, bs('00000011')]) -addop("stc_l", [bs('0100'), bsgbr, d32rmpdec, bs('00010011')]) -addop("stc_l", [bs('0100'), bsvbr, d32rmpdec, bs('00100011')]) -addop("stc_l", [bs('0100'), bsssr, d32rmpdec, bs('00110011')]) -addop("stc_l", [bs('0100'), bsspc, d32rmpdec, bs('01000011')]) -addop("stc_l", [bs('0100'), bssgr, d32rmpdec, bs('00110010')]) -addop("stc_l", [bs('0100'), bsdbr, d32rmpdec, bs('11110010')]) +addop("stc_l", [bs('0100'), bs_sr, d32rmpdec, bs('00000011')]) +addop("stc_l", [bs('0100'), bs_gbr, d32rmpdec, bs('00010011')]) +addop("stc_l", [bs('0100'), bs_vbr, d32rmpdec, bs('00100011')]) +addop("stc_l", [bs('0100'), bs_ssr, d32rmpdec, bs('00110011')]) +addop("stc_l", [bs('0100'), bs_spc, d32rmpdec, bs('01000011')]) +addop("stc_l", [bs('0100'), bs_sgr, d32rmpdec, bs('00110010')]) +addop("stc_l", [bs('0100'), bs_dbr, d32rmpdec, bs('11110010')]) addop("stc_l", [bs('0100'), d32rnpdec, bs('1'), brm, bs('0011')], [brm, d32rnpdec]) # float -addop("sts", [bs('0000'), bsmach, rm, bs('00001010')]) -addop("sts", [bs('0000'), bsmacl, rm, bs('00011010')]) -addop("sts", [bs('0000'), bspr, rm, bs('00101010')]) -addop("sts_l", [bs('0100'), bsmach, d32rmpdec, bs('00000010')]) -addop("sts_l", [bs('0100'), bsmacl, d32rmpdec, bs('00010010')]) +addop("sts", [bs('0000'), bs_mach, rm, bs('00001010')]) +addop("sts", [bs('0000'), bs_macl, rm, bs('00011010')]) +addop("sts", [bs('0000'), bs_pr, rm, bs('00101010')]) +addop("sts_l", [bs('0100'), bs_mach, d32rmpdec, bs('00000010')]) +addop("sts_l", [bs('0100'), bs_macl, d32rmpdec, bs('00010010')]) addop("sts_l", - [bs('0100'), d32rnpdec, bspr, bs('00100010')], [bspr, d32rnpdec]) + [bs('0100'), d32rnpdec, bs_pr, bs('00100010')], [bs_pr, d32rnpdec]) addop("trapa", [bs('11000011'), u08imm]) addop("fldi0", [bs('1111'), frn, bs('10001101')]) @@ -956,18 +972,18 @@ addop("fmov_s", [bs('1111'), d32gpreg, frm, bs('1010')], [frm, d32gpreg]) addop("fmov_s", [bs('1111'), d32rnpdec, frm, bs('1011')], [frm, d32rnpdec]) addop("fmov_s", [bs('1111'), bd32r0gp, frm, bs('0111')], [frm, bd32r0gp]) -addop("flds", [bs('1111'), frm, bsfpul, bs('00011101')]) -addop("fsts", [bs('1111'), bsfpul, frm, bs('00001101')]) +addop("flds", [bs('1111'), frm, bs_fpul, bs('00011101')]) +addop("fsts", [bs('1111'), bs_fpul, frm, bs('00001101')]) addop("fabs", [bs('1111'), frn, bs('01011101')]) addop("fadd", [bs('1111'), frn, frm, bs('0000')], [frm, frn]) addop("fcmpeq", [bs('1111'), frn, frm, bs('0100')], [frm, frn]) addop("fcmpgt", [bs('1111'), frn, frm, bs('0101')], [frm, frn]) addop("fdiv", [bs('1111'), frn, frm, bs('0011')], [frm, frn]) -addop("float", [bs('1111'), bsfpul, frn, bs('00101101')]) -addop("fmac", [bs('1111'), bsfr0, frn, frm, bs('1110')], [bsfr0, frm, frn]) +addop("float", [bs('1111'), bs_fpul, frn, bs('00101101')]) +addop("fmac", [bs('1111'), bs_fr0, frn, frm, bs('1110')], [bs_fr0, frm, frn]) addop("fmul", [bs('1111'), frn, frm, bs('0010')], [frm, frn]) addop("fneg", [bs('1111'), frn, bs('01001101')]) addop("fsqrt", [bs('1111'), frn, bs('01101101')]) addop("fsub", [bs('1111'), frn, frm, bs('0001')], [frm, frn]) -addop("ftrc", [bs('1111'), frm, bsfpul, bs('00111101')]) +addop("ftrc", [bs('1111'), frm, bs_fpul, bs('00111101')]) diff --git a/miasm2/arch/sh4/regs.py b/miasm2/arch/sh4/regs.py index 89ff42f8..148e74ba 100644 --- a/miasm2/arch/sh4/regs.py +++ b/miasm2/arch/sh4/regs.py @@ -19,20 +19,20 @@ dregs_expr = [ExprId(x, 32) for x in dregs_str] dregs = reg_info(dregs_str, dregs_expr) -gen_reg('PC', globals()) -gen_reg('PR', globals()) -gen_reg('R0', globals()) -gen_reg('GBR', globals()) -gen_reg('SR', globals()) -gen_reg('VBR', globals()) -gen_reg('SSR', globals()) -gen_reg('SPC', globals()) -gen_reg('SGR', globals()) -gen_reg('DBR', globals()) -gen_reg('MACH', globals()) -gen_reg('MACL', globals()) -gen_reg('FPUL', globals()) -gen_reg('FR0', globals()) +PC, reg_info_pc = gen_reg('PC') +PR, reg_info_pr = gen_reg('PR') +R0, reg_info_r0 = gen_reg('R0') +GBR, reg_info_gbr = gen_reg('GBR') +SR, reg_info_sr = gen_reg('SR') +VBR, reg_info_vbr = gen_reg('VBR') +SSR, reg_info_ssr = gen_reg('SSR') +SPC, reg_info_spc = gen_reg('SPC') +SGR, reg_info_sgr = gen_reg('SGR') +DBR, reg_info_dbr = gen_reg('DBR') +MACH, reg_info_mach = gen_reg('MACH') +MACL, reg_info_macl = gen_reg('MACL') +FPUL, reg_info_fpul = gen_reg('FPUL') +FR0, reg_info_fr0 = gen_reg('FR0') R0 = gpregs_expr[0] R1 = gpregs_expr[1] diff --git a/miasm2/arch/x86/arch.py b/miasm2/arch/x86/arch.py index 29303fdf..fc3a5882 100644 --- a/miasm2/arch/x86/arch.py +++ b/miasm2/arch/x86/arch.py @@ -8,6 +8,8 @@ from collections import defaultdict import miasm2.arch.x86.regs as regs_module from miasm2.arch.x86.regs import * from miasm2.core.asmblock import AsmLabel +from miasm2.core.asm_ast import AstNode, AstInt, AstId, AstMem, AstOp + log = logging.getLogger("x86_arch") console_handler = logging.StreamHandler() @@ -121,148 +123,82 @@ replace_regs = {16: replace_regs16, 64: replace_regs64} -# parser helper ########### -PLUS = Suppress("+") -MULT = Suppress("*") - -COLON = Suppress(":") - - -LBRACK = Suppress("[") -RBRACK = Suppress("]") - -dbreg = Group(gpregs16.parser | gpregs32.parser | gpregs64.parser) -gpreg = (gpregs08.parser | gpregs08_64.parser | gpregs16.parser | - gpregs32.parser | gpregs64.parser | gpregs_xmm.parser | - gpregs_mm.parser | gpregs_bnd.parser) - - -def reg2exprid(r): - if not r.name in all_regs_ids_byname: - raise ValueError('unknown reg') - return all_regs_ids_byname[r.name] - - -def parse_deref_reg(s, l, t): - t = t[0][0] - return t[0] - - -def parse_deref_int(s, l, t): - t = t[0] - return t[0] - - -def parse_deref_regint(s, l, t): - t = t[0] - r1 = reg2exprid(t[0][0]) - i1 = ExprInt(t[1].arg, r1.size) - return r1 + i1 - - -def parse_deref_regreg(s, l, t): - t = t[0] - return t[0][0] + t[1][0] - - -def parse_deref_regregint(s, l, t): - t = t[0] - r1 = reg2exprid(t[0][0]) - r2 = reg2exprid(t[1][0]) - i1 = ExprInt(t[2].arg, r1.size) - return r1 + r2 + i1 +segm2enc = {CS: 1, SS: 2, DS: 3, ES: 4, FS: 5, GS: 6} +enc2segm = dict([(x[1], x[0]) for x in segm2enc.items()]) +segm_info = reg_info_dct(enc2segm) -def parse_deref_reg_intmreg(s, l, t): - t = t[0] - r1 = reg2exprid(t[0][0]) - r2 = reg2exprid(t[1][0]) - i1 = ExprInt(t[2].arg, r1.size) - return r1 + (r2 * i1) -def parse_deref_reg_intmreg_int(s, l, t): - t = t[0] - r1 = reg2exprid(t[0][0]) - r2 = reg2exprid(t[1][0]) - i1 = ExprInt(t[2].arg, r1.size) - i2 = ExprInt(t[3].arg, r1.size) - return r1 + (r2 * i1) + i2 +enc2crx = { + 0: cr0, + 1: cr1, + 2: cr2, + 3: cr3, + 4: cr4, + 5: cr5, + 6: cr6, + 7: cr7, +} +crx_info = reg_info_dct(enc2crx) -def parse_deref_intmreg(s, l, t): - t = t[0] - r1 = reg2exprid(t[0][0]) - i1 = ExprInt(t[1].arg, r1.size) - return r1 * i1 +enc2drx = { + 0: dr0, + 1: dr1, + 2: dr2, + 3: dr3, + 4: dr4, + 5: dr5, + 6: dr6, + 7: dr7, +} -def parse_deref_intmregint(s, l, t): - t = t[0] - r1 = reg2exprid(t[0][0]) - i1 = ExprInt(t[1].arg, r1.size) - i2 = ExprInt(t[1].arg, r1.size) - return (r1 * i1) + i2 +drx_info = reg_info_dct(enc2drx) -def getreg(s, l, t): - t = t[0] - return t[0] +# parser helper ########### +PLUS = Suppress("+") +MULT = Suppress("*") -def parse_deref_ptr(s, l, t): - t = t[0] - return ExprMem(ExprOp('segm', t[0], t[1])) +COLON = Suppress(":") -def parse_deref_segmoff(s, l, t): - t = t[0] - return ExprOp('segm', t[0], t[1]) +LBRACK = Suppress("[") +RBRACK = Suppress("]") -variable, operand, base_expr = gen_base_expr() +gpreg = ( + gpregs08.parser | + gpregs08_64.parser | + gpregs16.parser | + gpregs32.parser | + gpregs64.parser | + gpregs_xmm.parser | + gpregs_mm.parser | + gpregs_bnd.parser +) -def ast_id2expr(t): - return mn_x86.regs.all_regs_ids_byname.get(t, t) -def ast_int2expr(a): - return ExprInt(a, 64) +def cb_deref_segmoff(tokens): + assert len(tokens) == 2 + return AstOp('segm', tokens[0], tokens[1]) -my_var_parser = ParseAst(ast_id2expr, ast_int2expr) -base_expr.setParseAction(my_var_parser) -int_or_expr = base_expr +def cb_deref_base_expr(tokens): + tokens = tokens[0] + assert isinstance(tokens, AstNode) + addr = tokens + return addr -deref_mem_ad = Group(LBRACK + dbreg + RBRACK).setParseAction(parse_deref_reg) -deref_mem_ad |= Group( - LBRACK + int_or_expr + RBRACK).setParseAction(parse_deref_int) -deref_mem_ad |= Group( - LBRACK + dbreg + PLUS + - int_or_expr + RBRACK).setParseAction(parse_deref_regint) -deref_mem_ad |= Group( - LBRACK + dbreg + PLUS + - dbreg + RBRACK).setParseAction(parse_deref_regreg) -deref_mem_ad |= Group( - LBRACK + dbreg + PLUS + dbreg + PLUS + - int_or_expr + RBRACK).setParseAction(parse_deref_regregint) -deref_mem_ad |= Group( - LBRACK + dbreg + PLUS + dbreg + MULT + - int_or_expr + RBRACK).setParseAction(parse_deref_reg_intmreg) -deref_mem_ad |= Group( - LBRACK + dbreg + PLUS + dbreg + MULT + int_or_expr + - PLUS + int_or_expr + RBRACK).setParseAction(parse_deref_reg_intmreg_int) -deref_mem_ad |= Group( - LBRACK + dbreg + MULT + - int_or_expr + RBRACK).setParseAction(parse_deref_intmreg) -deref_mem_ad |= Group( - LBRACK + dbreg + MULT + int_or_expr + - PLUS + int_or_expr + RBRACK).setParseAction(parse_deref_intmregint) +deref_mem_ad = (LBRACK + base_expr + RBRACK).setParseAction(cb_deref_base_expr) -deref_ptr = Group(int_or_expr + COLON + - int_or_expr).setParseAction(parse_deref_segmoff) +deref_ptr = (base_expr + COLON + base_expr).setParseAction(cb_deref_segmoff) PTR = Suppress('PTR') @@ -282,68 +218,120 @@ MEMPREFIX2SIZE = {'BYTE': 8, 'WORD': 16, 'DWORD': 32, SIZE2MEMPREFIX = dict((x[1], x[0]) for x in MEMPREFIX2SIZE.items()) -def parse_deref_mem(s, l, t): - t = t[0] - if len(t) == 2: - s, ptr = t - return ExprMem(ptr, MEMPREFIX2SIZE[s[0]]) - elif len(t) == 3: - s, segm, ptr = t - return ExprMem(ExprOp('segm', segm[0], ptr), MEMPREFIX2SIZE[s[0]]) - else: - raise ValueError('len(t) > 3') +def cb_deref_mem(tokens): + if len(tokens) == 2: + s, ptr = tokens + assert isinstance(ptr, AstNode) + return AstMem(ptr, MEMPREFIX2SIZE[s]) + elif len(tokens) == 3: + s, segm, ptr = tokens + return AstMem(AstOp('segm', segm, ptr), MEMPREFIX2SIZE[s]) + raise ValueError('len(tokens) > 3') + +mem_size = (BYTE | DWORD | QWORD | WORD | TBYTE | XMMWORD) +deref_mem = (mem_size + PTR + Optional((base_expr + COLON))+ deref_mem_ad).setParseAction(cb_deref_mem) + + +rmarg = ( + gpregs08.parser | + gpregs08_64.parser | + gpregs16.parser | + gpregs32.parser | + gpregs64.parser | + gpregs_mm.parser | + gpregs_xmm.parser | + gpregs_bnd.parser +) -mem_size = Group(BYTE | DWORD | QWORD | WORD | TBYTE | XMMWORD) -deref_mem = Group(mem_size + PTR + Optional(Group(int_or_expr + COLON)) - + deref_mem_ad).setParseAction(parse_deref_mem) +rmarg |= deref_mem -rmarg = Group(gpregs08.parser | - gpregs08_64.parser | - gpregs16.parser | - gpregs32.parser | - gpregs64.parser | - gpregs_mm.parser | - gpregs_xmm.parser | - gpregs_bnd.parser - ).setParseAction(getreg) +mem_far = FAR + deref_mem -rmarg |= deref_mem +cl_or_imm = r08_ecx.parser +cl_or_imm |= base_expr -mem_far = FAR + deref_mem -cl_or_imm = Group(r08_ecx.parser).setParseAction(getreg) -cl_or_imm |= int_or_expr +class x86_arg(m_arg): + def asm_ast_to_expr(self, value, symbol_pool, size_hint=None, fixed_size=None): + if size_hint is None: + size_hint = self.parent.v_opmode() + if fixed_size is None: + fixed_size = set() + if isinstance(value, AstId): + if value.name in all_regs_ids_byname: + reg = all_regs_ids_byname[value.name] + fixed_size.add(reg.size) + return reg + if isinstance(value.name, ExprId): + fixed_size.add(value.name.size) + return value.name + if value.name in MEMPREFIX2SIZE: + return None + if value.name in ["FAR"]: + return None + label = symbol_pool.getby_name_create(value.name) + return ExprId(label, size_hint) + if isinstance(value, AstOp): + # First pass to retreive fixed_size + if value.op == "segm": + segm = self.asm_ast_to_expr(value.args[0], symbol_pool) + ptr = self.asm_ast_to_expr(value.args[1], symbol_pool, None, fixed_size) + return ExprOp('segm', segm, ptr) + args = [self.asm_ast_to_expr(arg, symbol_pool, None, fixed_size) for arg in value.args] + if len(fixed_size) == 0: + # No fixed size + pass + elif len(fixed_size) == 1: + # One fixed size, regen all + size = list(fixed_size)[0] + args = [self.asm_ast_to_expr(arg, symbol_pool, size, fixed_size) for arg in value.args] + else: + raise ValueError("Size conflict") + if None in args: + return None + return ExprOp(value.op, *args) + if isinstance(value, AstInt): + if 1 << size_hint < value.value: + size_hint *= 2 + return ExprInt(value.value, size_hint) + if isinstance(value, AstMem): + fixed_size.add(value.size) + ptr = self.asm_ast_to_expr(value.ptr, symbol_pool, None, set()) + if ptr is None: + return None + return ExprMem(ptr, value.size) + return None -class r_al(reg_noarg, m_arg): +class r_al(reg_noarg, x86_arg): reg_info = r08_eax parser = reg_info.parser -class r_ax(reg_noarg, m_arg): +class r_ax(reg_noarg, x86_arg): reg_info = r16_eax parser = reg_info.parser -class r_dx(reg_noarg, m_arg): +class r_dx(reg_noarg, x86_arg): reg_info = r16_edx parser = reg_info.parser -class r_eax(reg_noarg, m_arg): +class r_eax(reg_noarg, x86_arg): reg_info = r32_eax parser = reg_info.parser -class r_rax(reg_noarg, m_arg): +class r_rax(reg_noarg, x86_arg): reg_info = r64_eax parser = reg_info.parser -class r_cl(reg_noarg, m_arg): +class r_cl(reg_noarg, x86_arg): reg_info = r08_ecx parser = reg_info.parser @@ -442,9 +430,6 @@ repeat_mn = ["INS", "OUTS", "CMPSB", "CMPSW", "CMPSD", "CMPSQ", ] -segm2enc = {CS: 1, SS: 2, DS: 3, ES: 4, FS: 5, GS: 6} -enc2segm = dict([(x[1], x[0]) for x in segm2enc.items()]) - class group: @@ -685,19 +670,19 @@ class mn_x86(cls_mn): return [(subcls, name, bases, dct, fields)] @classmethod - def fromstring(cls, s, mode): + def fromstring(cls, text, symbol_pool, mode): pref = 0 - prefix, new_s = get_prefix(s) + prefix, new_s = get_prefix(text) if prefix == "LOCK": pref |= 1 - s = new_s + text = new_s elif prefix == "REPNE": pref |= 2 - s = new_s + text = new_s elif prefix == "REPE": pref |= 4 - s = new_s - c = super(mn_x86, cls).fromstring(s, mode) + text = new_s + c = super(mn_x86, cls).fromstring(text, symbol_pool, mode) c.additional_info.g1.value = pref return c @@ -1065,10 +1050,12 @@ class x86_imm_fix_08(imm_noarg): def decodeval(self, v): return self.ival - def encodeval(self, v): + def encode(self): + v = self.expr2int(self.expr) if v != self.ival: return False - return self.ival + self.value = 0 + return True class x86_08(x86_imm): @@ -1222,7 +1209,7 @@ class x86_s32to64(x86_s08to32): return ExprInt(x, 64) -class bs_eax(m_arg): +class bs_eax(x86_arg): reg_info = r_eax_all rindex = 0 parser = reg_info.parser @@ -1262,7 +1249,7 @@ class bs_eax(m_arg): return False return False -class bs_seg(m_arg): +class bs_seg(x86_arg): reg_info = r_eax_all rindex = 0 parser = reg_info.parser @@ -1324,7 +1311,7 @@ class bs_gs(bs_seg): parser = reg_info.parser -class x86_reg_st(reg_noarg, m_arg): +class x86_reg_st(reg_noarg, x86_arg): reg_info = r_st_all parser = reg_info.parser @@ -1932,15 +1919,14 @@ def modrm2expr(modrm, parent, w8, sx=0, xmm=0, mm=0, bnd=0): return expr -class x86_rm_arg(m_arg): +class x86_rm_arg(x86_arg): parser = rmarg - def fromstring(self, s, parser_result=None): - start, stop = super(x86_rm_arg, self).fromstring(s, parser_result) + def fromstring(self, text, symbol_pool, parser_result=None): + start, stop = super(x86_rm_arg, self).fromstring(text, symbol_pool, parser_result) p = self.parent if start is None: return None, None - s = self.expr.size return start, stop def get_modrm(self): @@ -2072,9 +2058,9 @@ class x86_rm_arg(m_arg): yield x class x86_rm_mem(x86_rm_arg): - def fromstring(self, s, parser_result=None): + def fromstring(self, text, symbol_pool, parser_result=None): self.expr = None - start, stop = super(x86_rm_mem, self).fromstring(s, parser_result) + start, stop = super(x86_rm_mem, self).fromstring(text, symbol_pool, parser_result) if not isinstance(self.expr, ExprMem): return None, None return start, stop @@ -2082,9 +2068,9 @@ class x86_rm_mem(x86_rm_arg): class x86_rm_mem_far(x86_rm_arg): parser = mem_far - def fromstring(self, s, parser_result=None): + def fromstring(self, text, symbol_pool, parser_result=None): self.expr = None - start, stop = super(x86_rm_mem_far, self).fromstring(s, parser_result) + start, stop = super(x86_rm_mem_far, self).fromstring(text, symbol_pool, parser_result) if not isinstance(self.expr, ExprMem): return None, None self.expr = ExprOp('far', self.expr) @@ -2454,24 +2440,28 @@ class x86_rm_reg_noarg(object): parser = gpreg - def fromstring(self, s, parser_result=None): + def fromstring(self, text, symbol_pool, parser_result=None): if not hasattr(self.parent, 'sx') and hasattr(self.parent, "w8"): self.parent.w8.value = 1 if parser_result: - e, start, stop = parser_result[self.parser] - if e is None: + result, start, stop = parser_result[self.parser] + if result == [None]: return None, None - self.expr = e + self.expr = result if self.expr.size == 8: if hasattr(self.parent, 'sx') or not hasattr(self.parent, 'w8'): return None, None self.parent.w8.value = 0 return start, stop try: - v, start, stop = self.parser.scanString(s).next() + result, start, stop = self.parser.scanString(text).next() except StopIteration: return None, None - self.expr = v[0] + expr = self.asm_ast_to_expr(result[0], symbol_pool) + if expr is None: + return None, None + + self.expr = expr if self.expr.size == 0: if hasattr(self.parent, 'sx') or not hasattr(self.parent, 'w8'): return None, None @@ -2540,7 +2530,7 @@ class x86_rm_reg_noarg(object): return True -class x86_rm_reg_mm(x86_rm_reg_noarg, m_arg): +class x86_rm_reg_mm(x86_rm_reg_noarg, x86_arg): selreg = gpregs_mm def decode(self, v): if self.parent.mode == 64 and self.getrexsize(): @@ -2570,7 +2560,7 @@ class x86_rm_reg_xmm(x86_rm_reg_mm): class x86_rm_reg_bnd(x86_rm_reg_mm): selreg = gpregs_bnd -class x86_rm_reg(x86_rm_reg_noarg, m_arg): +class x86_rm_reg(x86_rm_reg_noarg, x86_arg): pass @@ -2602,25 +2592,25 @@ class x86_reg_noarg(x86_rm_reg_noarg): self.parent.rex_b.value = v -class x86_rm_segm(reg_noarg, m_arg): +class x86_rm_segm(reg_noarg, x86_arg): prio = default_prio + 1 reg_info = segmreg parser = reg_info.parser -class x86_rm_cr(reg_noarg, m_arg): +class x86_rm_cr(reg_noarg, x86_arg): prio = default_prio + 1 reg_info = crregs parser = reg_info.parser -class x86_rm_dr(reg_noarg, m_arg): +class x86_rm_dr(reg_noarg, x86_arg): prio = default_prio + 1 reg_info = drregs parser = reg_info.parser -class x86_rm_flt(reg_noarg, m_arg): +class x86_rm_flt(reg_noarg, x86_arg): prio = default_prio + 1 reg_info = fltregs parser = reg_info.parser @@ -2633,7 +2623,7 @@ class bs_fbit(bsi): return True -class bs_cl1(bsi, m_arg): +class bs_cl1(bsi, x86_arg): parser = cl_or_imm def decode(self, v): @@ -2750,16 +2740,16 @@ class bs_cond_disp(bs_cond): return True -class bs_cond_imm(bs_cond_scale, m_arg): - parser = int_or_expr +class bs_cond_imm(bs_cond_scale, x86_arg): + parser = base_expr max_size = 32 - def fromstring(self, s, parser_result=None): + def fromstring(self, text, symbol_pool, parser_result=None): if parser_result: expr, start, stop = parser_result[self.parser] else: try: - expr, start, stop = self.parser.scanString(s).next() + expr, start, stop = self.parser.scanString(text).next() except StopIteration: expr = None self.expr = expr @@ -2774,7 +2764,7 @@ class bs_cond_imm(bs_cond_scale, m_arg): self.expr = ExprInt(v & mask, l) if self.expr is None: - log.debug('cannot fromstring int %r', s) + log.debug('cannot fromstring int %r', text) return None, None return start, stop @@ -2879,14 +2869,14 @@ class bs_cond_imm64(bs_cond_imm): class bs_rel_off(bs_cond_imm): - parser = int_or_expr + parser = base_expr - def fromstring(self, s, parser_result=None): + def fromstring(self, text, symbol_pool, parser_result=None): if parser_result: expr, start, stop = parser_result[self.parser] else: try: - expr, start, stop = self.parser.scanString(s).next() + expr, start, stop = self.parser.scanString(text).next() except StopIteration: expr = None self.expr = expr @@ -2939,7 +2929,7 @@ class bs_rel_off(bs_cond_imm): return True class bs_s08(bs_rel_off): - parser = int_or_expr + parser = base_expr @classmethod def flen(cls, mode, v): @@ -3020,10 +3010,10 @@ class bs_moff(bsi): return True -class bs_movoff(m_arg): +class bs_movoff(x86_arg): parser = deref_mem - def fromstring(self, s, parser_result=None): + def fromstring(self, text, symbol_pool, parser_result=None): if parser_result: e, start, stop = parser_result[self.parser] if e is None: @@ -3035,14 +3025,14 @@ class bs_movoff(m_arg): return None, None return start, stop try: - v, start, stop = self.parser.scanString(s).next() + v, start, stop = self.parser.scanString(text).next() except StopIteration: return None, None if not isinstance(e, ExprMem): return None, None self.expr = v[0] if self.expr is None: - log.debug('cannot fromstring int %r', s) + log.debug('cannot fromstring int %r', text) return None, None return start, stop @@ -3087,10 +3077,10 @@ class bs_movoff(m_arg): return True -class bs_msegoff(m_arg): +class bs_msegoff(x86_arg): parser = deref_ptr - def fromstring(self, s, parser_result=None): + def fromstring(self, text, symbol_pool, parser_result=None): if parser_result: e, start, stop = parser_result[self.parser] if e is None: @@ -3100,12 +3090,12 @@ class bs_msegoff(m_arg): return None, None return start, stop try: - v, start, stop = self.parser.scanString(s).next() + v, start, stop = self.parser.scanString(text).next() except StopIteration: return None, None self.expr = v[0] if self.expr is None: - log.debug('cannot fromstring int %r', s) + log.debug('cannot fromstring int %r', text) return None, None return start, stop @@ -3171,13 +3161,13 @@ disp = bs(l=0, cls=(bs_cond_disp,), fname = "disp") s08 = bs(l=8, cls=(bs_s08, )) -u08 = bs(l=8, cls=(x86_08, m_arg)) -u07 = bs(l=7, cls=(x86_08, m_arg)) -u16 = bs(l=16, cls=(x86_16, m_arg)) -u32 = bs(l=32, cls=(x86_32, m_arg)) -s3264 = bs(l=32, cls=(x86_s32to64, m_arg)) +u08 = bs(l=8, cls=(x86_08, x86_arg)) +u07 = bs(l=7, cls=(x86_08, x86_arg)) +u16 = bs(l=16, cls=(x86_16, x86_arg)) +u32 = bs(l=32, cls=(x86_32, x86_arg)) +s3264 = bs(l=32, cls=(x86_s32to64, x86_arg)) -u08_3 = bs(l=0, cls=(x86_imm_fix_08, m_arg), ival = 3) +u08_3 = bs(l=0, cls=(x86_imm_fix_08, x86_arg), ival = 3) d0 = bs("000", fname='reg') d1 = bs("001", fname='reg') |