diff options
Diffstat (limited to 'miasm2')
28 files changed, 1034 insertions, 1023 deletions
diff --git a/miasm2/analysis/depgraph.py b/miasm2/analysis/depgraph.py index 0d4a3719..5923e7ed 100644 --- a/miasm2/analysis/depgraph.py +++ b/miasm2/analysis/depgraph.py @@ -1,6 +1,6 @@ """Provide dependency graph""" -from miasm2.expression.expression import ExprInt, ExprLoc, ExprAff +from miasm2.expression.expression import ExprInt, ExprLoc, ExprAssign from miasm2.core.graph import DiGraph from miasm2.core.locationdb import LocationDB from miasm2.expression.simplifications import expr_simp_explicit @@ -319,7 +319,7 @@ class DependencyResultImplicit(DependencyResult): # Z3 Solver instance _solver = None - unsat_expr = ExprAff(ExprInt(0, 1), ExprInt(1, 1)) + unsat_expr = ExprAssign(ExprInt(0, 1), ExprInt(1, 1)) def _gen_path_constraints(self, translator, expr, expected): """Generate path constraint from @expr. Handle special case with @@ -341,7 +341,7 @@ class DependencyResultImplicit(DependencyResult): conds = z3.And( conds, translator.from_expr( - ExprAff(value, + ExprAssign(value, expected)) ) out.append(conds) diff --git a/miasm2/analysis/dse.py b/miasm2/analysis/dse.py index fb332154..1a3c0259 100644 --- a/miasm2/analysis/dse.py +++ b/miasm2/analysis/dse.py @@ -56,7 +56,7 @@ except ImportError: z3 = None from miasm2.expression.expression import ExprMem, ExprInt, ExprCompose, \ - ExprAff, ExprId, ExprLoc, LocKey + ExprAssign, ExprId, ExprLoc, LocKey from miasm2.core.bin_stream import bin_stream_vm from miasm2.jitter.emulatedsymbexec import EmulatedSymbExec from miasm2.expression.expression_helper import possible_values @@ -626,14 +626,14 @@ class DSEPathConstraint(DSEEngine): target_addr = self.ir_arch.loc_db.canonize_to_exprloc( possibility.value ) - path_constraint = set() # Set of ExprAff for the possible path + path_constraint = set() # Set of ExprAssign for the possible path # Get constraint associated to the possible path memory_to_add = ModularIntervals(symb_pc.size) for cons in possibility.constraints: eaff = cons.to_constraint() # eaff.get_r(mem_read=True) is not enough - # ExprAff consider a Memory access in dst as a write + # ExprAssign consider a Memory access in dst as a write mem = eaff.dst.get_r(mem_read=True) mem.update(eaff.src.get_r(mem_read=True)) for expr in mem: @@ -663,7 +663,7 @@ class DSEPathConstraint(DSEEngine): if not value.is_int(): raise TypeError("Rely on a symbolic memory case, " \ "address 0x%x" % address) - path_constraint.add(ExprAff(expr_mem, value)) + path_constraint.add(ExprAssign(expr_mem, value)) if target_addr == cur_addr: # Add path constraint diff --git a/miasm2/analysis/ssa.py b/miasm2/analysis/ssa.py index 61aa987f..0320d117 100644 --- a/miasm2/analysis/ssa.py +++ b/miasm2/analysis/ssa.py @@ -1,6 +1,6 @@ from collections import deque -from miasm2.expression.expression import ExprId, ExprAff, ExprOp, get_expr_ids +from miasm2.expression.expression import ExprId, ExprAssign, ExprOp, get_expr_ids from miasm2.ir.ir import AssignBlock, IRBlock @@ -185,7 +185,7 @@ class SSA(object): instructions = [] for dst in assignblk: # dst = src - aff = assignblk.dst2ExprAff(dst) + aff = assignblk.dst2ExprAssign(dst) # insert memory expression into start of list if dst.is_mem(): instructions.insert(0, aff) @@ -259,7 +259,7 @@ class SSA(object): src_ssa = rhs.popleft() # rebuild SSA expression - expr = ExprAff(dst_ssa, src_ssa) + expr = ExprAssign(dst_ssa, src_ssa) self.expressions[dst_ssa] = src_ssa self.ssa_to_location[dst_ssa] = (loc_key, index) @@ -455,10 +455,10 @@ class SSADiGraph(SSA): """ Generates an empty phi function for a variable :param expr: variable - :return: ExprAff, empty phi function for expr + :return: ExprAssign, empty phi function for expr """ phi = ExprId(self.PHI_STR, expr.size) - return ExprAff(expr, phi) + return ExprAssign(expr, phi) def _fill_phi(self, *args): """ diff --git a/miasm2/arch/aarch64/sem.py b/miasm2/arch/aarch64/sem.py index 3f70d7a7..1b591f74 100644 --- a/miasm2/arch/aarch64/sem.py +++ b/miasm2/arch/aarch64/sem.py @@ -1,5 +1,5 @@ from miasm2.expression.expression import ExprId, ExprInt, ExprLoc, ExprMem, \ - ExprCond, ExprCompose, ExprOp, ExprAff + ExprCond, ExprCompose, ExprOp, ExprAssign from miasm2.ir.ir import IntermediateRepresentation, IRBlock, AssignBlock from miasm2.arch.aarch64.arch import mn_aarch64, conds_expr, replace_regs from miasm2.arch.aarch64.regs import * @@ -11,16 +11,16 @@ from miasm2.jitter.csts import EXCEPT_DIV_BY_ZERO, EXCEPT_INT_XX def update_flag_zf(a): - return [ExprAff(zf, ExprOp("FLAG_EQ", a))] + return [ExprAssign(zf, ExprOp("FLAG_EQ", a))] def update_flag_zf_eq(a, b): - return [ExprAff(zf, ExprOp("FLAG_EQ_CMP", a, b))] + return [ExprAssign(zf, ExprOp("FLAG_EQ_CMP", a, b))] def update_flag_nf(arg): return [ - ExprAff( + ExprAssign( nf, ExprOp("FLAG_SIGN_SUB", arg, ExprInt(0, arg.size)) ) @@ -41,22 +41,22 @@ def check_ops_msb(a, b, c): def update_flag_add_cf(op1, op2): "Compute cf in @op1 + @op2" - return [ExprAff(cf, ExprOp("FLAG_ADD_CF", op1, op2))] + return [ExprAssign(cf, ExprOp("FLAG_ADD_CF", op1, op2))] def update_flag_add_of(op1, op2): "Compute of in @op1 + @op2" - return [ExprAff(of, ExprOp("FLAG_ADD_OF", op1, op2))] + return [ExprAssign(of, ExprOp("FLAG_ADD_OF", op1, op2))] def update_flag_sub_cf(op1, op2): "Compote CF in @op1 - @op2" - return [ExprAff(cf, ExprOp("FLAG_SUB_CF", op1, op2) ^ ExprInt(1, 1))] + return [ExprAssign(cf, ExprOp("FLAG_SUB_CF", op1, op2) ^ ExprInt(1, 1))] def update_flag_sub_of(op1, op2): "Compote OF in @op1 - @op2" - return [ExprAff(of, ExprOp("FLAG_SUB_OF", op1, op2))] + return [ExprAssign(of, ExprOp("FLAG_SUB_OF", op1, op2))] def update_flag_arith_add_co(arg1, arg2): @@ -72,7 +72,7 @@ def update_flag_arith_add_zn(arg1, arg2): """ e = [] e += update_flag_zf_eq(arg1, -arg2) - e += [ExprAff(nf, ExprOp("FLAG_SIGN_SUB", arg1, -arg2))] + e += [ExprAssign(nf, ExprOp("FLAG_SIGN_SUB", arg1, -arg2))] return e @@ -92,17 +92,17 @@ def update_flag_arith_sub_zn(arg1, arg2): """ e = [] e += update_flag_zf_eq(arg1, arg2) - e += [ExprAff(nf, ExprOp("FLAG_SIGN_SUB", arg1, arg2))] + e += [ExprAssign(nf, ExprOp("FLAG_SIGN_SUB", arg1, arg2))] return e def update_flag_zfaddwc_eq(arg1, arg2, arg3): - return [ExprAff(zf, ExprOp("FLAG_EQ_ADDWC", arg1, arg2, arg3))] + return [ExprAssign(zf, ExprOp("FLAG_EQ_ADDWC", arg1, arg2, arg3))] def update_flag_zfsubwc_eq(arg1, arg2, arg3): - return [ExprAff(zf, ExprOp("FLAG_EQ_SUBWC", arg1, arg2, arg3))] + return [ExprAssign(zf, ExprOp("FLAG_EQ_SUBWC", arg1, arg2, arg3))] def update_flag_arith_addwc_zn(arg1, arg2, arg3): @@ -111,7 +111,7 @@ def update_flag_arith_addwc_zn(arg1, arg2, arg3): """ e = [] e += update_flag_zfaddwc_eq(arg1, arg2, arg3) - e += [ExprAff(nf, ExprOp("FLAG_SIGN_ADDWC", arg1, arg2, arg3))] + e += [ExprAssign(nf, ExprOp("FLAG_SIGN_ADDWC", arg1, arg2, arg3))] return e @@ -121,18 +121,18 @@ def update_flag_arith_subwc_zn(arg1, arg2, arg3): """ e = [] e += update_flag_zfsubwc_eq(arg1, arg2, arg3) - e += [ExprAff(nf, ExprOp("FLAG_SIGN_SUBWC", arg1, arg2, arg3))] + e += [ExprAssign(nf, ExprOp("FLAG_SIGN_SUBWC", arg1, arg2, arg3))] return e def update_flag_addwc_cf(op1, op2, op3): "Compute cf in @res = @op1 + @op2 + @op3" - return [ExprAff(cf, ExprOp("FLAG_ADDWC_CF", op1, op2, op3))] + return [ExprAssign(cf, ExprOp("FLAG_ADDWC_CF", op1, op2, op3))] def update_flag_addwc_of(op1, op2, op3): "Compute of in @res = @op1 + @op2 + @op3" - return [ExprAff(of, ExprOp("FLAG_ADDWC_OF", op1, op2, op3))] + return [ExprAssign(of, ExprOp("FLAG_ADDWC_OF", op1, op2, op3))] def update_flag_arith_addwc_co(arg1, arg2, arg3): @@ -145,12 +145,12 @@ def update_flag_arith_addwc_co(arg1, arg2, arg3): def update_flag_subwc_cf(op1, op2, op3): "Compute cf in @res = @op1 + @op2 + @op3" - return [ExprAff(cf, ExprOp("FLAG_SUBWC_CF", op1, op2, op3) ^ ExprInt(1, 1))] + return [ExprAssign(cf, ExprOp("FLAG_SUBWC_CF", op1, op2, op3) ^ ExprInt(1, 1))] def update_flag_subwc_of(op1, op2, op3): "Compute of in @res = @op1 + @op2 + @op3" - return [ExprAff(of, ExprOp("FLAG_SUBWC_OF", op1, op2, op3))] + return [ExprAssign(of, ExprOp("FLAG_SUBWC_OF", op1, op2, op3))] def update_flag_arith_subwc_co(arg1, arg2, arg3): @@ -290,10 +290,10 @@ def bics(ir, instr, arg1, arg2, arg3): e = [] tmp1, tmp2 = arg2, (~extend_arg(arg2, arg3)) - e += [ExprAff(zf, ExprOp('FLAG_EQ_AND', tmp1, tmp2))] + e += [ExprAssign(zf, ExprOp('FLAG_EQ_AND', tmp1, tmp2))] e += update_flag_nf(res) - e.append(ExprAff(arg1, res)) + e.append(ExprAssign(arg1, res)) e += null_flag_co() return e, [] @@ -312,7 +312,7 @@ def adds(ir, instr, arg1, arg2, arg3): e += update_flag_arith_add_zn(arg2, arg3) e += update_flag_arith_add_co(arg2, arg3) - e.append(ExprAff(arg1, res)) + e.append(ExprAssign(arg1, res)) return e, [] @@ -326,7 +326,7 @@ def subs(ir, instr, arg1, arg2, arg3): e += update_flag_arith_sub_zn(arg2, arg3) e += update_flag_arith_sub_co(arg2, arg3) - e.append(ExprAff(arg1, res)) + e.append(ExprAssign(arg1, res)) return e, [] @@ -355,10 +355,10 @@ def ands(ir, instr, arg1, arg2, arg3): arg3 = extend_arg(arg2, arg3) res = arg2 & arg3 - e += [ExprAff(zf, ExprOp('FLAG_EQ_AND', arg2, arg3))] + e += [ExprAssign(zf, ExprOp('FLAG_EQ_AND', arg2, arg3))] e += update_flag_nf(res) - e.append(ExprAff(arg1, res)) + e.append(ExprAssign(arg1, res)) return e, [] def tst(ir, instr, arg1, arg2): @@ -366,7 +366,7 @@ def tst(ir, instr, arg1, arg2): arg2 = extend_arg(arg1, arg2) res = arg1 & arg2 - e += [ExprAff(zf, ExprOp('FLAG_EQ_AND', arg1, arg2))] + e += [ExprAssign(zf, ExprOp('FLAG_EQ_AND', arg1, arg2))] e += update_flag_nf(res) return e, [] @@ -401,9 +401,9 @@ def movk(ir, instr, arg1, arg2): isinstance(arg2.args[1], ExprInt)) value, shift = int(arg2.args[0].arg), int(arg2.args[1]) e.append( - ExprAff(arg1[shift:shift + 16], ExprInt(value, 16))) + ExprAssign(arg1[shift:shift + 16], ExprInt(value, 16))) else: - e.append(ExprAff(arg1[:16], ExprInt(int(arg2), 16))) + e.append(ExprAssign(arg1[:16], ExprInt(int(arg2), 16))) return e, [] @@ -444,16 +444,16 @@ def ccmp(ir, instr, arg1, arg2, arg3, arg4): new_cf = update_flag_sub_cf(arg1, arg2).src new_of = update_flag_sub_of(arg1, arg2).src - e.append(ExprAff(nf, ExprCond(cond_expr, + e.append(ExprAssign(nf, ExprCond(cond_expr, new_nf, default_nf))) - e.append(ExprAff(zf, ExprCond(cond_expr, + e.append(ExprAssign(zf, ExprCond(cond_expr, new_zf, default_zf))) - e.append(ExprAff(cf, ExprCond(cond_expr, + e.append(ExprAssign(cf, ExprCond(cond_expr, new_cf, default_cf))) - e.append(ExprAff(of, ExprCond(cond_expr, + e.append(ExprAssign(of, ExprCond(cond_expr, new_of, default_of))) return e, [] @@ -463,7 +463,7 @@ def csinc(ir, instr, arg1, arg2, arg3, arg4): e = [] cond_expr = cond2expr[arg4.name] e.append( - ExprAff( + ExprAssign( arg1, ExprCond( cond_expr, @@ -479,7 +479,7 @@ def csinv(ir, instr, arg1, arg2, arg3, arg4): e = [] cond_expr = cond2expr[arg4.name] e.append( - ExprAff( + ExprAssign( arg1, ExprCond( cond_expr, @@ -494,7 +494,7 @@ def csneg(ir, instr, arg1, arg2, arg3, arg4): e = [] cond_expr = cond2expr[arg4.name] e.append( - ExprAff( + ExprAssign( arg1, ExprCond( cond_expr, @@ -509,7 +509,7 @@ def cset(ir, instr, arg1, arg2): e = [] cond_expr = cond2expr[arg2.name] e.append( - ExprAff( + ExprAssign( arg1, ExprCond( cond_expr, @@ -525,7 +525,7 @@ def csetm(ir, instr, arg1, arg2): e = [] cond_expr = cond2expr[arg2.name] e.append( - ExprAff( + ExprAssign( arg1, ExprCond( cond_expr, @@ -562,11 +562,11 @@ def get_mem_access(mem): raise NotImplementedError('bad op') elif mem.op == "postinc": addr, off = mem.args - updt = ExprAff(addr, addr + off) + updt = ExprAssign(addr, addr + off) elif mem.op == "preinc_wb": base, off = mem.args addr = base + off - updt = ExprAff(base, base + off) + updt = ExprAssign(base, base + off) else: raise NotImplementedError('bad op') else: @@ -578,7 +578,7 @@ def get_mem_access(mem): def ldr(ir, instr, arg1, arg2): e = [] addr, updt = get_mem_access(arg2) - e.append(ExprAff(arg1, ExprMem(addr, arg1.size))) + e.append(ExprAssign(arg1, ExprMem(addr, arg1.size))) if updt: e.append(updt) return e, [] @@ -588,7 +588,7 @@ def ldr_size(ir, instr, arg1, arg2, size): e = [] addr, updt = get_mem_access(arg2) e.append( - ExprAff(arg1, ExprMem(addr, size).zeroExtend(arg1.size))) + ExprAssign(arg1, ExprMem(addr, size).zeroExtend(arg1.size))) if updt: e.append(updt) return e, [] @@ -606,7 +606,7 @@ def ldrs_size(ir, instr, arg1, arg2, size): e = [] addr, updt = get_mem_access(arg2) e.append( - ExprAff(arg1, ExprMem(addr, size).signExtend(arg1.size))) + ExprAssign(arg1, ExprMem(addr, size).signExtend(arg1.size))) if updt: e.append(updt) return e, [] @@ -628,7 +628,7 @@ def ldrsw(ir, instr, arg1, arg2): def l_str(ir, instr, arg1, arg2): e = [] addr, updt = get_mem_access(arg2) - e.append(ExprAff(ExprMem(addr, arg1.size), arg1)) + e.append(ExprAssign(ExprMem(addr, arg1.size), arg1)) if updt: e.append(updt) return e, [] @@ -637,7 +637,7 @@ def l_str(ir, instr, arg1, arg2): def strb(ir, instr, arg1, arg2): e = [] addr, updt = get_mem_access(arg2) - e.append(ExprAff(ExprMem(addr, 8), arg1[:8])) + e.append(ExprAssign(ExprMem(addr, 8), arg1[:8])) if updt: e.append(updt) return e, [] @@ -646,7 +646,7 @@ def strb(ir, instr, arg1, arg2): def strh(ir, instr, arg1, arg2): e = [] addr, updt = get_mem_access(arg2) - e.append(ExprAff(ExprMem(addr, 16), arg1[:16])) + e.append(ExprAssign(ExprMem(addr, 16), arg1[:16])) if updt: e.append(updt) return e, [] @@ -655,9 +655,9 @@ def strh(ir, instr, arg1, arg2): def stp(ir, instr, arg1, arg2, arg3): e = [] addr, updt = get_mem_access(arg3) - e.append(ExprAff(ExprMem(addr, arg1.size), arg1)) + e.append(ExprAssign(ExprMem(addr, arg1.size), arg1)) e.append( - ExprAff(ExprMem(addr + ExprInt(arg1.size / 8, addr.size), arg2.size), arg2)) + ExprAssign(ExprMem(addr + ExprInt(arg1.size / 8, addr.size), arg2.size), arg2)) if updt: e.append(updt) return e, [] @@ -666,9 +666,9 @@ def stp(ir, instr, arg1, arg2, arg3): def ldp(ir, instr, arg1, arg2, arg3): e = [] addr, updt = get_mem_access(arg3) - e.append(ExprAff(arg1, ExprMem(addr, arg1.size))) + e.append(ExprAssign(arg1, ExprMem(addr, arg1.size))) e.append( - ExprAff(arg2, ExprMem(addr + ExprInt(arg1.size / 8, addr.size), arg2.size))) + ExprAssign(arg2, ExprMem(addr + ExprInt(arg1.size / 8, addr.size), arg2.size))) if updt: e.append(updt) return e, [] @@ -682,7 +682,7 @@ def sbfm(ir, instr, arg1, arg2, arg3, arg4): else: shift = ExprInt(arg2.size - rim, arg2.size) res = (arg2[:sim].signExtend(arg1.size) << shift) - e.append(ExprAff(arg1, res)) + e.append(ExprAssign(arg1, res)) return e, [] @@ -694,7 +694,7 @@ def ubfm(ir, instr, arg1, arg2, arg3, arg4): else: shift = ExprInt(arg2.size - rim, arg2.size) res = (arg2[:sim].zeroExtend(arg1.size) << shift) - e.append(ExprAff(arg1, res)) + e.append(ExprAssign(arg1, res)) return e, [] def bfm(ir, instr, arg1, arg2, arg3, arg4): @@ -702,12 +702,12 @@ def bfm(ir, instr, arg1, arg2, arg3, arg4): rim, sim = int(arg3.arg), int(arg4) + 1 if sim > rim: res = arg2[rim:sim] - e.append(ExprAff(arg1[:sim-rim], res)) + e.append(ExprAssign(arg1[:sim-rim], res)) else: shift_i = arg2.size - rim shift = ExprInt(shift_i, arg2.size) res = arg2[:sim] - e.append(ExprAff(arg1[shift_i:shift_i+sim], res)) + e.append(ExprAssign(arg1[shift_i:shift_i+sim], res)) return e, [] @@ -721,7 +721,7 @@ def mrs(ir, insr, arg1, arg2, arg3, arg4, arg5): out.append(cf) out.append(zf) out.append(nf) - e.append(ExprAff(arg1, ExprCompose(*out).zeroExtend(arg1.size))) + e.append(ExprAssign(arg1, ExprCompose(*out).zeroExtend(arg1.size))) else: raise NotImplementedError("MRS not implemented") return e, [] @@ -730,10 +730,10 @@ def msr(ir, instr, arg1, arg2, arg3, arg4, arg5): e = [] if arg1.is_int(3) and arg2.is_id("c4") and arg3.is_id("c2") and arg4.is_int(0): - e.append(ExprAff(nf, arg5[31:32])) - e.append(ExprAff(zf, arg5[30:31])) - e.append(ExprAff(cf, arg5[29:30])) - e.append(ExprAff(of, arg5[28:29])) + e.append(ExprAssign(nf, arg5[31:32])) + e.append(ExprAssign(zf, arg5[30:31])) + e.append(ExprAssign(cf, arg5[29:30])) + e.append(ExprAssign(of, arg5[28:29])) else: raise NotImplementedError("MSR not implemented") return e, [] @@ -744,7 +744,7 @@ def adc(ir, instr, arg1, arg2, arg3): arg3 = extend_arg(arg2, arg3) e = [] r = arg2 + arg3 + cf.zeroExtend(arg3.size) - e.append(ExprAff(arg1, r)) + e.append(ExprAssign(arg1, r)) return e, [] @@ -752,7 +752,7 @@ def adcs(ir, instr, arg1, arg2, arg3): arg3 = extend_arg(arg2, arg3) e = [] r = arg2 + arg3 + cf.zeroExtend(arg3.size) - e.append(ExprAff(arg1, r)) + e.append(ExprAssign(arg1, r)) e += update_flag_arith_addwc_zn(arg2, arg3, cf) e += update_flag_arith_addwc_co(arg2, arg3, cf) return e, [] @@ -762,7 +762,7 @@ def sbc(ir, instr, arg1, arg2, arg3): arg3 = extend_arg(arg2, arg3) e = [] r = arg2 - (arg3 + (~cf).zeroExtend(arg3.size)) - e.append(ExprAff(arg1, r)) + e.append(ExprAssign(arg1, r)) return e, [] @@ -770,7 +770,7 @@ def sbcs(ir, instr, arg1, arg2, arg3): arg3 = extend_arg(arg2, arg3) e = [] r = arg2 - (arg3 + (~cf).zeroExtend(arg3.size)) - e.append(ExprAff(arg1, r)) + e.append(ExprAssign(arg1, r)) e += update_flag_arith_subwc_zn(arg2, arg3, ~cf) e += update_flag_arith_subwc_co(arg2, arg3, ~cf) return e, [] @@ -956,7 +956,7 @@ def rev(ir, instr, arg1, arg2): out.reverse() e = [] result = ExprCompose(*out) - e.append(ExprAff(arg1, result)) + e.append(ExprAssign(arg1, result)) return e, [] @@ -1088,7 +1088,7 @@ class ir_aarch64l(IntermediateRepresentation): def expraff_fix_regs_for_mode(self, e): dst = self.expr_fix_regs_for_mode(e.dst) src = self.expr_fix_regs_for_mode(e.src) - return ExprAff(dst, src) + return ExprAssign(dst, src) def irbloc_fix_regs_for_mode(self, irblock, mode=64): irs = [] @@ -1119,7 +1119,7 @@ class ir_aarch64l(IntermediateRepresentation): if dst != self.pc: dst = dst.replace_expr(pc_fixed) src = src.replace_expr(pc_fixed) - instr_ir[i] = ExprAff(dst, src) + instr_ir[i] = ExprAssign(dst, src) for idx, irblock in enumerate(extra_ir): extra_ir[idx] = irblock.modify_exprs(lambda expr: expr.replace_expr(pc_fixed) \ diff --git a/miasm2/arch/arm/ira.py b/miasm2/arch/arm/ira.py index fd8096d7..2214c626 100644 --- a/miasm2/arch/arm/ira.py +++ b/miasm2/arch/arm/ira.py @@ -3,7 +3,7 @@ from miasm2.ir.analysis import ira from miasm2.ir.ir import IRBlock from miasm2.arch.arm.sem import ir_arml, ir_armtl, ir_armb, ir_armtb, tab_cond -from miasm2.expression.expression import ExprAff, ExprOp, ExprLoc, ExprCond +from miasm2.expression.expression import ExprAssign, ExprOp, ExprLoc, ExprCond from miasm2.ir.ir import AssignBlock class ir_a_arml_base(ir_arml, ira): @@ -26,7 +26,7 @@ class ir_a_arml(ir_a_arml_base): def call_effects(self, ad, instr): call_assignblk = AssignBlock( [ - ExprAff( + ExprAssign( self.ret_reg, ExprOp( 'call_func_ret', @@ -37,7 +37,7 @@ class ir_a_arml(ir_a_arml_base): self.arch.regs.R3, ) ), - ExprAff( + ExprAssign( self.sp, ExprOp('call_func_stack', ad, self.sp) ), @@ -61,11 +61,11 @@ class ir_a_arml(ir_a_arml_base): call_assignblks = [ call_assignblk, - AssignBlock([ExprAff(self.IRDst, loc_next_expr)], instr), + AssignBlock([ExprAssign(self.IRDst, loc_next_expr)], instr), ] e_do = IRBlock(loc_do, call_assignblks) assignblks_out = [ - AssignBlock([ExprAff(self.IRDst, dst_cond)], instr) + AssignBlock([ExprAssign(self.IRDst, dst_cond)], instr) ] return assignblks_out, [e_do] diff --git a/miasm2/arch/arm/jit.py b/miasm2/arch/arm/jit.py index 716a8826..551d761a 100644 --- a/miasm2/arch/arm/jit.py +++ b/miasm2/arch/arm/jit.py @@ -5,7 +5,7 @@ from miasm2.core.locationdb import LocationDB from miasm2.core.utils import pck32, upck32 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.expression.expression import ExprId, ExprAssign, ExprCond from miasm2.ir.ir import IRBlock, AssignBlock from miasm2.ir.translators.C import TranslatorC from miasm2.expression.simplifications import expr_simp_high_to_explicit diff --git a/miasm2/arch/arm/sem.py b/miasm2/arch/arm/sem.py index 600ad586..f955b585 100644 --- a/miasm2/arch/arm/sem.py +++ b/miasm2/arch/arm/sem.py @@ -14,16 +14,16 @@ EXCEPT_PRIV_INSN = (1 << 17) def update_flag_zf(a): - return [ExprAff(zf, ExprOp("FLAG_EQ", a))] + return [ExprAssign(zf, ExprOp("FLAG_EQ", a))] def update_flag_zf_eq(a, b): - return [ExprAff(zf, ExprOp("FLAG_EQ_CMP", a, b))] + return [ExprAssign(zf, ExprOp("FLAG_EQ_CMP", a, b))] def update_flag_nf(arg): return [ - ExprAff( + ExprAssign( nf, ExprOp("FLAG_SIGN_SUB", arg, ExprInt(0, arg.size)) ) @@ -47,22 +47,22 @@ def check_ops_msb(a, b, c): def update_flag_add_cf(op1, op2): "Compute cf in @op1 + @op2" - return [ExprAff(cf, ExprOp("FLAG_ADD_CF", op1, op2))] + return [ExprAssign(cf, ExprOp("FLAG_ADD_CF", op1, op2))] def update_flag_add_of(op1, op2): "Compute of in @op1 + @op2" - return [ExprAff(of, ExprOp("FLAG_ADD_OF", op1, op2))] + return [ExprAssign(of, ExprOp("FLAG_ADD_OF", op1, op2))] def update_flag_sub_cf(op1, op2): "Compote CF in @op1 - @op2" - return [ExprAff(cf, ExprOp("FLAG_SUB_CF", op1, op2) ^ ExprInt(1, 1))] + return [ExprAssign(cf, ExprOp("FLAG_SUB_CF", op1, op2) ^ ExprInt(1, 1))] def update_flag_sub_of(op1, op2): "Compote OF in @op1 - @op2" - return [ExprAff(of, ExprOp("FLAG_SUB_OF", op1, op2))] + return [ExprAssign(of, ExprOp("FLAG_SUB_OF", op1, op2))] def update_flag_arith_add_co(arg1, arg2): @@ -78,7 +78,7 @@ def update_flag_arith_add_zn(arg1, arg2): """ e = [] e += update_flag_zf_eq(arg1, -arg2) - e += [ExprAff(nf, ExprOp("FLAG_SIGN_SUB", arg1, -arg2))] + e += [ExprAssign(nf, ExprOp("FLAG_SIGN_SUB", arg1, -arg2))] return e @@ -98,17 +98,17 @@ def update_flag_arith_sub_zn(arg1, arg2): """ e = [] e += update_flag_zf_eq(arg1, arg2) - e += [ExprAff(nf, ExprOp("FLAG_SIGN_SUB", arg1, arg2))] + e += [ExprAssign(nf, ExprOp("FLAG_SIGN_SUB", arg1, arg2))] return e def update_flag_zfaddwc_eq(arg1, arg2, arg3): - return [ExprAff(zf, ExprOp("FLAG_EQ_ADDWC", arg1, arg2, arg3))] + return [ExprAssign(zf, ExprOp("FLAG_EQ_ADDWC", arg1, arg2, arg3))] def update_flag_zfsubwc_eq(arg1, arg2, arg3): - return [ExprAff(zf, ExprOp("FLAG_EQ_SUBWC", arg1, arg2, arg3))] + return [ExprAssign(zf, ExprOp("FLAG_EQ_SUBWC", arg1, arg2, arg3))] def update_flag_arith_addwc_zn(arg1, arg2, arg3): @@ -117,7 +117,7 @@ def update_flag_arith_addwc_zn(arg1, arg2, arg3): """ e = [] e += update_flag_zfaddwc_eq(arg1, arg2, arg3) - e += [ExprAff(nf, ExprOp("FLAG_SIGN_ADDWC", arg1, arg2, arg3))] + e += [ExprAssign(nf, ExprOp("FLAG_SIGN_ADDWC", arg1, arg2, arg3))] return e @@ -127,18 +127,18 @@ def update_flag_arith_subwc_zn(arg1, arg2, arg3): """ e = [] e += update_flag_zfsubwc_eq(arg1, arg2, arg3) - e += [ExprAff(nf, ExprOp("FLAG_SIGN_SUBWC", arg1, arg2, arg3))] + e += [ExprAssign(nf, ExprOp("FLAG_SIGN_SUBWC", arg1, arg2, arg3))] return e def update_flag_addwc_cf(op1, op2, op3): "Compute cf in @res = @op1 + @op2 + @op3" - return [ExprAff(cf, ExprOp("FLAG_ADDWC_CF", op1, op2, op3))] + return [ExprAssign(cf, ExprOp("FLAG_ADDWC_CF", op1, op2, op3))] def update_flag_addwc_of(op1, op2, op3): "Compute of in @res = @op1 + @op2 + @op3" - return [ExprAff(of, ExprOp("FLAG_ADDWC_OF", op1, op2, op3))] + return [ExprAssign(of, ExprOp("FLAG_ADDWC_OF", op1, op2, op3))] def update_flag_arith_addwc_co(arg1, arg2, arg3): @@ -151,12 +151,12 @@ def update_flag_arith_addwc_co(arg1, arg2, arg3): def update_flag_subwc_cf(op1, op2, op3): "Compute cf in @res = @op1 + @op2 + @op3" - return [ExprAff(cf, ExprOp("FLAG_SUBWC_CF", op1, op2, op3) ^ ExprInt(1, 1))] + return [ExprAssign(cf, ExprOp("FLAG_SUBWC_CF", op1, op2, op3) ^ ExprInt(1, 1))] def update_flag_subwc_of(op1, op2, op3): "Compute of in @res = @op1 + @op2 + @op3" - return [ExprAff(of, ExprOp("FLAG_SUBWC_OF", op1, op2, op3))] + return [ExprAssign(of, ExprOp("FLAG_SUBWC_OF", op1, op2, op3))] def update_flag_arith_subwc_co(arg1, arg2, arg3): @@ -184,10 +184,10 @@ def adc(ir, instr, a, b, c=None): if instr.name == 'ADCS' and a != PC: e += update_flag_arith_addwc_zn(arg1, arg2, cf) e += update_flag_arith_addwc_co(arg1, arg2, cf) - e.append(ExprAff(a, r)) + e.append(ExprAssign(a, r)) dst = get_dst(a) if dst is not None: - e.append(ExprAff(ir.IRDst, r)) + e.append(ExprAssign(ir.IRDst, r)) return e, [] @@ -200,10 +200,10 @@ def add(ir, instr, a, b, c=None): if instr.name == 'ADDS' and a != PC: e += update_flag_arith_add_zn(arg1, arg2) e += update_flag_arith_add_co(arg1, arg2) - e.append(ExprAff(a, r)) + e.append(ExprAssign(a, r)) dst = get_dst(a) if dst is not None: - e.append(ExprAff(ir.IRDst, r)) + e.append(ExprAssign(ir.IRDst, r)) return e, [] @@ -213,13 +213,13 @@ def l_and(ir, instr, a, b, c=None): b, c = a, b r = b & c if instr.name == 'ANDS' and a != PC: - e += [ExprAff(zf, ExprOp('FLAG_EQ_AND', b, c))] + e += [ExprAssign(zf, ExprOp('FLAG_EQ_AND', b, c))] e += update_flag_nf(r) - e.append(ExprAff(a, r)) + e.append(ExprAssign(a, r)) dst = get_dst(a) if dst is not None: - e.append(ExprAff(ir.IRDst, r)) + e.append(ExprAssign(ir.IRDst, r)) return e, [] @@ -228,10 +228,10 @@ def sub(ir, instr, a, b, c=None): if c is None: b, c = a, b r = b - c - e.append(ExprAff(a, r)) + e.append(ExprAssign(a, r)) dst = get_dst(a) if dst is not None: - e.append(ExprAff(ir.IRDst, r)) + e.append(ExprAssign(ir.IRDst, r)) return e, [] @@ -243,10 +243,10 @@ def subs(ir, instr, a, b, c=None): r = b - c e += update_flag_arith_sub_zn(arg1, arg2) e += update_flag_arith_sub_co(arg1, arg2) - e.append(ExprAff(a, r)) + e.append(ExprAssign(a, r)) dst = get_dst(a) if dst is not None: - e.append(ExprAff(ir.IRDst, r)) + e.append(ExprAssign(ir.IRDst, r)) return e, [] @@ -255,10 +255,10 @@ def eor(ir, instr, a, b, c=None): if c is None: b, c = a, b r = b ^ c - e.append(ExprAff(a, r)) + e.append(ExprAssign(a, r)) dst = get_dst(a) if dst is not None: - e.append(ExprAff(ir.IRDst, r)) + e.append(ExprAssign(ir.IRDst, r)) return e, [] @@ -269,13 +269,13 @@ def eors(ir, instr, a, b, c=None): arg1, arg2 = b, c r = arg1 ^ arg2 - e += [ExprAff(zf, ExprOp('FLAG_EQ_CMP', arg1, arg2))] + e += [ExprAssign(zf, ExprOp('FLAG_EQ_CMP', arg1, arg2))] e += update_flag_nf(r) - e.append(ExprAff(a, r)) + e.append(ExprAssign(a, r)) dst = get_dst(a) if dst is not None: - e.append(ExprAff(ir.IRDst, r)) + e.append(ExprAssign(ir.IRDst, r)) return e, [] @@ -285,10 +285,10 @@ def rsb(ir, instr, a, b, c=None): b, c = a, b arg1, arg2 = c, b r = arg1 - arg2 - e.append(ExprAff(a, r)) + e.append(ExprAssign(a, r)) dst = get_dst(a) if dst is not None: - e.append(ExprAff(ir.IRDst, r)) + e.append(ExprAssign(ir.IRDst, r)) return e, [] @@ -300,10 +300,10 @@ def rsbs(ir, instr, a, b, c=None): r = arg1 - arg2 e += update_flag_arith_sub_zn(arg1, arg2) e += update_flag_arith_sub_co(arg1, arg2) - e.append(ExprAff(a, r)) + e.append(ExprAssign(a, r)) dst = get_dst(a) if dst is not None: - e.append(ExprAff(ir.IRDst, r)) + e.append(ExprAssign(ir.IRDst, r)) return e, [] @@ -313,10 +313,10 @@ def sbc(ir, instr, a, b, c=None): b, c = a, b arg1, arg2 = b, c r = arg1 - (arg2 + (~cf).zeroExtend(32)) - e.append(ExprAff(a, r)) + e.append(ExprAssign(a, r)) dst = get_dst(a) if dst is not None: - e.append(ExprAff(ir.IRDst, r)) + e.append(ExprAssign(ir.IRDst, r)) return e, [] @@ -330,10 +330,10 @@ def sbcs(ir, instr, a, b, c=None): e += update_flag_arith_subwc_zn(arg1, arg2, ~cf) e += update_flag_arith_subwc_co(arg1, arg2, ~cf) - e.append(ExprAff(a, r)) + e.append(ExprAssign(a, r)) dst = get_dst(a) if dst is not None: - e.append(ExprAff(ir.IRDst, r)) + e.append(ExprAssign(ir.IRDst, r)) return e, [] @@ -343,10 +343,10 @@ def rsc(ir, instr, a, b, c=None): b, c = a, b arg1, arg2 = c, b r = arg1 - (arg2 + (~cf).zeroExtend(32)) - e.append(ExprAff(a, r)) + e.append(ExprAssign(a, r)) dst = get_dst(a) if dst is not None: - e.append(ExprAff(ir.IRDst, r)) + e.append(ExprAssign(ir.IRDst, r)) return e, [] @@ -360,11 +360,11 @@ def rscs(ir, instr, a, b, c=None): e += update_flag_arith_subwc_zn(arg1, arg2, ~cf) e += update_flag_arith_subwc_co(arg1, arg2, ~cf) - e.append(ExprAff(a, r)) + e.append(ExprAssign(a, r)) dst = get_dst(a) if dst is not None: - e.append(ExprAff(ir.IRDst, r)) + e.append(ExprAssign(ir.IRDst, r)) return e, [] @@ -373,7 +373,7 @@ def tst(ir, instr, a, b): arg1, arg2 = a, b r = arg1 & arg2 - e += [ExprAff(zf, ExprOp('FLAG_EQ_AND', arg1, arg2))] + e += [ExprAssign(zf, ExprOp('FLAG_EQ_AND', arg1, arg2))] e += update_flag_nf(r) return e, [] @@ -386,7 +386,7 @@ def teq(ir, instr, a, b, c=None): arg1, arg2 = b, c r = arg1 ^ arg2 - e += [ExprAff(zf, ExprOp('FLAG_EQ_CMP', arg1, arg2))] + e += [ExprAssign(zf, ExprOp('FLAG_EQ_CMP', arg1, arg2))] e += update_flag_nf(r) return e, [] @@ -417,10 +417,10 @@ def orr(ir, instr, a, b, c=None): if c is None: b, c = a, b r = b | c - e.append(ExprAff(a, r)) + e.append(ExprAssign(a, r)) dst = get_dst(a) if dst is not None: - e.append(ExprAff(ir.IRDst, r)) + e.append(ExprAssign(ir.IRDst, r)) return e, [] @@ -429,10 +429,10 @@ def orn(ir, instr, a, b, c=None): if c is None: b, c = a, b r = ~(b | c) - e.append(ExprAff(a, r)) + e.append(ExprAssign(a, r)) dst = get_dst(a) if dst is not None: - e.append(ExprAff(ir.IRDst, r)) + e.append(ExprAssign(ir.IRDst, r)) return e, [] @@ -443,66 +443,66 @@ def orrs(ir, instr, a, b, c=None): arg1, arg2 = b, c r = arg1 | arg2 - e += [ExprAff(zf, ExprOp('FLAG_EQ', r))] + e += [ExprAssign(zf, ExprOp('FLAG_EQ', r))] e += update_flag_nf(r) - e.append(ExprAff(a, r)) + e.append(ExprAssign(a, r)) dst = get_dst(a) if dst is not None: - e.append(ExprAff(ir.IRDst, r)) + e.append(ExprAssign(ir.IRDst, r)) return e, [] def mov(ir, instr, a, b): - e = [ExprAff(a, b)] + e = [ExprAssign(a, b)] dst = get_dst(a) if dst is not None: - e.append(ExprAff(ir.IRDst, b)) + e.append(ExprAssign(ir.IRDst, b)) return e, [] def movt(ir, instr, a, b): r = a | b << ExprInt(16, 32) - e = [ExprAff(a, r)] + e = [ExprAssign(a, r)] dst = get_dst(a) if dst is not None: - e.append(ExprAff(ir.IRDst, r)) + e.append(ExprAssign(ir.IRDst, r)) return e, [] def movs(ir, instr, a, b): e = [] - e.append(ExprAff(a, b)) + e.append(ExprAssign(a, b)) # XXX TODO check - e += [ExprAff(zf, ExprOp('FLAG_EQ', b))] + e += [ExprAssign(zf, ExprOp('FLAG_EQ', b))] e += update_flag_nf(b) dst = get_dst(a) if dst is not None: - e.append(ExprAff(ir.IRDst, b)) + e.append(ExprAssign(ir.IRDst, b)) return e, [] def mvn(ir, instr, a, b): r = b ^ ExprInt(-1, 32) - e = [ExprAff(a, r)] + e = [ExprAssign(a, r)] dst = get_dst(a) if dst is not None: - e.append(ExprAff(ir.IRDst, r)) + e.append(ExprAssign(ir.IRDst, r)) return e, [] def mvns(ir, instr, a, b): e = [] r = b ^ ExprInt(-1, 32) - e.append(ExprAff(a, r)) + e.append(ExprAssign(a, r)) # XXX TODO check - e += [ExprAff(zf, ExprOp('FLAG_EQ', r))] + e += [ExprAssign(zf, ExprOp('FLAG_EQ', r))] e += update_flag_nf(r) dst = get_dst(a) if dst is not None: - e.append(ExprAff(ir.IRDst, r)) + e.append(ExprAssign(ir.IRDst, r)) return e, [] @@ -516,7 +516,7 @@ def mrs(ir, instr, a, b): out.append(cf) out.append(zf) out.append(nf) - e.append(ExprAff(a, ExprCompose(*out))) + e.append(ExprAssign(a, ExprCompose(*out))) else: raise NotImplementedError("MRS not implemented") return e, [] @@ -524,10 +524,10 @@ def mrs(ir, instr, a, b): def msr(ir, instr, a, b): e = [] if a.is_id('CPSR_cf'): - e.append(ExprAff(nf, b[31:32])) - e.append(ExprAff(zf, b[30:31])) - e.append(ExprAff(cf, b[29:30])) - e.append(ExprAff(of, b[28:29])) + e.append(ExprAssign(nf, b[31:32])) + e.append(ExprAssign(zf, b[30:31])) + e.append(ExprAssign(cf, b[29:30])) + e.append(ExprAssign(of, b[28:29])) else: raise NotImplementedError("MSR not implemented") return e, [] @@ -536,10 +536,10 @@ def msr(ir, instr, a, b): def neg(ir, instr, a, b): e = [] r = - b - e.append(ExprAff(a, r)) + e.append(ExprAssign(a, r)) dst = get_dst(a) if dst is not None: - e.append(ExprAff(ir.IRDst, r)) + e.append(ExprAssign(ir.IRDst, r)) return e, [] def negs(ir, instr, a, b): @@ -550,10 +550,10 @@ def bic(ir, instr, a, b, c=None): if c is None: b, c = a, b r = b & (c ^ ExprInt(-1, 32)) - e.append(ExprAff(a, r)) + e.append(ExprAssign(a, r)) dst = get_dst(a) if dst is not None: - e.append(ExprAff(ir.IRDst, r)) + e.append(ExprAssign(ir.IRDst, r)) return e, [] @@ -564,13 +564,13 @@ def bics(ir, instr, a, b, c=None): tmp1, tmp2 = b, ~c r = tmp1 & tmp2 - e += [ExprAff(zf, ExprOp('FLAG_EQ_AND', tmp1, tmp2))] + e += [ExprAssign(zf, ExprOp('FLAG_EQ_AND', tmp1, tmp2))] e += update_flag_nf(r) - e.append(ExprAff(a, r)) + e.append(ExprAssign(a, r)) dst = get_dst(a) if dst is not None: - e.append(ExprAff(ir.IRDst, r)) + e.append(ExprAssign(ir.IRDst, r)) return e, [] @@ -583,23 +583,23 @@ def sdiv(ir, instr, a, b, c=None): loc_except = ExprId(ir.loc_db.add_location(), ir.IRDst.size) loc_next = ExprLoc(ir.get_next_loc_key(instr), ir.IRDst.size) - e.append(ExprAff(ir.IRDst, ExprCond(c, loc_div, loc_except))) + e.append(ExprAssign(ir.IRDst, ExprCond(c, loc_div, loc_except))) do_except = [] - do_except.append(ExprAff(exception_flags, ExprInt(EXCEPT_DIV_BY_ZERO, exception_flags.size))) - do_except.append(ExprAff(ir.IRDst, loc_next)) + do_except.append(ExprAssign(exception_flags, ExprInt(EXCEPT_DIV_BY_ZERO, exception_flags.size))) + do_except.append(ExprAssign(ir.IRDst, loc_next)) blk_except = IRBlock(loc_except.loc_key, [AssignBlock(do_except, instr)]) r = ExprOp("idiv", b, c) do_div = [] - do_div.append(ExprAff(a, r)) + do_div.append(ExprAssign(a, r)) dst = get_dst(a) if dst is not None: - do_div.append(ExprAff(ir.IRDst, r)) + do_div.append(ExprAssign(ir.IRDst, r)) - do_div.append(ExprAff(ir.IRDst, loc_next)) + do_div.append(ExprAssign(ir.IRDst, loc_next)) blk_div = IRBlock(loc_div.loc_key, [AssignBlock(do_div, instr)]) return e, [blk_div, blk_except] @@ -616,22 +616,22 @@ def udiv(ir, instr, a, b, c=None): loc_except = ExprLoc(ir.loc_db.add_location(), ir.IRDst.size) loc_next = ExprLoc(ir.get_next_loc_key(instr), ir.IRDst.size) - e.append(ExprAff(ir.IRDst, ExprCond(c, loc_div, loc_except))) + e.append(ExprAssign(ir.IRDst, ExprCond(c, loc_div, loc_except))) do_except = [] - do_except.append(ExprAff(exception_flags, ExprInt(EXCEPT_DIV_BY_ZERO, exception_flags.size))) - do_except.append(ExprAff(ir.IRDst, loc_next)) + do_except.append(ExprAssign(exception_flags, ExprInt(EXCEPT_DIV_BY_ZERO, exception_flags.size))) + do_except.append(ExprAssign(ir.IRDst, loc_next)) blk_except = IRBlock(loc_except.loc_key, [AssignBlock(do_except, instr)]) r = ExprOp("udiv", b, c) do_div = [] - do_div.append(ExprAff(a, r)) + do_div.append(ExprAssign(a, r)) dst = get_dst(a) if dst is not None: - do_div.append(ExprAff(ir.IRDst, r)) + do_div.append(ExprAssign(ir.IRDst, r)) - do_div.append(ExprAff(ir.IRDst, loc_next)) + do_div.append(ExprAssign(ir.IRDst, loc_next)) blk_div = IRBlock(loc_div.loc_key, [AssignBlock(do_div, instr)]) return e, [blk_div, blk_except] @@ -640,10 +640,10 @@ def udiv(ir, instr, a, b, c=None): def mla(ir, instr, a, b, c, d): e = [] r = (b * c) + d - e.append(ExprAff(a, r)) + e.append(ExprAssign(a, r)) dst = get_dst(a) if dst is not None: - e.append(ExprAff(ir.IRDst, r)) + e.append(ExprAssign(ir.IRDst, r)) return e, [] @@ -651,20 +651,20 @@ def mlas(ir, instr, a, b, c, d): e = [] r = (b * c) + d e += update_flag_zn(r) - e.append(ExprAff(a, r)) + e.append(ExprAssign(a, r)) dst = get_dst(a) if dst is not None: - e.append(ExprAff(ir.IRDst, r)) + e.append(ExprAssign(ir.IRDst, r)) return e, [] def mls(ir, instr, a, b, c, d): e = [] r = d - (b * c) - e.append(ExprAff(a, r)) + e.append(ExprAssign(a, r)) dst = get_dst(a) if dst is not None: - e.append(ExprAff(ir.IRDst, r)) + e.append(ExprAssign(ir.IRDst, r)) return e, [] @@ -673,10 +673,10 @@ def mul(ir, instr, a, b, c=None): if c is None: b, c = a, b r = b * c - e.append(ExprAff(a, r)) + e.append(ExprAssign(a, r)) dst = get_dst(a) if dst is not None: - e.append(ExprAff(ir.IRDst, r)) + e.append(ExprAssign(ir.IRDst, r)) return e, [] @@ -686,73 +686,73 @@ def muls(ir, instr, a, b, c=None): b, c = a, b r = b * c e += update_flag_zn(r) - e.append(ExprAff(a, r)) + e.append(ExprAssign(a, r)) dst = get_dst(a) if dst is not None: - e.append(ExprAff(ir.IRDst, r)) + e.append(ExprAssign(ir.IRDst, r)) return e, [] def umull(ir, instr, a, b, c, d): e = [] r = c.zeroExtend(64) * d.zeroExtend(64) - e.append(ExprAff(a, r[0:32])) - e.append(ExprAff(b, r[32:64])) + e.append(ExprAssign(a, r[0:32])) + e.append(ExprAssign(b, r[32:64])) # r15/IRDst not allowed as output return e, [] def umlal(ir, instr, a, b, c, d): e = [] r = c.zeroExtend(64) * d.zeroExtend(64) + ExprCompose(a, b) - e.append(ExprAff(a, r[0:32])) - e.append(ExprAff(b, r[32:64])) + e.append(ExprAssign(a, r[0:32])) + e.append(ExprAssign(b, r[32:64])) # r15/IRDst not allowed as output return e, [] def smull(ir, instr, a, b, c, d): e = [] r = c.signExtend(64) * d.signExtend(64) - e.append(ExprAff(a, r[0:32])) - e.append(ExprAff(b, r[32:64])) + e.append(ExprAssign(a, r[0:32])) + e.append(ExprAssign(b, r[32:64])) # r15/IRDst not allowed as output return e, [] def smlal(ir, instr, a, b, c, d): e = [] r = c.signExtend(64) * d.signExtend(64) + ExprCompose(a, b) - e.append(ExprAff(a, r[0:32])) - e.append(ExprAff(b, r[32:64])) + e.append(ExprAssign(a, r[0:32])) + e.append(ExprAssign(b, r[32:64])) # r15/IRDst not allowed as output return e, [] def b(ir, instr, a): e = [] - e.append(ExprAff(PC, a)) - e.append(ExprAff(ir.IRDst, a)) + e.append(ExprAssign(PC, a)) + e.append(ExprAssign(ir.IRDst, a)) return e, [] def bl(ir, instr, a): e = [] l = ExprInt(instr.offset + instr.l, 32) - e.append(ExprAff(PC, a)) - e.append(ExprAff(ir.IRDst, a)) - e.append(ExprAff(LR, l)) + e.append(ExprAssign(PC, a)) + e.append(ExprAssign(ir.IRDst, a)) + e.append(ExprAssign(LR, l)) return e, [] def bx(ir, instr, a): e = [] - e.append(ExprAff(PC, a)) - e.append(ExprAff(ir.IRDst, a)) + e.append(ExprAssign(PC, a)) + e.append(ExprAssign(ir.IRDst, a)) return e, [] def blx(ir, instr, a): e = [] l = ExprInt(instr.offset + instr.l, 32) - e.append(ExprAff(PC, a)) - e.append(ExprAff(ir.IRDst, a)) - e.append(ExprAff(LR, l)) + e.append(ExprAssign(PC, a)) + e.append(ExprAssign(ir.IRDst, a)) + e.append(ExprAssign(LR, l)) return e, [] @@ -804,20 +804,20 @@ def st_ld_r(ir, instr, a, a2, b, store=False, size=32, s_ext=False, z_ext=False) dst = None if store: - e.append(ExprAff(m, a)) + e.append(ExprAssign(m, a)) if dmem: - e.append(ExprAff(ExprMem(ad + ExprInt(4, 32), size=size), a2)) + e.append(ExprAssign(ExprMem(ad + ExprInt(4, 32), size=size), a2)) else: if a == PC: dst = PC - e.append(ExprAff(ir.IRDst, m)) - e.append(ExprAff(a, m)) + e.append(ExprAssign(ir.IRDst, m)) + e.append(ExprAssign(a, m)) if dmem: - e.append(ExprAff(a2, ExprMem(ad + ExprInt(4, 32), size=size))) + e.append(ExprAssign(a2, ExprMem(ad + ExprInt(4, 32), size=size))) # XXX TODO check multiple write cause by wb if wb or postinc: - e.append(ExprAff(base, base + off)) + e.append(ExprAssign(base, base + off)) return e, [] @@ -890,17 +890,17 @@ def st_ld_m(ir, instr, a, b, store=False, postinc=False, updown=False): for i, r in enumerate(regs): ad = base + ExprInt(i * step, 32) if store: - e.append(ExprAff(ExprMem(ad, 32), r)) + e.append(ExprAssign(ExprMem(ad, 32), r)) else: - e.append(ExprAff(r, ExprMem(ad, 32))) + e.append(ExprAssign(r, ExprMem(ad, 32))) if r == PC: - e.append(ExprAff(ir.IRDst, ExprMem(ad, 32))) + e.append(ExprAssign(ir.IRDst, ExprMem(ad, 32))) # XXX TODO check multiple write cause by wb if wb: if postinc: - e.append(ExprAff(a, base + ExprInt(len(regs) * step, 32))) + e.append(ExprAssign(a, base + ExprInt(len(regs) * step, 32))) else: - e.append(ExprAff(a, base + ExprInt((len(regs) - 1) * step, 32))) + e.append(ExprAssign(a, base + ExprInt((len(regs) - 1) * step, 32))) if store: pass else: @@ -944,8 +944,8 @@ def stmdb(ir, instr, a, b): def svc(ir, instr, a): e = [] except_int = EXCEPT_INT_XX - e.append(ExprAff(exception_flags, ExprInt(except_int, 32))) - e.append(ExprAff(interrupt_num, a)) + e.append(ExprAssign(exception_flags, ExprInt(except_int, 32))) + e.append(ExprAssign(interrupt_num, a)) return e, [] @@ -960,10 +960,10 @@ def lsr(ir, instr, a, b, c=None): if c is None: b, c = a, b r = b >> c - e.append(ExprAff(a, r)) + e.append(ExprAssign(a, r)) dst = get_dst(a) if dst is not None: - e.append(ExprAff(ir.IRDst, r)) + e.append(ExprAssign(ir.IRDst, r)) return e, [] @@ -972,14 +972,14 @@ def lsrs(ir, instr, a, b, c=None): if c is None: b, c = a, b r = b >> c - e.append(ExprAff(a, r)) + e.append(ExprAssign(a, r)) - e += [ExprAff(zf, ExprOp('FLAG_EQ', r))] + e += [ExprAssign(zf, ExprOp('FLAG_EQ', r))] e += update_flag_nf(r) dst = get_dst(a) if dst is not None: - e.append(ExprAff(ir.IRDst, r)) + e.append(ExprAssign(ir.IRDst, r)) return e, [] def asr(ir, instr, a, b, c=None): @@ -987,10 +987,10 @@ def asr(ir, instr, a, b, c=None): if c is None: b, c = a, b r = ExprOp("a>>", b, c) - e.append(ExprAff(a, r)) + e.append(ExprAssign(a, r)) dst = get_dst(a) if dst is not None: - e.append(ExprAff(ir.IRDst, r)) + e.append(ExprAssign(ir.IRDst, r)) return e, [] def asrs(ir, instr, a, b, c=None): @@ -998,14 +998,14 @@ def asrs(ir, instr, a, b, c=None): if c is None: b, c = a, b r = ExprOp("a>>", b, c) - e.append(ExprAff(a, r)) + e.append(ExprAssign(a, r)) - e += [ExprAff(zf, ExprOp('FLAG_EQ', r))] + e += [ExprAssign(zf, ExprOp('FLAG_EQ', r))] e += update_flag_nf(r) dst = get_dst(a) if dst is not None: - e.append(ExprAff(ir.IRDst, r)) + e.append(ExprAssign(ir.IRDst, r)) return e, [] def lsl(ir, instr, a, b, c=None): @@ -1013,10 +1013,10 @@ def lsl(ir, instr, a, b, c=None): if c is None: b, c = a, b r = b << c - e.append(ExprAff(a, r)) + e.append(ExprAssign(a, r)) dst = get_dst(a) if dst is not None: - e.append(ExprAff(ir.IRDst, r)) + e.append(ExprAssign(ir.IRDst, r)) return e, [] @@ -1025,28 +1025,28 @@ def lsls(ir, instr, a, b, c=None): if c is None: b, c = a, b r = b << c - e.append(ExprAff(a, r)) + e.append(ExprAssign(a, r)) - e += [ExprAff(zf, ExprOp('FLAG_EQ', r))] + e += [ExprAssign(zf, ExprOp('FLAG_EQ', r))] e += update_flag_nf(r) dst = get_dst(a) if dst is not None: - e.append(ExprAff(ir.IRDst, r)) + e.append(ExprAssign(ir.IRDst, r)) return e, [] def rors(ir, instr, a, b): e = [] r = ExprOp(">>>", a, b) - e.append(ExprAff(a, r)) + e.append(ExprAssign(a, r)) - e += [ExprAff(zf, ExprOp('FLAG_EQ', r))] + e += [ExprAssign(zf, ExprOp('FLAG_EQ', r))] e += update_flag_nf(r) dst = get_dst(a) if dst is not None: - e.append(ExprAff(ir.IRDst, r)) + e.append(ExprAssign(ir.IRDst, r)) return e, [] @@ -1055,9 +1055,9 @@ def push(ir, instr, a): regs = list(a.args) for i in xrange(len(regs)): r = SP + ExprInt(-4 * len(regs) + 4 * i, 32) - e.append(ExprAff(ExprMem(r, 32), regs[i])) + e.append(ExprAssign(ExprMem(r, 32), regs[i])) r = SP + ExprInt(-4 * len(regs), 32) - e.append(ExprAff(SP, r)) + e.append(ExprAssign(SP, r)) return e, [] @@ -1067,13 +1067,13 @@ def pop(ir, instr, a): dst = None for i in xrange(len(regs)): r = SP + ExprInt(4 * i, 32) - e.append(ExprAff(regs[i], ExprMem(r, 32))) + e.append(ExprAssign(regs[i], ExprMem(r, 32))) if regs[i] == ir.pc: dst = ExprMem(r, 32) r = SP + ExprInt(4 * len(regs), 32) - e.append(ExprAff(SP, r)) + e.append(ExprAssign(SP, r)) if dst is not None: - e.append(ExprAff(ir.IRDst, dst)) + e.append(ExprAssign(ir.IRDst, dst)) return e, [] @@ -1081,7 +1081,7 @@ def cbz(ir, instr, a, b): e = [] loc_next = ir.get_next_loc_key(instr) loc_next_expr = ExprLoc(loc_next, 32) - e.append(ExprAff(ir.IRDst, ExprCond(a, loc_next_expr, b))) + e.append(ExprAssign(ir.IRDst, ExprCond(a, loc_next_expr, b))) return e, [] @@ -1096,41 +1096,41 @@ def cbnz(ir, instr, a, b): def uxtb(ir, instr, a, b): e = [] r = b[:8].zeroExtend(32) - e.append(ExprAff(a, r)) + e.append(ExprAssign(a, r)) dst = None if PC in a.get_r(): dst = PC - e.append(ExprAff(ir.IRDst, r)) + e.append(ExprAssign(ir.IRDst, r)) return e, [] def uxth(ir, instr, a, b): e = [] r = b[:16].zeroExtend(32) - e.append(ExprAff(a, r)) + e.append(ExprAssign(a, r)) dst = None if PC in a.get_r(): dst = PC - e.append(ExprAff(ir.IRDst, r)) + e.append(ExprAssign(ir.IRDst, r)) return e, [] def sxtb(ir, instr, a, b): e = [] r = b[:8].signExtend(32) - e.append(ExprAff(a, r)) + e.append(ExprAssign(a, r)) dst = None if PC in a.get_r(): dst = PC - e.append(ExprAff(ir.IRDst, r)) + e.append(ExprAssign(ir.IRDst, r)) return e, [] def sxth(ir, instr, a, b): e = [] r = b[:16].signExtend(32) - e.append(ExprAff(a, r)) + e.append(ExprAssign(a, r)) dst = None if PC in a.get_r(): dst = PC - e.append(ExprAff(ir.IRDst, r)) + e.append(ExprAssign(ir.IRDst, r)) return e, [] @@ -1139,11 +1139,11 @@ def ubfx(ir, instr, a, b, c, d): c = int(c) d = int(d) r = b[c:c+d].zeroExtend(32) - e.append(ExprAff(a, r)) + e.append(ExprAssign(a, r)) dst = None if PC in a.get_r(): dst = PC - e.append(ExprAff(ir.IRDst, r)) + e.append(ExprAssign(ir.IRDst, r)) return e, [] def bfc(ir, instr, a, b, c): @@ -1161,11 +1161,11 @@ def bfc(ir, instr, a, b, c): if last < 32: out.append(a[last:]) r = ExprCompose(*out) - e.append(ExprAff(a, r)) + e.append(ExprAssign(a, r)) dst = None if PC in a.get_r(): dst = PC - e.append(ExprAff(ir.IRDst, r)) + e.append(ExprAssign(ir.IRDst, r)) return e, [] @@ -1181,19 +1181,19 @@ def pldw(ir, instr, a): def clz(ir, instr, a, b): e = [] - e.append(ExprAff(a, ExprOp('cntleadzeros', b))) + e.append(ExprAssign(a, ExprOp('cntleadzeros', b))) return e, [] def uxtab(ir, instr, a, b, c): e = [] - e.append(ExprAff(a, b + (c & ExprInt(0xff, 32)))) + e.append(ExprAssign(a, b + (c & ExprInt(0xff, 32)))) return e, [] def bkpt(ir, instr, a): e = [] - e.append(ExprAff(exception_flags, ExprInt(EXCEPT_SOFT_BP, 32))) - e.append(ExprAff(bp_num, a)) + e.append(ExprAssign(exception_flags, ExprInt(EXCEPT_SOFT_BP, 32))) + e.append(ExprAssign(bp_num, a)) return e, [] @@ -1206,58 +1206,58 @@ def _extract_s16(arg, part): def smul(ir, instr, a, b, c): e = [] - e.append(ExprAff(a, _extract_s16(b, instr.name[4]).signExtend(32) * _extract_s16(c, instr.name[5]).signExtend(32))) + e.append(ExprAssign(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) - e.append(ExprAff(a, prod[16:48])) + e.append(ExprAssign(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)) + e.append(ExprAssign(PC, dst)) + e.append(ExprAssign(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)) + e.append(ExprAssign(PC, dst)) + e.append(ExprAssign(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)) + e.append(ExprAssign(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)) + e.append(ExprAssign(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)) + e.append(ExprAssign(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)) + e.append(ExprAssign(a, result)) return e, [] @@ -1269,10 +1269,10 @@ def uadd8(ir, instr, a, b, c): 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))) + e.append(ExprAssign(a, ExprCompose(*sums))) for i, value in enumerate(ges): - e.append(ExprAff(ge_regs[i], value)) + e.append(ExprAssign(ge_regs[i], value)) return e, [] @@ -1283,14 +1283,14 @@ def sel(ir, instr, a, b, c): 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)) + e.append(ExprAssign(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)) + e.append(ExprAssign(a, result)) return e, [] @@ -1438,9 +1438,9 @@ def add_condition_expr(ir, instr, cond, instr_ir, extra_ir): has_irdst = True break if not has_irdst: - instr_ir.append(ExprAff(ir.IRDst, loc_next_expr)) + instr_ir.append(ExprAssign(ir.IRDst, loc_next_expr)) e_do = IRBlock(loc_do, [AssignBlock(instr_ir, instr)]) - e = [ExprAff(ir.IRDst, dst_cond)] + e = [ExprAssign(ir.IRDst, dst_cond)] return e, [e_do] + extra_ir mnemo_func = {} @@ -1656,7 +1656,7 @@ class ir_arml(IntermediateRepresentation): if dst != self.pc: dst = dst.replace_expr(pc_fixed) src = src.replace_expr(pc_fixed) - instr_ir[i] = ExprAff(dst, src) + instr_ir[i] = ExprAssign(dst, src) for idx, irblock in enumerate(extra_ir): extra_ir[idx] = irblock.modify_exprs(lambda expr: expr.replace_expr(pc_fixed) \ @@ -1706,7 +1706,7 @@ class ir_arml(IntermediateRepresentation): # Gen dummy irblock for IT instr loc_next = self.get_next_loc_key(instr) - dst = ExprAff(self.IRDst, ExprId(loc_next, 32)) + dst = ExprAssign(self.IRDst, ExprId(loc_next, 32)) dst_blk = AssignBlock([dst], instr) assignments.append(dst_blk) irblock = IRBlock(loc, assignments) @@ -1727,7 +1727,7 @@ class ir_arml(IntermediateRepresentation): local_cond = ~cond_eq else: local_cond = cond_eq - dst = ExprAff(self.IRDst, ExprCond(local_cond, ExprLoc(loc_do, 32), ExprLoc(loc_next, 32))) + dst = ExprAssign(self.IRDst, ExprCond(local_cond, ExprLoc(loc_do, 32), ExprLoc(loc_next, 32))) dst_blk = AssignBlock([dst], instr) assignments.append(dst_blk) irblock = IRBlock(loc, assignments) @@ -1743,7 +1743,7 @@ class ir_arml(IntermediateRepresentation): if split: raise NotImplementedError("Unsupported instr in IT block (%s)" % instr) - dst = ExprAff(self.IRDst, ExprId(loc_next, 32)) + dst = ExprAssign(self.IRDst, ExprId(loc_next, 32)) dst_blk = AssignBlock([dst], instr) assignments.append(dst_blk) irblock = IRBlock(loc, assignments) @@ -1824,7 +1824,7 @@ class ir_armtl(ir_arml): if dst != self.pc: dst = dst.replace_expr(pc_fixed) src = src.replace_expr(pc_fixed) - instr_ir[i] = ExprAff(dst, src) + instr_ir[i] = ExprAssign(dst, src) for idx, irblock in enumerate(extra_ir): extra_ir[idx] = irblock.modify_exprs(lambda expr: expr.replace_expr(pc_fixed) \ diff --git a/miasm2/arch/mep/sem.py b/miasm2/arch/mep/sem.py index e779b970..717afd7e 100644 --- a/miasm2/arch/mep/sem.py +++ b/miasm2/arch/mep/sem.py @@ -8,7 +8,7 @@ from miasm2.arch.mep.regs import PC, SP, LP, SAR, TP, RPB, RPE, RPC, EPC, NPC, \ take_jmp, in_erepeat from miasm2.arch.mep.regs import EXC, HI, LO, PSW, DEPC, DBG from miasm2.expression.expression import ExprId, ExprInt, ExprOp -from miasm2.expression.expression import ExprAff, ExprCond, ExprMem +from miasm2.expression.expression import ExprAssign, ExprCond, ExprMem from miasm2.core.cpu import sign_ext from miasm2.jitter.csts import EXCEPT_DIV_BY_ZERO @@ -105,7 +105,7 @@ def sw(reg_src, deref_dst): # imm = deref_reg_or_imm.zeroExtend(32) # dst = ExprMem(ExprOp("+", imm, deref_reg.arg)) # -# return [ExprAff(dst, reg_src)], [] +# return [ExprAssign(dst, reg_src)], [] @sbuild.parse @@ -242,7 +242,7 @@ def add3(ir, instr, reg_dst, reg_src, reg_or_imm): value = int(reg_or_imm.arg) result = ExprOp("+", reg_src, ExprInt(value, 32)) - return [ExprAff(reg_dst, result)], [] + return [ExprAssign(reg_dst, result)], [] manual_functions["add3"] = add3 @@ -287,7 +287,7 @@ def sbvck3(ir, instr, r0, rn, rm): # Return the result condition = ExprCond(overflow_test, ExprInt(1, 32), ExprInt(0, 32)) - return [ExprAff(r0, condition)], [] + return [ExprAssign(r0, condition)], [] manual_functions["sbvck3"] = sbvck3 @@ -602,12 +602,12 @@ def jmp(ir, instr, reg_or_imm): if isinstance(reg_or_imm, ExprId): # PC <- Rm31..1||0 - new_PC = ExprAff(PC, reg_or_imm) + new_PC = ExprAssign(PC, reg_or_imm) else: # PC <- PC31..28||0000||(target24)23..1||0 - new_PC = ExprAff(PC, ExprOp("+", ExprOp("&", PC, ExprInt(0xF0000000, 32)), reg_or_imm)) + new_PC = ExprAssign(PC, ExprOp("+", ExprOp("&", PC, ExprInt(0xF0000000, 32)), reg_or_imm)) - return [new_PC, ExprAff(ir.IRDst, new_PC)], [] + return [new_PC, ExprAssign(ir.IRDst, new_PC)], [] manual_functions["jmp"] = jmp diff --git a/miasm2/arch/mips32/ira.py b/miasm2/arch/mips32/ira.py index 4c4a33d8..90558708 100644 --- a/miasm2/arch/mips32/ira.py +++ b/miasm2/arch/mips32/ira.py @@ -1,6 +1,6 @@ #-*- coding:utf-8 -*- -from miasm2.expression.expression import ExprAff, ExprOp +from miasm2.expression.expression import ExprAssign, ExprOp from miasm2.ir.ir import IRBlock, AssignBlock from miasm2.ir.analysis import ira from miasm2.arch.mips32.sem import ir_mips32l, ir_mips32b @@ -13,7 +13,7 @@ class ir_a_mips32l(ir_mips32l, ira): def call_effects(self, ad, instr): call_assignblk = AssignBlock( [ - ExprAff( + ExprAssign( self.ret_reg, ExprOp( 'call_func_ret', diff --git a/miasm2/arch/mips32/sem.py b/miasm2/arch/mips32/sem.py index 92001280..a603e7c3 100644 --- a/miasm2/arch/mips32/sem.py +++ b/miasm2/arch/mips32/sem.py @@ -333,7 +333,7 @@ def ins(ir, instr, a, b, c, d): if pos + l != 32: my_slices.append((a[pos+l:], pos+l, 32)) r = m2_expr.ExprCompose(my_slices) - e.append(m2_expr.ExprAff(a, r)) + e.append(m2_expr.ExprAssign(a, r)) return e, [] @@ -433,16 +433,16 @@ def teq(ir, instr, arg1, arg2): loc_next_expr = m2_expr.ExprLoc(loc_next, ir.IRDst.size) do_except = [] - do_except.append(m2_expr.ExprAff(exception_flags, m2_expr.ExprInt( + do_except.append(m2_expr.ExprAssign(exception_flags, m2_expr.ExprInt( EXCEPT_DIV_BY_ZERO, exception_flags.size))) - do_except.append(m2_expr.ExprAff(ir.IRDst, loc_next_expr)) + do_except.append(m2_expr.ExprAssign(ir.IRDst, loc_next_expr)) blk_except = IRBlock(loc_except.index, [AssignBlock(do_except, instr)]) cond = arg1 - arg2 e = [] - e.append(m2_expr.ExprAff(ir.IRDst, + e.append(m2_expr.ExprAssign(ir.IRDst, m2_expr.ExprCond(cond, loc_next_expr, loc_except_expr))) return e, [blk_except] @@ -498,7 +498,7 @@ class ir_mips32l(IntermediateRepresentation): ZERO: m2_expr.ExprInt(0, 32) } - instr_ir = [m2_expr.ExprAff(expr.dst, expr.src.replace_expr(fixed_regs)) + instr_ir = [m2_expr.ExprAssign(expr.dst, expr.src.replace_expr(fixed_regs)) for expr in instr_ir] new_extra_ir = [irblock.modify_exprs(mod_src=lambda expr: expr.replace_expr(fixed_regs)) diff --git a/miasm2/arch/msp430/sem.py b/miasm2/arch/msp430/sem.py index 191abe75..4736a51c 100644 --- a/miasm2/arch/msp430/sem.py +++ b/miasm2/arch/msp430/sem.py @@ -24,23 +24,23 @@ def bcd2hex(val): def reset_sr_res(): - return [ExprAff(res, ExprInt(0, 7))] + return [ExprAssign(res, ExprInt(0, 7))] def update_flag_zf(a): - return [ExprAff(zf, ExprCond(a, ExprInt(0, zf.size), ExprInt(1, zf.size)))] + return [ExprAssign(zf, ExprCond(a, ExprInt(0, zf.size), ExprInt(1, zf.size)))] def update_flag_nf(a): - return [ExprAff(nf, a.msb())] + return [ExprAssign(nf, a.msb())] def update_flag_pf(a): - return [ExprAff(pf, ExprOp('parity', a & ExprInt(0xFF, a.size)))] + return [ExprAssign(pf, ExprOp('parity', a & ExprInt(0xFF, a.size)))] def update_flag_cf_inv_zf(a): - return [ExprAff(cf, ExprCond(a, ExprInt(1, cf.size), ExprInt(0, cf.size)))] + return [ExprAssign(cf, ExprCond(a, ExprInt(1, cf.size), ExprInt(0, cf.size)))] def update_flag_zn_r(a): @@ -52,20 +52,20 @@ def update_flag_zn_r(a): def update_flag_sub_cf(a, b, c): - return [ExprAff(cf, + return [ExprAssign(cf, ((((a ^ b) ^ c) ^ ((a ^ c) & (a ^ b))).msb()) ^ ExprInt(1, 1))] def update_flag_add_cf(a, b, c): - return [ExprAff(cf, (((a ^ b) ^ c) ^ ((a ^ c) & (~(a ^ b)))).msb())] + return [ExprAssign(cf, (((a ^ b) ^ c) ^ ((a ^ c) & (~(a ^ b)))).msb())] def update_flag_add_of(a, b, c): - return [ExprAff(of, (((a ^ c) & (~(a ^ b)))).msb())] + return [ExprAssign(of, (((a ^ c) & (~(a ^ b)))).msb())] def update_flag_sub_of(a, b, c): - return [ExprAff(of, (((a ^ c) & (a ^ b))).msb())] + return [ExprAssign(of, (((a ^ c) & (a ^ b))).msb())] def mng_autoinc(a, b, size): @@ -74,7 +74,7 @@ def mng_autoinc(a, b, size): return e, a, b a_r = a.args[0] - e.append(ExprAff(a_r, a_r + ExprInt(size / 8, a_r.size))) + e.append(ExprAssign(a_r, a_r + ExprInt(size / 8, a_r.size))) a = ExprMem(a_r, size) if isinstance(b, ExprMem) and a_r in b.arg: b = ExprMem(b.arg + ExprInt(size / 8, 16), b.size) @@ -90,35 +90,35 @@ def mov_b(ir, instr, a, b): a = a[:8] else: a = a[:8].zeroExtend(16) - e.append(ExprAff(b, a)) + e.append(ExprAssign(b, a)) return e, [] def mov_w(ir, instr, a, b): e, a, b = mng_autoinc(a, b, 16) - e.append(ExprAff(b, a)) + e.append(ExprAssign(b, a)) if b == ir.pc: - e.append(ExprAff(ir.IRDst, a)) + e.append(ExprAssign(ir.IRDst, a)) return e, [] def and_b(ir, instr, a, b): e, a, b = mng_autoinc(a, b, 8) c = a[:8] & b[:8] - e.append(ExprAff(b, c.zeroExtend(16))) + e.append(ExprAssign(b, c.zeroExtend(16))) e += update_flag_zn_r(c) e += update_flag_cf_inv_zf(c) - e += [ExprAff(of, ExprInt(0, 1))] + e += [ExprAssign(of, ExprInt(0, 1))] return e, [] def and_w(ir, instr, a, b): e, a, b = mng_autoinc(a, b, 16) c = a & b - e.append(ExprAff(b, c)) + e.append(ExprAssign(b, c)) e += update_flag_zn_r(c) e += update_flag_cf_inv_zf(c) - e += [ExprAff(of, ExprInt(0, 1))] + e += [ExprAssign(of, ExprInt(0, 1))] return e, [] @@ -126,21 +126,21 @@ def bic_b(ir, instr, a, b): e, a, b = mng_autoinc(a, b, 8) c = (a[:8] ^ ExprInt(0xff, 8)) & b[:8] c = c.zeroExtend(b.size) - e.append(ExprAff(b, c)) + e.append(ExprAssign(b, c)) return e, [] def bic_w(ir, instr, a, b): e, a, b = mng_autoinc(a, b, 16) c = (a ^ ExprInt(0xffff, 16)) & b - e.append(ExprAff(b, c)) + e.append(ExprAssign(b, c)) return e, [] def bis_w(ir, instr, a, b): e, a, b = mng_autoinc(a, b, 16) c = a | b - e.append(ExprAff(b, c)) + e.append(ExprAssign(b, c)) return e, [] @@ -149,14 +149,14 @@ def bit_w(ir, instr, a, b): c = a & b e += update_flag_zn_r(c) e += update_flag_cf_inv_zf(c) - e.append(ExprAff(of, ExprInt(0, 1))) + e.append(ExprAssign(of, ExprInt(0, 1))) return e, [] """ def sub_b(ir, instr, a, b): e, a, b = mng_autoinc(a, b, 8) c = b - a - e.append(ExprAff(b, c)) + e.append(ExprAssign(b, c)) e += update_flag_zn_r(c) e += update_flag_sub_cf(b, a, c) return None, e, [] @@ -166,7 +166,7 @@ def sub_b(ir, instr, a, b): def sub_w(ir, instr, a, b): e, a, b = mng_autoinc(a, b, 16) c = b - a - e.append(ExprAff(b, c)) + e.append(ExprAssign(b, c)) e += update_flag_zn_r(c) e += update_flag_sub_cf(b, a, c) # micrcorruption @@ -183,7 +183,7 @@ def add_b(ir, instr, a, b): b = b[:8] a = a[:8] c = b + a - e.append(ExprAff(b, c)) + e.append(ExprAssign(b, c)) e += update_flag_zn_r(c) e += update_flag_add_cf(a, b, c) e += update_flag_add_of(a, b, c) @@ -193,7 +193,7 @@ def add_b(ir, instr, a, b): def add_w(ir, instr, a, b): e, a, b = mng_autoinc(a, b, 16) c = b + a - e.append(ExprAff(b, c)) + e.append(ExprAssign(b, c)) e += update_flag_zn_r(c) e += update_flag_add_cf(a, b, c) e += update_flag_add_of(a, b, c) @@ -205,7 +205,7 @@ def dadd_w(ir, instr, a, b): # TODO: microcorruption no carryflag c = ExprOp("bcdadd", b, a) # +zeroExtend(cf, 16)) - e.append(ExprAff(b, c)) + e.append(ExprAssign(b, c)) # e += update_flag_zn_r(c) # micrcorruption @@ -213,7 +213,7 @@ def dadd_w(ir, instr, a, b): # e += update_flag_nf(a) e += reset_sr_res() - e.append(ExprAff(cf, ExprOp("bcdadd_cf", b, a))) # +zeroExtend(cf, 16)))) + e.append(ExprAssign(cf, ExprOp("bcdadd_cf", b, a))) # +zeroExtend(cf, 16)))) # of : undefined return e, [] @@ -222,17 +222,17 @@ def dadd_w(ir, instr, a, b): def xor_w(ir, instr, a, b): e, a, b = mng_autoinc(a, b, 16) c = b ^ a - e.append(ExprAff(b, c)) + e.append(ExprAssign(b, c)) e += update_flag_zn_r(c) e += update_flag_cf_inv_zf(c) - e.append(ExprAff(of, b.msb() & a.msb())) + e.append(ExprAssign(of, b.msb() & a.msb())) return e, [] def push_w(ir, instr, a): e = [] - e.append(ExprAff(ExprMem(SP - ExprInt(2, 16), 16), a)) - e.append(ExprAff(SP, SP - ExprInt(2, 16))) + e.append(ExprAssign(ExprMem(SP - ExprInt(2, 16), 16), a)) + e.append(ExprAssign(SP, SP - ExprInt(2, 16))) return e, [] @@ -242,17 +242,17 @@ def call(ir, instr, a): loc_next = ir.get_next_loc_key(instr) loc_next_expr = ExprLoc(loc_next, 16) - e.append(ExprAff(ExprMem(SP - ExprInt(2, 16), 16), loc_next_expr)) - e.append(ExprAff(SP, SP - ExprInt(2, 16))) - e.append(ExprAff(PC, a)) - e.append(ExprAff(ir.IRDst, a)) + e.append(ExprAssign(ExprMem(SP - ExprInt(2, 16), 16), loc_next_expr)) + e.append(ExprAssign(SP, SP - ExprInt(2, 16))) + e.append(ExprAssign(PC, a)) + e.append(ExprAssign(ir.IRDst, a)) return e, [] def swpb(ir, instr, a): e = [] x, y = a[:8], a[8:16] - e.append(ExprAff(a, ExprCompose(y, x))) + e.append(ExprAssign(a, ExprCompose(y, x))) return e, [] @@ -278,8 +278,8 @@ def jz(ir, instr, a): loc_next = ir.get_next_loc_key(instr) loc_next_expr = ExprLoc(loc_next, 16) e = [] - e.append(ExprAff(PC, ExprCond(zf, a, loc_next_expr))) - e.append(ExprAff(ir.IRDst, ExprCond(zf, a, loc_next_expr))) + e.append(ExprAssign(PC, ExprCond(zf, a, loc_next_expr))) + e.append(ExprAssign(ir.IRDst, ExprCond(zf, a, loc_next_expr))) return e, [] @@ -287,8 +287,8 @@ def jnz(ir, instr, a): loc_next = ir.get_next_loc_key(instr) loc_next_expr = ExprLoc(loc_next, 16) e = [] - e.append(ExprAff(PC, ExprCond(zf, loc_next_expr, a))) - e.append(ExprAff(ir.IRDst, ExprCond(zf, loc_next_expr, a))) + e.append(ExprAssign(PC, ExprCond(zf, loc_next_expr, a))) + e.append(ExprAssign(ir.IRDst, ExprCond(zf, loc_next_expr, a))) return e, [] @@ -296,8 +296,8 @@ def jl(ir, instr, a): loc_next = ir.get_next_loc_key(instr) loc_next_expr = ExprLoc(loc_next, 16) e = [] - e.append(ExprAff(PC, ExprCond(nf ^ of, a, loc_next_expr))) - e.append(ExprAff(ir.IRDst, ExprCond(nf ^ of, a, loc_next_expr))) + e.append(ExprAssign(PC, ExprCond(nf ^ of, a, loc_next_expr))) + e.append(ExprAssign(ir.IRDst, ExprCond(nf ^ of, a, loc_next_expr))) return e, [] @@ -305,8 +305,8 @@ def jc(ir, instr, a): loc_next = ir.get_next_loc_key(instr) loc_next_expr = ExprLoc(loc_next, 16) e = [] - e.append(ExprAff(PC, ExprCond(cf, a, loc_next_expr))) - e.append(ExprAff(ir.IRDst, ExprCond(cf, a, loc_next_expr))) + e.append(ExprAssign(PC, ExprCond(cf, a, loc_next_expr))) + e.append(ExprAssign(ir.IRDst, ExprCond(cf, a, loc_next_expr))) return e, [] @@ -314,8 +314,8 @@ def jnc(ir, instr, a): loc_next = ir.get_next_loc_key(instr) loc_next_expr = ExprLoc(loc_next, 16) e = [] - e.append(ExprAff(PC, ExprCond(cf, loc_next_expr, a))) - e.append(ExprAff(ir.IRDst, ExprCond(cf, loc_next_expr, a))) + e.append(ExprAssign(PC, ExprCond(cf, loc_next_expr, a))) + e.append(ExprAssign(ir.IRDst, ExprCond(cf, loc_next_expr, a))) return e, [] @@ -323,23 +323,23 @@ def jge(ir, instr, a): loc_next = ir.get_next_loc_key(instr) loc_next_expr = ExprLoc(loc_next, 16) e = [] - e.append(ExprAff(PC, ExprCond(nf ^ of, loc_next_expr, a))) - e.append(ExprAff(ir.IRDst, ExprCond(nf ^ of, loc_next_expr, a))) + e.append(ExprAssign(PC, ExprCond(nf ^ of, loc_next_expr, a))) + e.append(ExprAssign(ir.IRDst, ExprCond(nf ^ of, loc_next_expr, a))) return e, [] def jmp(ir, instr, a): e = [] - e.append(ExprAff(PC, a)) - e.append(ExprAff(ir.IRDst, a)) + e.append(ExprAssign(PC, a)) + e.append(ExprAssign(ir.IRDst, a)) return e, [] def rrc_w(ir, instr, a): e = [] c = ExprCompose(a[1:16], cf) - e.append(ExprAff(a, c)) - e.append(ExprAff(cf, a[:1])) + e.append(ExprAssign(a, c)) + e.append(ExprAssign(cf, a[:1])) # e += update_flag_zn_r(c) # micrcorruption @@ -347,16 +347,16 @@ def rrc_w(ir, instr, a): # e += update_flag_nf(a) e += reset_sr_res() - e.append(ExprAff(of, ExprInt(0, 1))) + e.append(ExprAssign(of, ExprInt(0, 1))) return e, [] def rra_w(ir, instr, a): e = [] c = ExprCompose(a[1:16], a[15:16]) - e.append(ExprAff(a, c)) + e.append(ExprAssign(a, c)) # TODO: error in disasm microcorruption? - # e.append(ExprAff(cf, a[:1])) + # e.append(ExprAssign(cf, a[:1])) # e += update_flag_zn_r(c) # micrcorruption @@ -364,18 +364,18 @@ def rra_w(ir, instr, a): # e += update_flag_nf(a) e += reset_sr_res() - e.append(ExprAff(of, ExprInt(0, 1))) + e.append(ExprAssign(of, ExprInt(0, 1))) return e, [] def sxt(ir, instr, a): e = [] c = a[:8].signExtend(16) - e.append(ExprAff(a, c)) + e.append(ExprAssign(a, c)) e += update_flag_zn_r(c) e += update_flag_cf_inv_zf(c) - e.append(ExprAff(of, ExprInt(0, 1))) + e.append(ExprAssign(of, ExprInt(0, 1))) return e, [] @@ -414,10 +414,10 @@ mnemo_func = { composed_sr = ExprCompose(cf, zf, nf, gie, cpuoff, osc, scg0, scg1, of, res) -def ComposeExprAff(dst, src): +def ComposeExprAssign(dst, src): e = [] for start, arg in dst.iter_args(): - e.append(ExprAff(arg, src[start:start+arg.size])) + e.append(ExprAssign(arg, src[start:start+arg.size])) return e @@ -442,14 +442,14 @@ class ir_msp430(IntermediateRepresentation): def mod_sr(self, instr, instr_ir, extra_ir): for i, x in enumerate(instr_ir): - x = ExprAff(x.dst, x.src.replace_expr({SR: composed_sr})) + x = ExprAssign(x.dst, x.src.replace_expr({SR: composed_sr})) instr_ir[i] = x if x.dst != SR: continue - xx = ComposeExprAff(composed_sr, x.src) + xx = ComposeExprAssign(composed_sr, x.src) instr_ir[i:i+1] = xx for i, x in enumerate(instr_ir): - x = ExprAff(x.dst, x.src.replace_expr( + x = ExprAssign(x.dst, x.src.replace_expr( {self.pc: ExprInt(instr.offset + instr.l, 16)})) instr_ir[i] = x diff --git a/miasm2/arch/ppc/ira.py b/miasm2/arch/ppc/ira.py index 79476e90..cde57dd3 100644 --- a/miasm2/arch/ppc/ira.py +++ b/miasm2/arch/ppc/ira.py @@ -1,4 +1,4 @@ -from miasm2.expression.expression import ExprAff, ExprOp +from miasm2.expression.expression import ExprAssign, ExprOp from miasm2.ir.ir import AssignBlock from miasm2.ir.analysis import ira from miasm2.arch.ppc.sem import ir_ppc32b @@ -25,7 +25,7 @@ class ir_a_ppc32b(ir_ppc32b, ira): def call_effects(self, ad, instr): call_assignblks = AssignBlock( [ - ExprAff( + ExprAssign( self.ret_reg, ExprOp( 'call_func_ret', @@ -36,7 +36,7 @@ class ir_a_ppc32b(ir_ppc32b, ira): self.arch.regs.R5, ) ), - ExprAff(self.sp, ExprOp('call_func_stack', ad, self.sp)), + ExprAssign(self.sp, ExprOp('call_func_stack', ad, self.sp)), ], instr ) diff --git a/miasm2/arch/ppc/sem.py b/miasm2/arch/ppc/sem.py index 82a662c2..3a8ec244 100644 --- a/miasm2/arch/ppc/sem.py +++ b/miasm2/arch/ppc/sem.py @@ -23,15 +23,15 @@ sbuild = SemBuilder(ctx) def mn_compute_flags(rvalue, overflow_expr=None): ret = [] - ret.append(ExprAff(CR0_LT, rvalue.msb())) - ret.append(ExprAff(CR0_GT, (ExprCond(rvalue, ExprInt(1, 1), + ret.append(ExprAssign(CR0_LT, rvalue.msb())) + ret.append(ExprAssign(CR0_GT, (ExprCond(rvalue, ExprInt(1, 1), ExprInt(0, 1)) & ~rvalue.msb()))) - ret.append(ExprAff(CR0_EQ, ExprCond(rvalue, ExprInt(0, 1), + ret.append(ExprAssign(CR0_EQ, ExprCond(rvalue, ExprInt(0, 1), ExprInt(1, 1)))) if overflow_expr != None: - ret.append(ExprAff(CR0_SO, XER_SO | overflow_expr)) + ret.append(ExprAssign(CR0_SO, XER_SO | overflow_expr)) else: - ret.append(ExprAff(CR0_SO, XER_SO)) + ret.append(ExprAssign(CR0_SO, XER_SO)) return ret @@ -70,8 +70,8 @@ def mn_do_add(ir, instr, arg1, arg2, arg3): msb2 = arg3.msb() msba = rvalue.msb() over_expr = ~(msb1 ^ msb2) & (msb1 ^ msba) - flags_update.append(ExprAff(XER_OV, over_expr)) - flags_update.append(ExprAff(XER_SO, XER_SO | over_expr)) + flags_update.append(ExprAssign(XER_OV, over_expr)) + flags_update.append(ExprAssign(XER_SO, XER_SO | over_expr)) if has_dot: flags_update += mn_compute_flags(rvalue, over_expr) @@ -79,9 +79,9 @@ def mn_do_add(ir, instr, arg1, arg2, arg3): if has_c or has_e: carry_expr = (((arg2 ^ arg3) ^ rvalue) ^ ((arg2 ^ rvalue) & (~(arg2 ^ arg3)))).msb() - flags_update.append(ExprAff(XER_CA, carry_expr)) + flags_update.append(ExprAssign(XER_CA, carry_expr)) - return ([ ExprAff(arg1, rvalue) ] + flags_update), [] + return ([ ExprAssign(arg1, rvalue) ] + flags_update), [] def mn_do_and(ir, instr, ra, rs, arg2): if len(instr.name) > 3 and instr.name[3] == 'C': @@ -90,7 +90,7 @@ def mn_do_and(ir, instr, ra, rs, arg2): oarg = arg2 rvalue = rs & oarg - ret = [ ExprAff(ra, rvalue) ] + ret = [ ExprAssign(ra, rvalue) ] if instr.name[-1] == '.': ret += mn_compute_flags(rvalue) @@ -98,7 +98,7 @@ def mn_do_and(ir, instr, ra, rs, arg2): return ret, [] def mn_do_cntlzw(ir, instr, ra, rs): - ret = [ ExprAff(ra, ExprOp('cntleadzeros', rs)) ] + ret = [ ExprAssign(ra, ExprOp('cntleadzeros', rs)) ] if instr.name[-1] == '.': ret += mn_compute_flags(rvalue) @@ -136,7 +136,7 @@ def mn_do_cr(ir, instr, crd, cra, crb): r = a ^ b else: raise RuntimeError("Unknown operation on CR") - return [ ExprAff(d, r) ], [] + return [ ExprAssign(d, r) ], [] def mn_do_div(ir, instr, rd, ra, rb): assert instr.name[0:4] == 'DIVW' @@ -177,18 +177,18 @@ def mn_do_div(ir, instr, rd, ra, rb): ExprInt(1, 1)) & ExprCond(rb ^ 0xFFFFFFFF, ExprInt(0, 1), ExprInt(1, 1))) - flags_update.append(ExprAff(XER_OV, over_expr)) - flags_update.append(ExprAff(XER_SO, XER_SO | over_expr)) + flags_update.append(ExprAssign(XER_OV, over_expr)) + flags_update.append(ExprAssign(XER_SO, XER_SO | over_expr)) if has_dot: flags_update += mn_compute_flags(rvalue, over_expr) - return ([ ExprAff(rd, rvalue) ] + flags_update), [] + return ([ ExprAssign(rd, rvalue) ] + flags_update), [] def mn_do_eqv(ir, instr, ra, rs, rb): rvalue = ~(rs ^ rb) - ret = [ ExprAff(ra, rvalue) ] + ret = [ ExprAssign(ra, rvalue) ] if instr.name[-1] == '.': ret += mn_compute_flags(rvalue) @@ -204,7 +204,7 @@ def mn_do_exts(ir, instr, ra, rs): assert False rvalue = rs[0:size].signExtend(32) - ret = [ ExprAff(ra, rvalue) ] + ret = [ ExprAssign(ra, rvalue) ] if instr.name[-1] == '.': ret += mn_compute_flags(rvalue) @@ -264,16 +264,16 @@ def mn_do_load(ir, instr, arg1, arg2, arg3=None): else: src = src.zeroExtend(32) - ret.append(ExprAff(arg1, src)) + ret.append(ExprAssign(arg1, src)) if has_u: if arg3 is None: - ret.append(ExprAff(arg2.arg.args[0], address)) + ret.append(ExprAssign(arg2.arg.args[0], address)) else: - ret.append(ExprAff(arg2, address)) + ret.append(ExprAssign(arg2, address)) if is_lwarx: - ret.append(ExprAff(reserve, ExprInt(1, 1))) - ret.append(ExprAff(reserve_address, address)) # XXX should be the PA + ret.append(ExprAssign(reserve, ExprInt(1, 1))) + ret.append(ExprAssign(reserve_address, address)) # XXX should be the PA return ret, [] @@ -283,7 +283,7 @@ def mn_do_lmw(ir, instr, rd, src): ri = int(rd.name[1:],10) i = 0 while ri <= 31: - ret.append(ExprAff(all_regs_ids_byname["R%d" % ri], + ret.append(ExprAssign(all_regs_ids_byname["R%d" % ri], ExprMem(address + ExprInt(i, 32), 32))) ri += 1 i += 4 @@ -305,7 +305,7 @@ def mn_do_mcrf(ir, instr, crfd, crfs): for bit in [ 'LT', 'GT', 'EQ', 'SO' ]: d = all_regs_ids_byname["%s_%s" % (crfd, bit)] s = all_regs_ids_byname["%s_%s" % (crfs, bit)] - ret.append(ExprAff(d, s)) + ret.append(ExprAssign(d, s)) return ret, [] @@ -314,12 +314,12 @@ def mn_do_mcrxr(ir, instr, crfd): for (bit, val) in [ ('LT', XER_SO), ('GT', XER_OV), ('EQ', XER_CA), ('SO', ExprInt(0, 1)) ]: - ret.append(ExprAff(all_regs_ids_byname["%s_%s" % (crfd, bit)], val)) + ret.append(ExprAssign(all_regs_ids_byname["%s_%s" % (crfd, bit)], val)) return ret, [] def mn_do_mfcr(ir, instr, rd): - return ([ ExprAff(rd, ExprCompose(*[ all_regs_ids_byname["CR%d_%s" % (i, b)] + return ([ ExprAssign(rd, ExprCompose(*[ all_regs_ids_byname["CR%d_%s" % (i, b)] for i in xrange(7, -1, -1) for b in ['SO', 'EQ', 'GT', 'LT']]))], []) @@ -332,15 +332,15 @@ def mn_mfspr(ir, instr, arg1, arg2): sprid = arg2.arg.arg gprid = int(arg1.name[1:]) if sprid in spr_dict: - return [ ExprAff(arg1, spr_dict[sprid]) ], [] + return [ ExprAssign(arg1, spr_dict[sprid]) ], [] elif sprid == 1: # XER - return [ ExprAff(arg1, ExprCompose(XER_BC, ExprInt(0, 22), + return [ ExprAssign(arg1, ExprCompose(XER_BC, ExprInt(0, 22), XER_CA, XER_OV, XER_SO)) ], [] else: - return [ ExprAff(spr_access, + return [ ExprAssign(spr_access, ExprInt(((sprid << SPR_ACCESS_SPR_OFF) | (gprid << SPR_ACCESS_GPR_OFF)), 32)), - ExprAff(exception_flags, ExprInt(EXCEPT_SPR_ACCESS, 32)) ], [] + ExprAssign(exception_flags, ExprInt(EXCEPT_SPR_ACCESS, 32)) ], [] def mn_mtcrf(ir, instr, crm, rs): ret = [] @@ -349,7 +349,7 @@ def mn_mtcrf(ir, instr, crm, rs): if crm.arg.arg & (1 << (7 - i)): j = (28 - 4 * i) + 3 for b in ['LT', 'GT', 'EQ', 'SO']: - ret.append(ExprAff(all_regs_ids_byname["CR%d_%s" % (i, b)], + ret.append(ExprAssign(all_regs_ids_byname["CR%d_%s" % (i, b)], rs[j:j+1])) j -= 1 @@ -357,24 +357,24 @@ def mn_mtcrf(ir, instr, crm, rs): def mn_mtmsr(ir, instr, rs): print "%08x: MSR assigned" % instr.offset - return [ ExprAff(MSR, rs) ], [] + return [ ExprAssign(MSR, rs) ], [] def mn_mtspr(ir, instr, arg1, arg2): sprid = arg1.arg.arg gprid = int(arg2.name[1:]) if sprid in spr_dict: - return [ ExprAff(spr_dict[sprid], arg2) ], [] + return [ ExprAssign(spr_dict[sprid], arg2) ], [] elif sprid == 1: # XER - return [ ExprAff(XER_SO, arg2[31:32]), - ExprAff(XER_OV, arg2[30:31]), - ExprAff(XER_CA, arg2[29:30]), - ExprAff(XER_BC, arg2[0:7]) ], [] + return [ ExprAssign(XER_SO, arg2[31:32]), + ExprAssign(XER_OV, arg2[30:31]), + ExprAssign(XER_CA, arg2[29:30]), + ExprAssign(XER_BC, arg2[0:7]) ], [] else: - return [ ExprAff(spr_access, + return [ ExprAssign(spr_access, ExprInt(((sprid << SPR_ACCESS_SPR_OFF) | (gprid << SPR_ACCESS_GPR_OFF) | SPR_ACCESS_IS_WRITE), 32)), - ExprAff(exception_flags, ExprInt(EXCEPT_SPR_ACCESS, 32)) ], [] + ExprAssign(exception_flags, ExprInt(EXCEPT_SPR_ACCESS, 32)) ], [] def mn_do_mul(ir, instr, rd, ra, arg2): variant = instr.name[3:] @@ -398,7 +398,7 @@ def mn_do_mul(ir, instr, rd, ra, arg2): if shift != 0: rvalue = rvalue[shift : shift + 32] - ret = [ ExprAff(rd, rvalue) ] + ret = [ ExprAssign(rd, rvalue) ] over_expr = None if variant[-1] == 'O': @@ -406,8 +406,8 @@ def mn_do_mul(ir, instr, rd, ra, arg2): ExprOp('*', v1.signExtend(64), v2.signExtend(64))), ExprInt(1, 1), ExprInt(0, 1)) - ret.append(ExprAff(XER_OV, over_expr)) - ret.append(ExprAff(XER_SO, XER_SO | over_expr)) + ret.append(ExprAssign(XER_OV, over_expr)) + ret.append(ExprAssign(XER_SO, XER_SO | over_expr)) if instr.name[-1] == '.': ret += mn_compute_flags(rvalue, over_expr) @@ -416,7 +416,7 @@ def mn_do_mul(ir, instr, rd, ra, arg2): def mn_do_nand(ir, instr, ra, rs, rb): rvalue = ~(rs & rb) - ret = [ ExprAff(ra, rvalue) ] + ret = [ ExprAssign(ra, rvalue) ] if instr.name[-1] == '.': ret += mn_compute_flags(rvalue) @@ -425,7 +425,7 @@ def mn_do_nand(ir, instr, ra, rs, rb): def mn_do_neg(ir, instr, rd, ra): rvalue = -ra - ret = [ ExprAff(rd, rvalue) ] + ret = [ ExprAssign(rd, rvalue) ] has_o = False over_expr = None @@ -433,8 +433,8 @@ def mn_do_neg(ir, instr, rd, ra): has_o = True over_expr = ExprCond(ra ^ ExprInt(0x80000000, 32), ExprInt(0, 1), ExprInt(1, 1)) - ret.append(ExprAff(XER_OV, over_expr)) - ret.append(ExprAff(XER_SO, XER_SO | over_expr)) + ret.append(ExprAssign(XER_OV, over_expr)) + ret.append(ExprAssign(XER_SO, XER_SO | over_expr)) if instr.name[-1] == '.': ret += mn_compute_flags(rvalue, over_expr) @@ -444,7 +444,7 @@ def mn_do_neg(ir, instr, rd, ra): def mn_do_nor(ir, instr, ra, rs, rb): rvalue = ~(rs | rb) - ret = [ ExprAff(ra, rvalue) ] + ret = [ ExprAssign(ra, rvalue) ] if instr.name[-1] == '.': ret += mn_compute_flags(rvalue) @@ -458,7 +458,7 @@ def mn_do_or(ir, instr, ra, rs, arg2): oarg = arg2 rvalue = rs | oarg - ret = [ ExprAff(ra, rvalue) ] + ret = [ ExprAssign(ra, rvalue) ] if instr.name[-1] == '.': ret += mn_compute_flags(rvalue) @@ -467,13 +467,13 @@ def mn_do_or(ir, instr, ra, rs, arg2): def mn_do_rfi(ir, instr): dest = ExprCompose(ExprInt(0, 2), SRR0[2:32]) - ret = [ ExprAff(MSR, (MSR & + ret = [ ExprAssign(MSR, (MSR & ~ExprInt(0b1111111101110011, 32) | ExprCompose(SRR1[0:2], ExprInt(0, 2), SRR1[4:7], ExprInt(0, 1), SRR1[8:16], ExprInt(0, 16)))), - ExprAff(PC, dest), - ExprAff(ir.IRDst, dest) ] + ExprAssign(PC, dest), + ExprAssign(ir.IRDst, dest) ] return ret, [] def mn_do_rotate(ir, instr, ra, rs, shift, mb, me): @@ -486,7 +486,7 @@ def mn_do_rotate(ir, instr, ra, rs, shift, mb, me): if instr.name[0:6] == 'RLWIMI': rvalue = rvalue | (ra & ~m) - ret = [ ExprAff(ra, rvalue) ] + ret = [ ExprAssign(ra, rvalue) ] if instr.name[-1] == '.': ret += mn_compute_flags(rvalue) @@ -497,7 +497,7 @@ def mn_do_slw(ir, instr, ra, rs, rb): rvalue = ExprCond(rb[5:6], ExprInt(0, 32), ExprOp('<<', rs, rb & ExprInt(0b11111, 32))) - ret = [ ExprAff(ra, rvalue) ] + ret = [ ExprAssign(ra, rvalue) ] if instr.name[-1] == '.': ret += mn_compute_flags(rvalue) @@ -507,7 +507,7 @@ def mn_do_slw(ir, instr, ra, rs, rb): def mn_do_sraw(ir, instr, ra, rs, rb): rvalue = ExprCond(rb[5:6], ExprInt(0xFFFFFFFF, 32), ExprOp('a>>', rs, rb & ExprInt(0b11111, 32))) - ret = [ ExprAff(ra, rvalue) ] + ret = [ ExprAssign(ra, rvalue) ] if instr.name[-1] == '.': ret += mn_compute_flags(rvalue) @@ -515,28 +515,28 @@ def mn_do_sraw(ir, instr, ra, rs, rb): mask = ExprCond(rb[5:6], ExprInt(0xFFFFFFFF, 32), (ExprInt(0xFFFFFFFF, 32) >> (ExprInt(32, 32) - (rb & ExprInt(0b11111, 32))))) - ret.append(ExprAff(XER_CA, rs.msb() & + ret.append(ExprAssign(XER_CA, rs.msb() & ExprCond(rs & mask, ExprInt(1, 1), ExprInt(0, 1)))) return ret, [] def mn_do_srawi(ir, instr, ra, rs, imm): rvalue = ExprOp('a>>', rs, imm) - ret = [ ExprAff(ra, rvalue) ] + ret = [ ExprAssign(ra, rvalue) ] if instr.name[-1] == '.': ret += mn_compute_flags(rvalue) mask = ExprInt(0xFFFFFFFF >> (32 - imm.arg.arg), 32) - ret.append(ExprAff(XER_CA, rs.msb() & + ret.append(ExprAssign(XER_CA, rs.msb() & ExprCond(rs & mask, ExprInt(1, 1), ExprInt(0, 1)))) return ret, [] def mn_do_srw(ir, instr, ra, rs, rb): rvalue = rs >> (rb & ExprInt(0b11111, 32)) - ret = [ ExprAff(ra, rvalue) ] + ret = [ ExprAssign(ra, rvalue) ] if instr.name[-1] == '.': ret += mn_compute_flags(rvalue) @@ -549,7 +549,7 @@ def mn_do_stmw(ir, instr, rs, dest): ri = int(rs.name[1:],10) i = 0 while ri <= 31: - ret.append(ExprAff(ExprMem(address + ExprInt(i,32), 32), + ret.append(ExprAssign(ExprMem(address + ExprInt(i,32), 32), all_regs_ids_byname["R%d" % ri])) ri += 1 i += 4 @@ -596,29 +596,29 @@ def mn_do_store(ir, instr, arg1, arg2, arg3=None): if has_b: src = byte_swap(src) - ret.append(ExprAff(dest, src)) + ret.append(ExprAssign(dest, src)) if has_u: if arg3 is None: - ret.append(ExprAff(arg2.arg.args[0], address)) + ret.append(ExprAssign(arg2.arg.args[0], address)) else: - ret.append(ExprAff(arg2, address)) + ret.append(ExprAssign(arg2, address)) if is_stwcx: loc_do = ExprLoc(ir.loc_db.add_location(), ir.IRDst.size) loc_dont = ExprLoc(ir.loc_db.add_location(), ir.IRDst.size) loc_next = ExprLoc(ir.get_next_loc_key(instr), ir.IRDst.size) - flags = [ ExprAff(CR0_LT, ExprInt(0,1)), - ExprAff(CR0_GT, ExprInt(0,1)), - ExprAff(CR0_SO, XER_SO)] + flags = [ ExprAssign(CR0_LT, ExprInt(0,1)), + ExprAssign(CR0_GT, ExprInt(0,1)), + ExprAssign(CR0_SO, XER_SO)] ret += flags - ret.append(ExprAff(CR0_EQ, ExprInt(1,1))) - ret.append(ExprAff(ir.IRDst, loc_next)) - dont = flags + [ ExprAff(CR0_EQ, ExprInt(0,1)), - ExprAff(ir.IRDst, loc_next) ] + ret.append(ExprAssign(CR0_EQ, ExprInt(1,1))) + ret.append(ExprAssign(ir.IRDst, loc_next)) + dont = flags + [ ExprAssign(CR0_EQ, ExprInt(0,1)), + ExprAssign(ir.IRDst, loc_next) ] additional_ir = [ IRBlock(loc_do, [ AssignBlock(ret) ]), IRBlock(loc_dont, [ AssignBlock(dont) ]) ] - ret = [ ExprAff(reserve, ExprInt(0, 1)), - ExprAff(ir.IRDst, ExprCond(reserve, loc_do, loc_dont)) ] + ret = [ ExprAssign(reserve, ExprInt(0, 1)), + ExprAssign(ir.IRDst, ExprCond(reserve, loc_do, loc_dont)) ] return ret, additional_ir @@ -658,8 +658,8 @@ def mn_do_sub(ir, instr, arg1, arg2, arg3): msb2 = arg3.msb() msba = rvalue.msb() over_expr = (msb1 ^ msb2) & (msb1 ^ msba) - flags_update.append(ExprAff(XER_OV, over_expr)) - flags_update.append(ExprAff(XER_SO, XER_SO | over_expr)) + flags_update.append(ExprAssign(XER_OV, over_expr)) + flags_update.append(ExprAssign(XER_SO, XER_SO | over_expr)) if has_dot: flags_update += mn_compute_flags(rvalue, over_expr) @@ -667,13 +667,13 @@ def mn_do_sub(ir, instr, arg1, arg2, arg3): if has_c or has_e: carry_expr = ((((arg3 ^ arg2) ^ rvalue) ^ ((arg3 ^ rvalue) & (arg3 ^ arg2))).msb()) - flags_update.append(ExprAff(XER_CA, ~carry_expr)) + flags_update.append(ExprAssign(XER_CA, ~carry_expr)) - return ([ ExprAff(arg1, rvalue) ] + flags_update), [] + return ([ ExprAssign(arg1, rvalue) ] + flags_update), [] def mn_do_xor(ir, instr, ra, rs, rb): rvalue = rs ^ rb - ret = [ ExprAff(ra, rvalue) ] + ret = [ ExprAssign(ra, rvalue) ] if instr.name[-1] == '.': ret += mn_compute_flags(rvalue) @@ -683,15 +683,15 @@ def mn_do_xor(ir, instr, ra, rs, rb): def mn_b(ir, instr, arg1, arg2 = None): if arg2 is not None: arg1 = arg2 - return [ ExprAff(PC, arg1), ExprAff(ir.IRDst, arg1) ], [] + return [ ExprAssign(PC, arg1), ExprAssign(ir.IRDst, arg1) ], [] def mn_bl(ir, instr, arg1, arg2 = None): if arg2 is not None: arg1 = arg2 dst = ir.get_next_instr(instr) - return [ ExprAff(LR, ExprLoc(dst, 32)), - ExprAff(PC, arg1), - ExprAff(ir.IRDst, arg1) ], [] + return [ ExprAssign(LR, ExprLoc(dst, 32)), + ExprAssign(PC, arg1), + ExprAssign(ir.IRDst, arg1) ], [] def mn_get_condition(instr): bit = instr.additional_info.bi & 0b11 @@ -706,7 +706,7 @@ def mn_do_cond_branch(ir, instr, dest): if bo & 0b00100: ctr_cond = True else: - ret.append(ExprAff(CTR, CTR - ExprInt(1, 32))) + ret.append(ExprAssign(CTR, CTR - ExprInt(1, 32))) ctr_cond = ExprCond(CTR ^ ExprInt(1, 32), ExprInt(1, 1), ExprInt(0, 1)) if bo & 0b00010: ctr_cond = ~ctr_cond @@ -733,10 +733,10 @@ def mn_do_cond_branch(ir, instr, dest): if instr.name[-1] == 'L' or instr.name[-2:-1] == 'LA': dst = ir.get_next_instr(instr) - ret.append(ExprAff(LR, ExprLoc(dst, 32))) + ret.append(ExprAssign(LR, ExprLoc(dst, 32))) - ret.append(ExprAff(PC, dest_expr)) - ret.append(ExprAff(ir.IRDst, dest_expr)) + ret.append(ExprAssign(PC, dest_expr)) + ret.append(ExprAssign(ir.IRDst, dest_expr)) return ret, [] @@ -777,7 +777,7 @@ def mn_assign(arg1, arg2): def mn_stb(ir, instr, arg1, arg2): dest = ExprMem(arg2.arg, 8) - return [ExprAff(dest, ExprSlice(arg1, 0, 8))], [] + return [ExprAssign(dest, ExprSlice(arg1, 0, 8))], [] @sbuild.parse def mn_stwu(arg1, arg2): diff --git a/miasm2/arch/x86/arch.py b/miasm2/arch/x86/arch.py index 2abd5bbc..e2c515d1 100644 --- a/miasm2/arch/x86/arch.py +++ b/miasm2/arch/x86/arch.py @@ -881,7 +881,7 @@ class mn_x86(cls_mn): raise NotImplementedError('not fully functional') def ir_pre_instruction(self): - return [ExprAff(mRIP[self.mode], + return [ExprAssign(mRIP[self.mode], ExprInt(self.offset + self.l, mRIP[self.mode].size))] @classmethod diff --git a/miasm2/arch/x86/ira.py b/miasm2/arch/x86/ira.py index a95e6c69..749069f6 100644 --- a/miasm2/arch/x86/ira.py +++ b/miasm2/arch/x86/ira.py @@ -1,6 +1,6 @@ #-*- coding:utf-8 -*- -from miasm2.expression.expression import ExprAff, ExprOp +from miasm2.expression.expression import ExprAssign, ExprOp from miasm2.ir.ir import AssignBlock from miasm2.ir.analysis import ira from miasm2.arch.x86.sem import ir_x86_16, ir_x86_32, ir_x86_64 @@ -46,7 +46,7 @@ class ir_a_x86_64(ir_x86_64, ir_a_x86_16): def call_effects(self, ad, instr): call_assignblk = AssignBlock( [ - ExprAff( + ExprAssign( self.ret_reg, ExprOp( 'call_func_ret', @@ -58,7 +58,7 @@ class ir_a_x86_64(ir_x86_64, ir_a_x86_16): self.arch.regs.R9, ) ), - ExprAff(self.sp, ExprOp('call_func_stack', ad, self.sp)), + ExprAssign(self.sp, ExprOp('call_func_stack', ad, self.sp)), ], instr ) diff --git a/miasm2/arch/x86/sem.py b/miasm2/arch/x86/sem.py index 816608cb..727d0bc2 100644 --- a/miasm2/arch/x86/sem.py +++ b/miasm2/arch/x86/sem.py @@ -60,12 +60,12 @@ OF(A-B) = ((A XOR D) AND (A XOR B)) < 0 # XXX TODO make default check against 0 or not 0 (same eq as in C) def update_flag_zf_eq(a, b): - return [m2_expr.ExprAff(zf, m2_expr.ExprOp("FLAG_EQ_CMP", a, b))] + return [m2_expr.ExprAssign(zf, m2_expr.ExprOp("FLAG_EQ_CMP", a, b))] def update_flag_zf(a): return [ - m2_expr.ExprAff( + m2_expr.ExprAssign( zf, m2_expr.ExprCond( a, @@ -78,7 +78,7 @@ def update_flag_zf(a): def update_flag_nf(arg): return [ - m2_expr.ExprAff( + m2_expr.ExprAssign( nf, m2_expr.ExprOp("FLAG_SIGN_SUB", arg, m2_expr.ExprInt(0, arg.size)) ) @@ -86,13 +86,13 @@ def update_flag_nf(arg): def update_flag_pf(a): - return [m2_expr.ExprAff(pf, + return [m2_expr.ExprAssign(pf, m2_expr.ExprOp('parity', a & m2_expr.ExprInt(0xFF, a.size)))] def update_flag_af(op1, op2, res): - return [m2_expr.ExprAff(af, (op1 ^ op2 ^ res)[4:5])] + return [m2_expr.ExprAssign(af, (op1 ^ op2 ^ res)[4:5])] def update_flag_znp(a): @@ -112,8 +112,8 @@ def update_flag_np(result): def null_flag_co(): e = [] - e.append(m2_expr.ExprAff(of, m2_expr.ExprInt(0, of.size))) - e.append(m2_expr.ExprAff(cf, m2_expr.ExprInt(0, cf.size))) + e.append(m2_expr.ExprAssign(of, m2_expr.ExprInt(0, of.size))) + e.append(m2_expr.ExprAssign(cf, m2_expr.ExprInt(0, cf.size))) return e @@ -124,10 +124,10 @@ def update_flag_arith(a): def update_flag_zfaddwc_eq(arg1, arg2, arg3): - return [m2_expr.ExprAff(zf, m2_expr.ExprOp("FLAG_EQ_ADDWC", arg1, arg2, arg3))] + return [m2_expr.ExprAssign(zf, m2_expr.ExprOp("FLAG_EQ_ADDWC", arg1, arg2, arg3))] def update_flag_zfsubwc_eq(arg1, arg2, arg3): - return [m2_expr.ExprAff(zf, m2_expr.ExprOp("FLAG_EQ_SUBWC", arg1, arg2, arg3))] + return [m2_expr.ExprAssign(zf, m2_expr.ExprOp("FLAG_EQ_SUBWC", arg1, arg2, arg3))] def update_flag_arith_add_znp(arg1, arg2): @@ -136,7 +136,7 @@ def update_flag_arith_add_znp(arg1, arg2): """ e = [] e += update_flag_zf_eq(arg1, -arg2) - e += [m2_expr.ExprAff(nf, m2_expr.ExprOp("FLAG_SIGN_SUB", arg1, -arg2))] + e += [m2_expr.ExprAssign(nf, m2_expr.ExprOp("FLAG_SIGN_SUB", arg1, -arg2))] e += update_flag_pf(arg1+arg2) return e @@ -147,7 +147,7 @@ def update_flag_arith_addwc_znp(arg1, arg2, arg3): """ e = [] e += update_flag_zfaddwc_eq(arg1, arg2, arg3) - e += [m2_expr.ExprAff(nf, m2_expr.ExprOp("FLAG_SIGN_ADDWC", arg1, arg2, arg3))] + e += [m2_expr.ExprAssign(nf, m2_expr.ExprOp("FLAG_SIGN_ADDWC", arg1, arg2, arg3))] e += update_flag_pf(arg1+arg2+arg3.zeroExtend(arg2.size)) return e @@ -160,7 +160,7 @@ def update_flag_arith_sub_znp(arg1, arg2): """ e = [] e += update_flag_zf_eq(arg1, arg2) - e += [m2_expr.ExprAff(nf, m2_expr.ExprOp("FLAG_SIGN_SUB", arg1, arg2))] + e += [m2_expr.ExprAssign(nf, m2_expr.ExprOp("FLAG_SIGN_SUB", arg1, arg2))] e += update_flag_pf(arg1 - arg2) return e @@ -171,7 +171,7 @@ def update_flag_arith_subwc_znp(arg1, arg2, arg3): """ e = [] e += update_flag_zfsubwc_eq(arg1, arg2, arg3) - e += [m2_expr.ExprAff(nf, m2_expr.ExprOp("FLAG_SIGN_SUBWC", arg1, arg2, arg3))] + e += [m2_expr.ExprAssign(nf, m2_expr.ExprOp("FLAG_SIGN_SUBWC", arg1, arg2, arg3))] e += update_flag_pf(arg1 - (arg2+arg3.zeroExtend(arg2.size))) return e @@ -192,45 +192,45 @@ def arith_flag(a, b, c): def update_flag_add_cf(op1, op2, res): "Compute cf in @res = @op1 + @op2" - #return [m2_expr.ExprAff(cf, m2_expr.ExprOp("FLAG_SUB_CF", op1, -op2))] - return [m2_expr.ExprAff(cf, m2_expr.ExprOp("FLAG_ADD_CF", op1, op2))] + #return [m2_expr.ExprAssign(cf, m2_expr.ExprOp("FLAG_SUB_CF", op1, -op2))] + return [m2_expr.ExprAssign(cf, m2_expr.ExprOp("FLAG_ADD_CF", op1, op2))] def update_flag_add_of(op1, op2, res): "Compute of in @res = @op1 + @op2" - return [m2_expr.ExprAff(of, m2_expr.ExprOp("FLAG_ADD_OF", op1, op2))] + return [m2_expr.ExprAssign(of, m2_expr.ExprOp("FLAG_ADD_OF", op1, op2))] # checked: ok for sbb add because b & c before +cf def update_flag_sub_cf(op1, op2, res): "Compote CF in @res = @op1 - @op2" - return [m2_expr.ExprAff(cf, m2_expr.ExprOp("FLAG_SUB_CF", op1, op2))] + return [m2_expr.ExprAssign(cf, m2_expr.ExprOp("FLAG_SUB_CF", op1, op2))] def update_flag_sub_of(op1, op2, res): "Compote OF in @res = @op1 - @op2" - return [m2_expr.ExprAff(of, m2_expr.ExprOp("FLAG_SUB_OF", op1, op2))] + return [m2_expr.ExprAssign(of, m2_expr.ExprOp("FLAG_SUB_OF", op1, op2))] def update_flag_addwc_cf(op1, op2, op3): "Compute cf in @res = @op1 + @op2 + @op3" - return [m2_expr.ExprAff(cf, m2_expr.ExprOp("FLAG_ADDWC_CF", op1, op2, op3))] + return [m2_expr.ExprAssign(cf, m2_expr.ExprOp("FLAG_ADDWC_CF", op1, op2, op3))] def update_flag_addwc_of(op1, op2, op3): "Compute of in @res = @op1 + @op2 + @op3" - return [m2_expr.ExprAff(of, m2_expr.ExprOp("FLAG_ADDWC_OF", op1, op2, op3))] + return [m2_expr.ExprAssign(of, m2_expr.ExprOp("FLAG_ADDWC_OF", op1, op2, op3))] def update_flag_subwc_cf(op1, op2, op3): "Compute cf in @res = @op1 + @op2 + @op3" - return [m2_expr.ExprAff(cf, m2_expr.ExprOp("FLAG_SUBWC_CF", op1, op2, op3))] + return [m2_expr.ExprAssign(cf, m2_expr.ExprOp("FLAG_SUBWC_CF", op1, op2, op3))] def update_flag_subwc_of(op1, op2, op3): "Compute of in @res = @op1 + @op2 + @op3" - return [m2_expr.ExprAff(of, m2_expr.ExprOp("FLAG_SUBWC_OF", op1, op2, op3))] + return [m2_expr.ExprAssign(of, m2_expr.ExprOp("FLAG_SUBWC_OF", op1, op2, op3))] @@ -269,9 +269,9 @@ def update_flag_arith_subwc_co(arg1, arg2, arg3): def set_float_cs_eip(instr): e = [] # XXX TODO check float updt - e.append(m2_expr.ExprAff(float_eip, + e.append(m2_expr.ExprAssign(float_eip, m2_expr.ExprInt(instr.offset, float_eip.size))) - e.append(m2_expr.ExprAff(float_cs, CS)) + e.append(m2_expr.ExprAssign(float_cs, CS)) return e @@ -358,8 +358,8 @@ def gen_jcc(ir, instr, cond, dst, jmp_if): mn_dst = m2_expr.ExprCond(cond, dstA.zeroExtend(ir.IRDst.size), dstB.zeroExtend(ir.IRDst.size)) - e.append(m2_expr.ExprAff(meip, mn_dst)) - e.append(m2_expr.ExprAff(ir.IRDst, mn_dst)) + e.append(m2_expr.ExprAssign(meip, mn_dst)) + e.append(m2_expr.ExprAssign(ir.IRDst, mn_dst)) return e, [] @@ -378,9 +378,9 @@ def gen_fcmov(ir, instr, cond, arg1, arg2, mov_if): else: dstA, dstB = loc_skip_expr, loc_do_expr e = [] - e_do, extra_irs = [m2_expr.ExprAff(arg1, arg2)], [] - e_do.append(m2_expr.ExprAff(ir.IRDst, loc_skip_expr)) - e.append(m2_expr.ExprAff(ir.IRDst, m2_expr.ExprCond(cond, dstA, dstB))) + e_do, extra_irs = [m2_expr.ExprAssign(arg1, arg2)], [] + e_do.append(m2_expr.ExprAssign(ir.IRDst, loc_skip_expr)) + e.append(m2_expr.ExprAssign(ir.IRDst, m2_expr.ExprCond(cond, dstA, dstB))) return e, [IRBlock(loc_do, [AssignBlock(e_do, instr)])] @@ -400,8 +400,8 @@ def gen_cmov(ir, instr, cond, dst, src, mov_if): dstA, dstB = loc_skip_expr, loc_do_expr e = [] e_do, extra_irs = mov(ir, instr, dst, src) - e_do.append(m2_expr.ExprAff(ir.IRDst, loc_skip_expr)) - e.append(m2_expr.ExprAff(ir.IRDst, m2_expr.ExprCond(cond, dstA, dstB))) + e_do.append(m2_expr.ExprAssign(ir.IRDst, loc_skip_expr)) + e.append(m2_expr.ExprAssign(ir.IRDst, m2_expr.ExprCond(cond, dstA, dstB))) return e, [IRBlock(loc_do, [AssignBlock(e_do, instr)])] @@ -410,7 +410,7 @@ def mov(_, instr, dst, src): src = src[:dst.size] if src in [ES, CS, SS, DS, FS, GS]: src = src.zeroExtend(dst.size) - e = [m2_expr.ExprAff(dst, src)] + e = [m2_expr.ExprAssign(dst, src)] return e, [] @@ -418,7 +418,7 @@ def movq(_, instr, dst, src): src_final = (src.zeroExtend(dst.size) if dst.size >= src.size else src[:dst.size]) - return [m2_expr.ExprAff(dst, src_final)], [] + return [m2_expr.ExprAssign(dst, src_final)], [] @sbuild.parse @@ -429,12 +429,12 @@ def xchg(arg1, arg2): def movzx(_, instr, dst, src): - e = [m2_expr.ExprAff(dst, src.zeroExtend(dst.size))] + e = [m2_expr.ExprAssign(dst, src.zeroExtend(dst.size))] return e, [] def movsx(_, instr, dst, src): - e = [m2_expr.ExprAff(dst, src.signExtend(dst.size))] + e = [m2_expr.ExprAssign(dst, src.signExtend(dst.size))] return e, [] @@ -446,7 +446,7 @@ def lea(_, instr, dst, src): if ptr.size > dst.size: ptr = ptr[:dst.size] - e = [m2_expr.ExprAff(dst, ptr.zeroExtend(dst.size))] + e = [m2_expr.ExprAssign(dst, ptr.zeroExtend(dst.size))] return e, [] @@ -458,7 +458,7 @@ def add(_, instr, dst, src): e += update_flag_arith_add_znp(dst, src) e += update_flag_arith_add_co(dst, src, result) e += update_flag_af(dst, src, result) - e.append(m2_expr.ExprAff(dst, result)) + e.append(m2_expr.ExprAssign(dst, result)) return e, [] @@ -470,8 +470,8 @@ def xadd(_, instr, dst, src): e += update_flag_arith_add_co(src, dst, result) e += update_flag_af(dst, src, result) if dst != src: - e.append(m2_expr.ExprAff(src, dst)) - e.append(m2_expr.ExprAff(dst, result)) + e.append(m2_expr.ExprAssign(src, dst)) + e.append(m2_expr.ExprAssign(dst, result)) return e, [] @@ -485,7 +485,7 @@ def adc(_, instr, dst, src): e += update_flag_arith_addwc_znp(arg1, arg2, cf) e += update_flag_arith_addwc_co(arg1, arg2, cf) e += update_flag_af(arg1, arg2, result) - e.append(m2_expr.ExprAff(dst, result)) + e.append(m2_expr.ExprAssign(dst, result)) return e, [] @@ -498,7 +498,7 @@ def sub(_, instr, dst, src): e += update_flag_arith_sub_co(arg1, arg2, result) e += update_flag_af(dst, src, result) - e.append(m2_expr.ExprAff(dst, result)) + e.append(m2_expr.ExprAssign(dst, result)) return e, [] # a-(b+cf) @@ -513,7 +513,7 @@ def sbb(_, instr, dst, src): e += update_flag_arith_subwc_znp(arg1, arg2, cf) e += update_flag_af(arg1, arg2, result) e += update_flag_arith_subwc_co(arg1, arg2, cf) - e.append(m2_expr.ExprAff(dst, result)) + e.append(m2_expr.ExprAssign(dst, result)) return e, [] @@ -526,14 +526,14 @@ def neg(_, instr, src): e += update_flag_arith_sub_znp(arg1, arg2) e += update_flag_arith_sub_co(arg1, arg2, result) e += update_flag_af(arg1, arg2, result) - e.append(m2_expr.ExprAff(src, result)) + e.append(m2_expr.ExprAssign(src, result)) return (e, []) def l_not(_, instr, dst): e = [] result = (~dst) - e.append(m2_expr.ExprAff(dst, result)) + e.append(m2_expr.ExprAssign(dst, result)) return (e, []) @@ -551,38 +551,38 @@ def l_cmp(_, instr, dst, src): def xor(_, instr, dst, src): e = [] result = dst ^ src - e += [m2_expr.ExprAff(zf, m2_expr.ExprOp('FLAG_EQ_CMP', dst, src))] + e += [m2_expr.ExprAssign(zf, m2_expr.ExprOp('FLAG_EQ_CMP', dst, src))] e += update_flag_np(result) e += null_flag_co() - e.append(m2_expr.ExprAff(dst, result)) + e.append(m2_expr.ExprAssign(dst, result)) return (e, []) def pxor(_, instr, dst, src): e = [] result = dst ^ src - e.append(m2_expr.ExprAff(dst, result)) + e.append(m2_expr.ExprAssign(dst, result)) return (e, []) def l_or(_, instr, dst, src): e = [] result = dst | src - e += [m2_expr.ExprAff(zf, m2_expr.ExprOp('FLAG_EQ', dst | src))] + e += [m2_expr.ExprAssign(zf, m2_expr.ExprOp('FLAG_EQ', dst | src))] e += update_flag_np(result) e += null_flag_co() - e.append(m2_expr.ExprAff(dst, result)) + e.append(m2_expr.ExprAssign(dst, result)) return (e, []) def l_and(_, instr, dst, src): e = [] result = dst & src - e += [m2_expr.ExprAff(zf, m2_expr.ExprOp('FLAG_EQ_AND', dst, src))] + e += [m2_expr.ExprAssign(zf, m2_expr.ExprOp('FLAG_EQ_AND', dst, src))] e += update_flag_np(result) e += null_flag_co() - e.append(m2_expr.ExprAff(dst, result)) + e.append(m2_expr.ExprAssign(dst, result)) return (e, []) @@ -590,8 +590,8 @@ def l_test(_, instr, dst, src): e = [] result = dst & src - e += [m2_expr.ExprAff(zf, m2_expr.ExprOp('FLAG_EQ_CMP', result, m2_expr.ExprInt(0, result.size)))] - e += [m2_expr.ExprAff(nf, m2_expr.ExprOp("FLAG_SIGN_SUB", result, m2_expr.ExprInt(0, result.size)))] + e += [m2_expr.ExprAssign(zf, m2_expr.ExprOp('FLAG_EQ_CMP', result, m2_expr.ExprInt(0, result.size)))] + e += [m2_expr.ExprAssign(nf, m2_expr.ExprOp("FLAG_SIGN_SUB", result, m2_expr.ExprInt(0, result.size)))] e += update_flag_pf(result) e += null_flag_co() @@ -632,9 +632,9 @@ def _rotate_tpl(ir, instr, dst, src, op, left=False): res.msb() ^ new_cf if left else (dst ^ res).msb()) # Build basic blocks - e_do = [m2_expr.ExprAff(cf, new_cf), - m2_expr.ExprAff(of, new_of), - m2_expr.ExprAff(dst, res) + e_do = [m2_expr.ExprAssign(cf, new_cf), + m2_expr.ExprAssign(of, new_of), + m2_expr.ExprAssign(dst, res) ] # Don't generate conditional shifter on constant if isinstance(shifter, m2_expr.ExprInt): @@ -647,8 +647,8 @@ def _rotate_tpl(ir, instr, dst, src, op, left=False): loc_skip = ir.get_next_loc_key(instr) loc_skip_expr = m2_expr.ExprLoc(loc_skip, ir.IRDst.size) - e_do.append(m2_expr.ExprAff(ir.IRDst, loc_skip_expr)) - e.append(m2_expr.ExprAff( + e_do.append(m2_expr.ExprAssign(ir.IRDst, loc_skip_expr)) + e.append(m2_expr.ExprAssign( ir.IRDst, m2_expr.ExprCond(shifter, loc_do_expr, loc_skip_expr))) return (e, [IRBlock(loc_do, [AssignBlock(e_do, instr)])]) @@ -681,9 +681,9 @@ def rotate_with_carry_tpl(ir, instr, op, dst, src): # Build basic blocks - e_do = [m2_expr.ExprAff(cf, new_cf), - m2_expr.ExprAff(of, new_of), - m2_expr.ExprAff(dst, new_dst) + e_do = [m2_expr.ExprAssign(cf, new_cf), + m2_expr.ExprAssign(of, new_of), + m2_expr.ExprAssign(dst, new_dst) ] # Don't generate conditional shifter on constant if isinstance(shifter, m2_expr.ExprInt): @@ -696,8 +696,8 @@ def rotate_with_carry_tpl(ir, instr, op, dst, src): loc_skip = ir.get_next_loc_key(instr) loc_skip_expr = m2_expr.ExprLoc(loc_skip, ir.IRDst.size) - e_do.append(m2_expr.ExprAff(ir.IRDst, loc_skip_expr)) - e.append(m2_expr.ExprAff( + e_do.append(m2_expr.ExprAssign(ir.IRDst, loc_skip_expr)) + e.append(m2_expr.ExprAssign( ir.IRDst, m2_expr.ExprCond(shifter, loc_do_expr, loc_skip_expr))) return (e, [IRBlock(loc_do, [AssignBlock(e_do, instr)])]) @@ -765,11 +765,11 @@ def _shift_tpl(op, ir, instr, a, b, c=None, op_inv=None, left=False, # Build basic blocks e_do = [ - m2_expr.ExprAff(cf, new_cf), - m2_expr.ExprAff(of, m2_expr.ExprCond(shifter - i1, + m2_expr.ExprAssign(cf, new_cf), + m2_expr.ExprAssign(of, m2_expr.ExprCond(shifter - i1, m2_expr.ExprInt(0, of.size), value_of)), - m2_expr.ExprAff(a, res), + m2_expr.ExprAssign(a, res), ] e_do += update_flag_znp(res) @@ -784,8 +784,8 @@ def _shift_tpl(op, ir, instr, a, b, c=None, op_inv=None, left=False, loc_do, loc_do_expr = ir.gen_loc_key_and_expr(ir.IRDst.size) loc_skip = ir.get_next_loc_key(instr) loc_skip_expr = m2_expr.ExprLoc(loc_skip, ir.IRDst.size) - e_do.append(m2_expr.ExprAff(ir.IRDst, loc_skip_expr)) - e.append(m2_expr.ExprAff(ir.IRDst, m2_expr.ExprCond(shifter, loc_do_expr, + e_do.append(m2_expr.ExprAssign(ir.IRDst, loc_skip_expr)) + e.append(m2_expr.ExprAssign(ir.IRDst, m2_expr.ExprCond(shifter, loc_do_expr, loc_skip_expr))) return e, [IRBlock(loc_do, [AssignBlock(e_do, instr)])] @@ -814,38 +814,38 @@ def shld(ir, instr, dst, src1, src2): # XXX todo ### def cmc(_, instr): - e = [m2_expr.ExprAff(cf, m2_expr.ExprCond(cf, m2_expr.ExprInt(0, cf.size), + e = [m2_expr.ExprAssign(cf, m2_expr.ExprCond(cf, m2_expr.ExprInt(0, cf.size), m2_expr.ExprInt(1, cf.size)))] return e, [] def clc(_, instr): - e = [m2_expr.ExprAff(cf, m2_expr.ExprInt(0, cf.size))] + e = [m2_expr.ExprAssign(cf, m2_expr.ExprInt(0, cf.size))] return e, [] def stc(_, instr): - e = [m2_expr.ExprAff(cf, m2_expr.ExprInt(1, cf.size))] + e = [m2_expr.ExprAssign(cf, m2_expr.ExprInt(1, cf.size))] return e, [] def cld(_, instr): - e = [m2_expr.ExprAff(df, m2_expr.ExprInt(0, df.size))] + e = [m2_expr.ExprAssign(df, m2_expr.ExprInt(0, df.size))] return e, [] def std(_, instr): - e = [m2_expr.ExprAff(df, m2_expr.ExprInt(1, df.size))] + e = [m2_expr.ExprAssign(df, m2_expr.ExprInt(1, df.size))] return e, [] def cli(_, instr): - e = [m2_expr.ExprAff(i_f, m2_expr.ExprInt(0, i_f.size))] + e = [m2_expr.ExprAssign(i_f, m2_expr.ExprInt(0, i_f.size))] return e, [] def sti(_, instr): - e = [m2_expr.ExprAff(exception_flags, m2_expr.ExprInt(EXCEPT_PRIV_INSN, 32))] + e = [m2_expr.ExprAssign(exception_flags, m2_expr.ExprInt(EXCEPT_PRIV_INSN, 32))] return e, [] @@ -859,7 +859,7 @@ def inc(_, instr, dst): e += update_flag_af(arg1, arg2, result) e += update_flag_add_of(arg1, arg2, result) - e.append(m2_expr.ExprAff(dst, result)) + e.append(m2_expr.ExprAssign(dst, result)) return e, [] @@ -873,7 +873,7 @@ def dec(_, instr, dst): e += update_flag_af(arg1, arg2, result) e += update_flag_sub_of(arg1, arg2, result) - e.append(m2_expr.ExprAff(dst, result)) + e.append(m2_expr.ExprAssign(dst, result)) return e, [] @@ -887,10 +887,10 @@ def push_gen(ir, instr, src, size): sp = mRSP[instr.mode] new_sp = sp - m2_expr.ExprInt(off_size / 8, sp.size) - e.append(m2_expr.ExprAff(sp, new_sp)) + e.append(m2_expr.ExprAssign(sp, new_sp)) if ir.do_stk_segm: new_sp = ir.gen_segm_expr(SS, new_sp) - e.append(m2_expr.ExprAff(ir.ExprMem(new_sp, off_size), + e.append(m2_expr.ExprAssign(ir.ExprMem(new_sp, off_size), src)) return e, [] @@ -912,7 +912,7 @@ def pop_gen(ir, instr, src, size): new_sp = sp + m2_expr.ExprInt(src.size / 8, sp.size) # don't generate ESP incrementation on POP ESP if src != ir.sp: - e.append(m2_expr.ExprAff(sp, new_sp)) + e.append(m2_expr.ExprAssign(sp, new_sp)) # XXX FIX XXX for pop [esp] if isinstance(src, m2_expr.ExprMem): src = expr_simp(src.replace_expr({sp: new_sp})) @@ -920,7 +920,7 @@ def pop_gen(ir, instr, src, size): if ir.do_stk_segm: result = ir.gen_segm_expr(SS, result) - e.append(m2_expr.ExprAff(src, ir.ExprMem(result, src.size))) + e.append(m2_expr.ExprAssign(src, ir.ExprMem(result, src.size))) return e, [] @@ -935,7 +935,7 @@ def popw(ir, instr, src): def sete(_, instr, dst): e = [] e.append( - m2_expr.ExprAff( + m2_expr.ExprAssign( dst, m2_expr.ExprOp("CC_EQ", zf).zeroExtend(dst.size), ) @@ -946,7 +946,7 @@ def sete(_, instr, dst): def setnz(_, instr, dst): e = [] e.append( - m2_expr.ExprAff( + m2_expr.ExprAssign( dst, m2_expr.ExprOp("CC_EQ", ~zf).zeroExtend(dst.size), ) @@ -957,7 +957,7 @@ def setnz(_, instr, dst): def setl(_, instr, dst): e = [] e.append( - m2_expr.ExprAff( + m2_expr.ExprAssign( dst, m2_expr.ExprOp("CC_S<", nf, of).zeroExtend(dst.size), ) @@ -968,7 +968,7 @@ def setl(_, instr, dst): def setg(_, instr, dst): e = [] e.append( - m2_expr.ExprAff( + m2_expr.ExprAssign( dst, m2_expr.ExprOp("CC_S>", nf, of, zf).zeroExtend(dst.size), ) @@ -979,7 +979,7 @@ def setg(_, instr, dst): def setge(_, instr, dst): e = [] e.append( - m2_expr.ExprAff( + m2_expr.ExprAssign( dst, m2_expr.ExprOp("CC_S>=", nf, of).zeroExtend(dst.size), ) @@ -990,7 +990,7 @@ def setge(_, instr, dst): def seta(_, instr, dst): e = [] e.append( - m2_expr.ExprAff( + m2_expr.ExprAssign( dst, m2_expr.ExprOp("CC_U>", cf, zf).zeroExtend(dst.size), ) @@ -1001,7 +1001,7 @@ def seta(_, instr, dst): def setae(_, instr, dst): e = [] e.append( - m2_expr.ExprAff( + m2_expr.ExprAssign( dst, m2_expr.ExprOp("CC_U>=", cf).zeroExtend(dst.size), ) @@ -1012,7 +1012,7 @@ def setae(_, instr, dst): def setb(_, instr, dst): e = [] e.append( - m2_expr.ExprAff( + m2_expr.ExprAssign( dst, m2_expr.ExprOp("CC_U<", cf).zeroExtend(dst.size), ) @@ -1023,7 +1023,7 @@ def setb(_, instr, dst): def setbe(_, instr, dst): e = [] e.append( - m2_expr.ExprAff( + m2_expr.ExprAssign( dst, m2_expr.ExprOp("CC_U<=", cf, zf).zeroExtend(dst.size), ) @@ -1034,7 +1034,7 @@ def setbe(_, instr, dst): def setns(_, instr, dst): e = [] e.append( - m2_expr.ExprAff( + m2_expr.ExprAssign( dst, m2_expr.ExprOp("CC_NEG", ~nf).zeroExtend(dst.size), ) @@ -1045,7 +1045,7 @@ def setns(_, instr, dst): def sets(_, instr, dst): e = [] e.append( - m2_expr.ExprAff( + m2_expr.ExprAssign( dst, m2_expr.ExprOp("CC_NEG", nf).zeroExtend(dst.size), ) @@ -1056,7 +1056,7 @@ def sets(_, instr, dst): def seto(_, instr, dst): e = [] e.append( - m2_expr.ExprAff( + m2_expr.ExprAssign( dst, of.zeroExtend(dst.size) ) @@ -1067,7 +1067,7 @@ def seto(_, instr, dst): def setp(_, instr, dst): e = [] e.append( - m2_expr.ExprAff( + m2_expr.ExprAssign( dst, pf.zeroExtend(dst.size) ) @@ -1078,7 +1078,7 @@ def setp(_, instr, dst): def setnp(_, instr, dst): e = [] e.append( - m2_expr.ExprAff( + m2_expr.ExprAssign( dst, m2_expr.ExprCond( pf, @@ -1093,7 +1093,7 @@ def setnp(_, instr, dst): def setle(_, instr, dst): e = [] e.append( - m2_expr.ExprAff( + m2_expr.ExprAssign( dst, m2_expr.ExprOp("CC_S<=", nf, of, zf).zeroExtend(dst.size), ) @@ -1104,7 +1104,7 @@ def setle(_, instr, dst): def setna(_, instr, dst): e = [] e.append( - m2_expr.ExprAff( + m2_expr.ExprAssign( dst, m2_expr.ExprOp("CC_U<=", cf, zf).zeroExtend(dst.size), ) @@ -1115,7 +1115,7 @@ def setna(_, instr, dst): def setnbe(_, instr, dst): e = [] e.append( - m2_expr.ExprAff( + m2_expr.ExprAssign( dst, m2_expr.ExprOp("CC_U>", cf, zf).zeroExtend(dst.size), ) @@ -1126,7 +1126,7 @@ def setnbe(_, instr, dst): def setno(_, instr, dst): e = [] e.append( - m2_expr.ExprAff( + m2_expr.ExprAssign( dst, m2_expr.ExprCond( of, @@ -1141,7 +1141,7 @@ def setno(_, instr, dst): def setnb(_, instr, dst): e = [] e.append( - m2_expr.ExprAff( + m2_expr.ExprAssign( dst, m2_expr.ExprOp("CC_U>=", cf).zeroExtend(dst.size), ) @@ -1153,7 +1153,7 @@ def setalc(_, instr): dst = mRAX[instr.mode][0:8] e = [] e.append( - m2_expr.ExprAff(dst, m2_expr.ExprCond(cf, m2_expr.ExprInt(0xff, dst.size), + m2_expr.ExprAssign(dst, m2_expr.ExprCond(cf, m2_expr.ExprInt(0xff, dst.size), m2_expr.ExprInt(0, dst.size)))) return e, [] @@ -1170,7 +1170,7 @@ def bswap(_, instr, dst): dst[24:32], dst[16:24], dst[8:16], dst[:8]) else: raise ValueError('the size DOES matter') - e.append(m2_expr.ExprAff(dst, result)) + e.append(m2_expr.ExprAssign(dst, result)) return e, [] @@ -1199,18 +1199,18 @@ def cmps(ir, instr, size): e0 = [] - e0.append(m2_expr.ExprAff(src1, src1 + offset)) - e0.append(m2_expr.ExprAff(src2, src2 + offset)) - e0.append(m2_expr.ExprAff(ir.IRDst, loc_next_expr)) + e0.append(m2_expr.ExprAssign(src1, src1 + offset)) + e0.append(m2_expr.ExprAssign(src2, src2 + offset)) + e0.append(m2_expr.ExprAssign(ir.IRDst, loc_next_expr)) e0 = IRBlock(loc_df_0, [AssignBlock(e0, instr)]) e1 = [] - e1.append(m2_expr.ExprAff(src1, src1 - offset)) - e1.append(m2_expr.ExprAff(src2, src2 - offset)) - e1.append(m2_expr.ExprAff(ir.IRDst, loc_next_expr)) + e1.append(m2_expr.ExprAssign(src1, src1 - offset)) + e1.append(m2_expr.ExprAssign(src2, src2 - offset)) + e1.append(m2_expr.ExprAssign(ir.IRDst, loc_next_expr)) e1 = IRBlock(loc_df_1, [AssignBlock(e1, instr)]) - e.append(m2_expr.ExprAff(ir.IRDst, + e.append(m2_expr.ExprAssign(ir.IRDst, m2_expr.ExprCond(df, loc_df_1_expr, loc_df_0_expr))) return e, [e0, e1] @@ -1236,17 +1236,17 @@ def scas(ir, instr, size): ir.ExprMem(src_sgm, size)) e0 = [] - e0.append(m2_expr.ExprAff(src, src + offset)) + e0.append(m2_expr.ExprAssign(src, src + offset)) - e0.append(m2_expr.ExprAff(ir.IRDst, loc_next_expr)) + e0.append(m2_expr.ExprAssign(ir.IRDst, loc_next_expr)) e0 = IRBlock(loc_df_0, [AssignBlock(e0, instr)]) e1 = [] - e1.append(m2_expr.ExprAff(src, src - offset)) - e1.append(m2_expr.ExprAff(ir.IRDst, loc_next_expr)) + e1.append(m2_expr.ExprAssign(src, src - offset)) + e1.append(m2_expr.ExprAssign(ir.IRDst, loc_next_expr)) e1 = IRBlock(loc_df_1, [AssignBlock(e1, instr)]) - e.append(m2_expr.ExprAff(ir.IRDst, + e.append(m2_expr.ExprAssign(ir.IRDst, m2_expr.ExprCond(df, loc_df_1_expr, loc_df_0_expr))) return e, [e0, e1] @@ -1284,26 +1284,26 @@ def pushfw(ir, instr): def popfd(ir, instr): tmp = ir.ExprMem(mRSP[instr.mode], 32) e = [] - e.append(m2_expr.ExprAff(cf, m2_expr.ExprSlice(tmp, 0, 1))) - e.append(m2_expr.ExprAff(pf, m2_expr.ExprSlice(tmp, 2, 3))) - e.append(m2_expr.ExprAff(af, m2_expr.ExprSlice(tmp, 4, 5))) - e.append(m2_expr.ExprAff(zf, m2_expr.ExprSlice(tmp, 6, 7))) - e.append(m2_expr.ExprAff(nf, m2_expr.ExprSlice(tmp, 7, 8))) - e.append(m2_expr.ExprAff(tf, m2_expr.ExprSlice(tmp, 8, 9))) - e.append(m2_expr.ExprAff(i_f, m2_expr.ExprSlice(tmp, 9, 10))) - e.append(m2_expr.ExprAff(df, m2_expr.ExprSlice(tmp, 10, 11))) - e.append(m2_expr.ExprAff(of, m2_expr.ExprSlice(tmp, 11, 12))) - e.append(m2_expr.ExprAff(iopl, m2_expr.ExprSlice(tmp, 12, 14))) - e.append(m2_expr.ExprAff(nt, m2_expr.ExprSlice(tmp, 14, 15))) - e.append(m2_expr.ExprAff(rf, m2_expr.ExprSlice(tmp, 16, 17))) - e.append(m2_expr.ExprAff(vm, m2_expr.ExprSlice(tmp, 17, 18))) - e.append(m2_expr.ExprAff(ac, m2_expr.ExprSlice(tmp, 18, 19))) - e.append(m2_expr.ExprAff(vif, m2_expr.ExprSlice(tmp, 19, 20))) - e.append(m2_expr.ExprAff(vip, m2_expr.ExprSlice(tmp, 20, 21))) - e.append(m2_expr.ExprAff(i_d, m2_expr.ExprSlice(tmp, 21, 22))) - e.append(m2_expr.ExprAff(mRSP[instr.mode], + e.append(m2_expr.ExprAssign(cf, m2_expr.ExprSlice(tmp, 0, 1))) + e.append(m2_expr.ExprAssign(pf, m2_expr.ExprSlice(tmp, 2, 3))) + e.append(m2_expr.ExprAssign(af, m2_expr.ExprSlice(tmp, 4, 5))) + e.append(m2_expr.ExprAssign(zf, m2_expr.ExprSlice(tmp, 6, 7))) + e.append(m2_expr.ExprAssign(nf, m2_expr.ExprSlice(tmp, 7, 8))) + e.append(m2_expr.ExprAssign(tf, m2_expr.ExprSlice(tmp, 8, 9))) + e.append(m2_expr.ExprAssign(i_f, m2_expr.ExprSlice(tmp, 9, 10))) + e.append(m2_expr.ExprAssign(df, m2_expr.ExprSlice(tmp, 10, 11))) + e.append(m2_expr.ExprAssign(of, m2_expr.ExprSlice(tmp, 11, 12))) + e.append(m2_expr.ExprAssign(iopl, m2_expr.ExprSlice(tmp, 12, 14))) + e.append(m2_expr.ExprAssign(nt, m2_expr.ExprSlice(tmp, 14, 15))) + e.append(m2_expr.ExprAssign(rf, m2_expr.ExprSlice(tmp, 16, 17))) + e.append(m2_expr.ExprAssign(vm, m2_expr.ExprSlice(tmp, 17, 18))) + e.append(m2_expr.ExprAssign(ac, m2_expr.ExprSlice(tmp, 18, 19))) + e.append(m2_expr.ExprAssign(vif, m2_expr.ExprSlice(tmp, 19, 20))) + e.append(m2_expr.ExprAssign(vip, m2_expr.ExprSlice(tmp, 20, 21))) + e.append(m2_expr.ExprAssign(i_d, m2_expr.ExprSlice(tmp, 21, 22))) + e.append(m2_expr.ExprAssign(mRSP[instr.mode], mRSP[instr.mode] + m2_expr.ExprInt(instr.mode / 8, mRSP[instr.mode].size))) - e.append(m2_expr.ExprAff(exception_flags, + e.append(m2_expr.ExprAssign(exception_flags, m2_expr.ExprCond(m2_expr.ExprSlice(tmp, 8, 9), m2_expr.ExprInt( EXCEPT_SOFT_BP, 32), @@ -1318,7 +1318,7 @@ def _tpl_eflags(tmp): """Extract eflags from @tmp @tmp: Expr instance with a size >= 16 """ - return [m2_expr.ExprAff(dest, tmp[base:base + dest.size]) + return [m2_expr.ExprAssign(dest, tmp[base:base + dest.size]) for base, dest in ((0, cf), (2, pf), (4, af), (6, zf), (7, nf), (8, tf), (9, i_f), (10, df), (11, of), (12, iopl), (14, nt))] @@ -1328,7 +1328,7 @@ def popfw(ir, instr): tmp = ir.ExprMem(mRSP[instr.mode], 32) e = _tpl_eflags(tmp) e.append( - m2_expr.ExprAff(mRSP[instr.mode], mRSP[instr.mode] + m2_expr.ExprInt(2, mRSP[instr.mode].size))) + m2_expr.ExprAssign(mRSP[instr.mode], mRSP[instr.mode] + m2_expr.ExprInt(2, mRSP[instr.mode].size))) return e, [] pa_regs = [ @@ -1344,8 +1344,8 @@ def pusha_gen(ir, instr, size): cur_sp = mRSP[instr.mode] for i, reg in enumerate(pa_regs): stk_ptr = cur_sp + m2_expr.ExprInt(-(size / 8) * (i + 1), instr.mode) - e.append(m2_expr.ExprAff(ir.ExprMem(stk_ptr, size), reg[size])) - e.append(m2_expr.ExprAff(cur_sp, stk_ptr)) + e.append(m2_expr.ExprAssign(ir.ExprMem(stk_ptr, size), reg[size])) + e.append(m2_expr.ExprAssign(cur_sp, stk_ptr)) return e, [] @@ -1364,10 +1364,10 @@ def popa_gen(ir, instr, size): if reg == mRSP: continue stk_ptr = cur_sp + m2_expr.ExprInt((size / 8) * i, instr.mode) - e.append(m2_expr.ExprAff(reg[size], ir.ExprMem(stk_ptr, size))) + e.append(m2_expr.ExprAssign(reg[size], ir.ExprMem(stk_ptr, size))) stk_ptr = cur_sp + m2_expr.ExprInt((size / 8) * (i + 1), instr.mode) - e.append(m2_expr.ExprAff(cur_sp, stk_ptr)) + e.append(m2_expr.ExprAssign(cur_sp, stk_ptr)) return e, [] @@ -1406,31 +1406,31 @@ def call(ir, instr, dst): else: raise RuntimeError("bad call operator") - e.append(m2_expr.ExprAff(CS, m1)) - e.append(m2_expr.ExprAff(meip, m2)) + e.append(m2_expr.ExprAssign(CS, m1)) + e.append(m2_expr.ExprAssign(meip, m2)) - e.append(m2_expr.ExprAff(ir.IRDst, m2)) + e.append(m2_expr.ExprAssign(ir.IRDst, m2)) c = myesp + m2_expr.ExprInt(-s / 8, s) - e.append(m2_expr.ExprAff(ir.ExprMem(c, size=s).zeroExtend(s), + e.append(m2_expr.ExprAssign(ir.ExprMem(c, size=s).zeroExtend(s), CS.zeroExtend(s))) c = myesp + m2_expr.ExprInt(-2 * s / 8, s) - e.append(m2_expr.ExprAff(ir.ExprMem(c, size=s).zeroExtend(s), + e.append(m2_expr.ExprAssign(ir.ExprMem(c, size=s).zeroExtend(s), meip.zeroExtend(s))) c = myesp + m2_expr.ExprInt((-2 * s) / 8, s) - e.append(m2_expr.ExprAff(myesp, c)) + e.append(m2_expr.ExprAssign(myesp, c)) return e, [] c = myesp + m2_expr.ExprInt((-s / 8), s) - e.append(m2_expr.ExprAff(myesp, c)) + e.append(m2_expr.ExprAssign(myesp, c)) if ir.do_stk_segm: c = ir.gen_segm_expr(SS, c) - e.append(m2_expr.ExprAff(ir.ExprMem(c, size=s), n)) - e.append(m2_expr.ExprAff(meip, dst.zeroExtend(ir.IRDst.size))) - e.append(m2_expr.ExprAff(ir.IRDst, dst.zeroExtend(ir.IRDst.size))) + e.append(m2_expr.ExprAssign(ir.ExprMem(c, size=s), n)) + e.append(m2_expr.ExprAssign(meip, dst.zeroExtend(ir.IRDst.size))) + e.append(m2_expr.ExprAssign(ir.IRDst, dst.zeroExtend(ir.IRDst.size))) return e, [] @@ -1446,14 +1446,14 @@ def ret(ir, instr, src=None): src = m2_expr.ExprInt(int(src), size) value = (myesp + (m2_expr.ExprInt((size / 8), size) + src)) - e.append(m2_expr.ExprAff(myesp, value)) + e.append(m2_expr.ExprAssign(myesp, value)) result = myesp if ir.do_stk_segm: result = ir.gen_segm_expr(SS, result) - e.append(m2_expr.ExprAff(meip, ir.ExprMem( + e.append(m2_expr.ExprAssign(meip, ir.ExprMem( result, size=size).zeroExtend(size))) - e.append(m2_expr.ExprAff(ir.IRDst, + e.append(m2_expr.ExprAssign(ir.IRDst, ir.ExprMem(result, size=size).zeroExtend(size))) return e, [] @@ -1472,19 +1472,19 @@ def retf(ir, instr, src=None): if ir.do_stk_segm: result = ir.gen_segm_expr(SS, result) - e.append(m2_expr.ExprAff(meip, ir.ExprMem( + e.append(m2_expr.ExprAssign(meip, ir.ExprMem( result, size=size).zeroExtend(size))) - e.append(m2_expr.ExprAff(ir.IRDst, + e.append(m2_expr.ExprAssign(ir.IRDst, ir.ExprMem(result, size=size).zeroExtend(size))) - # e.append(m2_expr.ExprAff(meip, ir.ExprMem(c, size = s))) + # e.append(m2_expr.ExprAssign(meip, ir.ExprMem(c, size = s))) result = myesp + m2_expr.ExprInt(size / 8, size) if ir.do_stk_segm: result = ir.gen_segm_expr(SS, result) - e.append(m2_expr.ExprAff(CS, ir.ExprMem(result, size=16))) + e.append(m2_expr.ExprAssign(CS, ir.ExprMem(result, size=16))) value = myesp + (m2_expr.ExprInt((2 * size) / 8, size) + src) - e.append(m2_expr.ExprAff(myesp, value)) + e.append(m2_expr.ExprAssign(myesp, value)) return e, [] @@ -1492,8 +1492,8 @@ def leave(ir, instr): size = instr.mode myesp = mRSP[size] e = [] - e.append(m2_expr.ExprAff(mRBP[size], ir.ExprMem(mRBP[size], size=size))) - e.append(m2_expr.ExprAff(myesp, + e.append(m2_expr.ExprAssign(mRBP[size], ir.ExprMem(mRBP[size], size=size))) + e.append(m2_expr.ExprAssign(myesp, m2_expr.ExprInt(size / 8, size) + mRBP[size])) return e, [] @@ -1507,10 +1507,10 @@ def enter(ir, instr, src1, src2): e = [] esp_tmp = myesp - m2_expr.ExprInt(size / 8, size) - e.append(m2_expr.ExprAff(ir.ExprMem(esp_tmp, size=size), + e.append(m2_expr.ExprAssign(ir.ExprMem(esp_tmp, size=size), myebp)) - e.append(m2_expr.ExprAff(myebp, esp_tmp)) - e.append(m2_expr.ExprAff(myesp, + e.append(m2_expr.ExprAssign(myebp, esp_tmp)) + e.append(m2_expr.ExprAssign(myesp, myesp - (src1 + m2_expr.ExprInt(size / 8, size)))) return e, [] @@ -1534,14 +1534,14 @@ def jmp(ir, instr, dst): else: raise RuntimeError("bad jmp operator") - e.append(m2_expr.ExprAff(CS, m1)) - e.append(m2_expr.ExprAff(meip, m2)) - e.append(m2_expr.ExprAff(ir.IRDst, m2)) + e.append(m2_expr.ExprAssign(CS, m1)) + e.append(m2_expr.ExprAssign(meip, m2)) + e.append(m2_expr.ExprAssign(ir.IRDst, m2)) else: # Classic jmp - e.append(m2_expr.ExprAff(meip, dst)) - e.append(m2_expr.ExprAff(ir.IRDst, dst)) + e.append(m2_expr.ExprAssign(meip, dst)) + e.append(m2_expr.ExprAssign(ir.IRDst, dst)) if isinstance(dst, m2_expr.ExprMem): dst = meip @@ -1650,9 +1650,9 @@ def loop(ir, instr, dst): dst_o = m2_expr.ExprCond(c, dst.zeroExtend(ir.IRDst.size), n.zeroExtend(ir.IRDst.size)) - e.append(m2_expr.ExprAff(myecx, c)) - e.append(m2_expr.ExprAff(meip, dst_o)) - e.append(m2_expr.ExprAff(ir.IRDst, dst_o)) + e.append(m2_expr.ExprAssign(myecx, c)) + e.append(m2_expr.ExprAssign(meip, dst_o)) + e.append(m2_expr.ExprAssign(ir.IRDst, dst_o)) return e, [] @@ -1669,12 +1669,12 @@ def loopne(ir, instr, dst): m2_expr.ExprInt(0, 1)) c &= zf ^ m2_expr.ExprInt(1, 1) - e.append(m2_expr.ExprAff(myecx, myecx - m2_expr.ExprInt(1, myecx.size))) + e.append(m2_expr.ExprAssign(myecx, myecx - m2_expr.ExprInt(1, myecx.size))) dst_o = m2_expr.ExprCond(c, dst.zeroExtend(ir.IRDst.size), n.zeroExtend(ir.IRDst.size)) - e.append(m2_expr.ExprAff(meip, dst_o)) - e.append(m2_expr.ExprAff(ir.IRDst, dst_o)) + e.append(m2_expr.ExprAssign(meip, dst_o)) + e.append(m2_expr.ExprAssign(ir.IRDst, dst_o)) return e, [] @@ -1689,12 +1689,12 @@ def loope(ir, instr, dst): m2_expr.ExprInt(1, 1), m2_expr.ExprInt(0, 1)) c &= zf - e.append(m2_expr.ExprAff(myecx, myecx - m2_expr.ExprInt(1, myecx.size))) + e.append(m2_expr.ExprAssign(myecx, myecx - m2_expr.ExprInt(1, myecx.size))) dst_o = m2_expr.ExprCond(c, dst.zeroExtend(ir.IRDst.size), n.zeroExtend(ir.IRDst.size)) - e.append(m2_expr.ExprAff(meip, dst_o)) - e.append(m2_expr.ExprAff(ir.IRDst, dst_o)) + e.append(m2_expr.ExprAssign(meip, dst_o)) + e.append(m2_expr.ExprAssign(ir.IRDst, dst_o)) return e, [] # XXX size to do; eflag @@ -1716,10 +1716,10 @@ def div(ir, instr, src1): # if 8 bit div, only ax is affected if size == 8: - e.append(m2_expr.ExprAff(src2, m2_expr.ExprCompose(c_d[:8], c_r[:8]))) + e.append(m2_expr.ExprAssign(src2, m2_expr.ExprCompose(c_d[:8], c_r[:8]))) else: - e.append(m2_expr.ExprAff(s1, c_r[:size])) - e.append(m2_expr.ExprAff(s2, c_d[:size])) + e.append(m2_expr.ExprAssign(s1, c_r[:size])) + e.append(m2_expr.ExprAssign(s2, c_d[:size])) loc_div, loc_div_expr = ir.gen_loc_key_and_expr(ir.IRDst.size) loc_except, loc_except_expr = ir.gen_loc_key_and_expr(ir.IRDst.size) @@ -1728,17 +1728,17 @@ def div(ir, instr, src1): do_div = [] do_div += e - do_div.append(m2_expr.ExprAff(ir.IRDst, loc_next_expr)) + do_div.append(m2_expr.ExprAssign(ir.IRDst, loc_next_expr)) blk_div = IRBlock(loc_div, [AssignBlock(do_div, instr)]) do_except = [] - do_except.append(m2_expr.ExprAff(exception_flags, m2_expr.ExprInt( + do_except.append(m2_expr.ExprAssign(exception_flags, m2_expr.ExprInt( EXCEPT_DIV_BY_ZERO, exception_flags.size))) - do_except.append(m2_expr.ExprAff(ir.IRDst, loc_next_expr)) + do_except.append(m2_expr.ExprAssign(ir.IRDst, loc_next_expr)) blk_except = IRBlock(loc_except, [AssignBlock(do_except, instr)]) e = [] - e.append(m2_expr.ExprAff(ir.IRDst, + e.append(m2_expr.ExprAssign(ir.IRDst, m2_expr.ExprCond(src1, loc_div_expr, loc_except_expr))) return e, [blk_div, blk_except] @@ -1763,10 +1763,10 @@ def idiv(ir, instr, src1): # if 8 bit div, only ax is affected if size == 8: - e.append(m2_expr.ExprAff(src2, m2_expr.ExprCompose(c_d[:8], c_r[:8]))) + e.append(m2_expr.ExprAssign(src2, m2_expr.ExprCompose(c_d[:8], c_r[:8]))) else: - e.append(m2_expr.ExprAff(s1, c_r[:size])) - e.append(m2_expr.ExprAff(s2, c_d[:size])) + e.append(m2_expr.ExprAssign(s1, c_r[:size])) + e.append(m2_expr.ExprAssign(s2, c_d[:size])) loc_div, loc_div_expr = ir.gen_loc_key_and_expr(ir.IRDst.size) loc_except, loc_except_expr = ir.gen_loc_key_and_expr(ir.IRDst.size) @@ -1775,17 +1775,17 @@ def idiv(ir, instr, src1): do_div = [] do_div += e - do_div.append(m2_expr.ExprAff(ir.IRDst, loc_next_expr)) + do_div.append(m2_expr.ExprAssign(ir.IRDst, loc_next_expr)) blk_div = IRBlock(loc_div, [AssignBlock(do_div, instr)]) do_except = [] - do_except.append(m2_expr.ExprAff(exception_flags, m2_expr.ExprInt( + do_except.append(m2_expr.ExprAssign(exception_flags, m2_expr.ExprInt( EXCEPT_DIV_BY_ZERO, exception_flags.size))) - do_except.append(m2_expr.ExprAff(ir.IRDst, loc_next_expr)) + do_except.append(m2_expr.ExprAssign(ir.IRDst, loc_next_expr)) blk_except = IRBlock(loc_except, [AssignBlock(do_except, instr)]) e = [] - e.append(m2_expr.ExprAff(ir.IRDst, + e.append(m2_expr.ExprAssign(ir.IRDst, m2_expr.ExprCond(src1, loc_div_expr, loc_except_expr))) return e, [blk_div, blk_except] @@ -1801,21 +1801,21 @@ def mul(_, instr, src1): result = m2_expr.ExprOp('*', mRAX[size].zeroExtend(size * 2), src1.zeroExtend(size * 2)) - e.append(m2_expr.ExprAff(mRAX[size], result[:size])) - e.append(m2_expr.ExprAff(mRDX[size], result[size:size * 2])) + e.append(m2_expr.ExprAssign(mRAX[size], result[:size])) + e.append(m2_expr.ExprAssign(mRDX[size], result[size:size * 2])) elif src1.size == 8: result = m2_expr.ExprOp('*', mRAX[instr.mode][:8].zeroExtend(16), src1.zeroExtend(16)) - e.append(m2_expr.ExprAff(mRAX[instr.mode][:16], result)) + e.append(m2_expr.ExprAssign(mRAX[instr.mode][:16], result)) else: raise ValueError('unknow size') - e.append(m2_expr.ExprAff(of, m2_expr.ExprCond(result[size:size * 2], + e.append(m2_expr.ExprAssign(of, m2_expr.ExprCond(result[size:size * 2], m2_expr.ExprInt(1, 1), m2_expr.ExprInt(0, 1)))) - e.append(m2_expr.ExprAff(cf, m2_expr.ExprCond(result[size:size * 2], + e.append(m2_expr.ExprAssign(cf, m2_expr.ExprCond(result[size:size * 2], m2_expr.ExprInt(1, 1), m2_expr.ExprInt(0, 1)))) @@ -1830,23 +1830,23 @@ def imul(_, instr, src1, src2=None, src3=None): result = m2_expr.ExprOp('*', mRAX[size].signExtend(size * 2), src1.signExtend(size * 2)) - e.append(m2_expr.ExprAff(mRAX[size], result[:size])) - e.append(m2_expr.ExprAff(mRDX[size], result[size:size * 2])) + e.append(m2_expr.ExprAssign(mRAX[size], result[:size])) + e.append(m2_expr.ExprAssign(mRDX[size], result[size:size * 2])) elif size == 8: dst = mRAX[instr.mode][:16] result = m2_expr.ExprOp('*', mRAX[instr.mode][:8].signExtend(16), src1.signExtend(16)) - e.append(m2_expr.ExprAff(dst, result)) + e.append(m2_expr.ExprAssign(dst, result)) value = m2_expr.ExprCond(result - result[:size].signExtend(size * 2), m2_expr.ExprInt(1, 1), m2_expr.ExprInt(0, 1)) - e.append(m2_expr.ExprAff(cf, value)) + e.append(m2_expr.ExprAssign(cf, value)) value = m2_expr.ExprCond(result - result[:size].signExtend(size * 2), m2_expr.ExprInt(1, 1), m2_expr.ExprInt(0, 1)) - e.append(m2_expr.ExprAff(of, value)) + e.append(m2_expr.ExprAssign(of, value)) else: if src3 is None: @@ -1855,16 +1855,16 @@ def imul(_, instr, src1, src2=None, src3=None): result = m2_expr.ExprOp('*', src2.signExtend(size * 2), src3.signExtend(size * 2)) - e.append(m2_expr.ExprAff(src1, result[:size])) + e.append(m2_expr.ExprAssign(src1, result[:size])) value = m2_expr.ExprCond(result - result[:size].signExtend(size * 2), m2_expr.ExprInt(1, 1), m2_expr.ExprInt(0, 1)) - e.append(m2_expr.ExprAff(cf, value)) + e.append(m2_expr.ExprAssign(cf, value)) value = m2_expr.ExprCond(result - result[:size].signExtend(size * 2), m2_expr.ExprInt(1, 1), m2_expr.ExprInt(0, 1)) - e.append(m2_expr.ExprAff(of, value)) + e.append(m2_expr.ExprAssign(of, value)) return e, [] @@ -1873,7 +1873,7 @@ def cbw(_, instr): e = [] tempAL = mRAX[instr.v_opmode()][:8] tempAX = mRAX[instr.v_opmode()][:16] - e.append(m2_expr.ExprAff(tempAX, tempAL.signExtend(16))) + e.append(m2_expr.ExprAssign(tempAX, tempAL.signExtend(16))) return e, [] @@ -1882,7 +1882,7 @@ def cwde(_, instr): e = [] tempAX = mRAX[instr.v_opmode()][:16] tempEAX = mRAX[instr.v_opmode()][:32] - e.append(m2_expr.ExprAff(tempEAX, tempAX.signExtend(32))) + e.append(m2_expr.ExprAssign(tempEAX, tempAX.signExtend(32))) return e, [] @@ -1891,7 +1891,7 @@ def cdqe(_, instr): e = [] tempEAX = mRAX[instr.mode][:32] tempRAX = mRAX[instr.mode][:64] - e.append(m2_expr.ExprAff(tempRAX, tempEAX.signExtend(64))) + e.append(m2_expr.ExprAssign(tempRAX, tempEAX.signExtend(64))) return e, [] @@ -1901,8 +1901,8 @@ def cwd(_, instr): tempAX = mRAX[instr.mode][:16] tempDX = mRDX[instr.mode][:16] result = tempAX.signExtend(32) - e.append(m2_expr.ExprAff(tempAX, result[:16])) - e.append(m2_expr.ExprAff(tempDX, result[16:32])) + e.append(m2_expr.ExprAssign(tempAX, result[:16])) + e.append(m2_expr.ExprAssign(tempDX, result[16:32])) return e, [] @@ -1912,7 +1912,7 @@ def cdq(_, instr): tempEAX = mRAX[instr.v_opmode()] tempEDX = mRDX[instr.v_opmode()] result = tempEAX.signExtend(64) - e.append(m2_expr.ExprAff(tempEDX, result[32:64])) + e.append(m2_expr.ExprAssign(tempEDX, result[32:64])) return e, [] @@ -1922,8 +1922,8 @@ def cqo(_, instr): tempRAX = mRAX[instr.mode][:64] tempRDX = mRDX[instr.mode][:64] result = tempRAX.signExtend(128) - e.append(m2_expr.ExprAff(tempRAX, result[:64])) - e.append(m2_expr.ExprAff(tempRDX, result[64:128])) + e.append(m2_expr.ExprAssign(tempRAX, result[:64])) + e.append(m2_expr.ExprAssign(tempRDX, result[64:128])) return e, [] @@ -1946,18 +1946,18 @@ def stos(ir, instr, size): b = mRAX[instr.mode][:size] e0 = [] - e0.append(m2_expr.ExprAff(addr_o, addr_p)) - e0.append(m2_expr.ExprAff(ir.IRDst, loc_next_expr)) + e0.append(m2_expr.ExprAssign(addr_o, addr_p)) + e0.append(m2_expr.ExprAssign(ir.IRDst, loc_next_expr)) e0 = IRBlock(loc_df_0, [AssignBlock(e0, instr)]) e1 = [] - e1.append(m2_expr.ExprAff(addr_o, addr_m)) - e1.append(m2_expr.ExprAff(ir.IRDst, loc_next_expr)) + e1.append(m2_expr.ExprAssign(addr_o, addr_m)) + e1.append(m2_expr.ExprAssign(ir.IRDst, loc_next_expr)) e1 = IRBlock(loc_df_1, [AssignBlock(e1, instr)]) e = [] - e.append(m2_expr.ExprAff(ir.ExprMem(addr, size), b)) - e.append(m2_expr.ExprAff(ir.IRDst, + e.append(m2_expr.ExprAssign(ir.ExprMem(addr, size), b)) + e.append(m2_expr.ExprAssign(ir.IRDst, m2_expr.ExprCond(df, loc_df_1_expr, loc_df_0_expr))) return e, [e0, e1] @@ -1982,23 +1982,23 @@ def lods(ir, instr, size): b = mRAX[instr.mode][:size] e0 = [] - e0.append(m2_expr.ExprAff(addr_o, addr_p)) - e0.append(m2_expr.ExprAff(ir.IRDst, loc_next_expr)) + e0.append(m2_expr.ExprAssign(addr_o, addr_p)) + e0.append(m2_expr.ExprAssign(ir.IRDst, loc_next_expr)) e0 = IRBlock(loc_df_0, [AssignBlock(e0, instr)]) e1 = [] - e1.append(m2_expr.ExprAff(addr_o, addr_m)) - e1.append(m2_expr.ExprAff(ir.IRDst, loc_next_expr)) + e1.append(m2_expr.ExprAssign(addr_o, addr_m)) + e1.append(m2_expr.ExprAssign(ir.IRDst, loc_next_expr)) e1 = IRBlock(loc_df_1, [AssignBlock(e1, instr)]) e = [] if instr.mode == 64 and b.size == 32: - e.append(m2_expr.ExprAff(mRAX[instr.mode], + e.append(m2_expr.ExprAssign(mRAX[instr.mode], ir.ExprMem(addr, size).zeroExtend(64))) else: - e.append(m2_expr.ExprAff(b, ir.ExprMem(addr, size))) + e.append(m2_expr.ExprAssign(b, ir.ExprMem(addr, size))) - e.append(m2_expr.ExprAff(ir.IRDst, + e.append(m2_expr.ExprAssign(ir.IRDst, m2_expr.ExprCond(df, loc_df_1_expr, loc_df_0_expr))) return e, [e0, e1] @@ -2024,22 +2024,22 @@ def movs(ir, instr, size): offset = m2_expr.ExprInt(size / 8, src.size) - e.append(m2_expr.ExprAff(ir.ExprMem(dst_sgm, size), + e.append(m2_expr.ExprAssign(ir.ExprMem(dst_sgm, size), ir.ExprMem(src_sgm, size))) e0 = [] - e0.append(m2_expr.ExprAff(src, src + offset)) - e0.append(m2_expr.ExprAff(dst, dst + offset)) - e0.append(m2_expr.ExprAff(ir.IRDst, loc_next_expr)) + e0.append(m2_expr.ExprAssign(src, src + offset)) + e0.append(m2_expr.ExprAssign(dst, dst + offset)) + e0.append(m2_expr.ExprAssign(ir.IRDst, loc_next_expr)) e0 = IRBlock(loc_df_0, [AssignBlock(e0, instr)]) e1 = [] - e1.append(m2_expr.ExprAff(src, src - offset)) - e1.append(m2_expr.ExprAff(dst, dst - offset)) - e1.append(m2_expr.ExprAff(ir.IRDst, loc_next_expr)) + e1.append(m2_expr.ExprAssign(src, src - offset)) + e1.append(m2_expr.ExprAssign(dst, dst - offset)) + e1.append(m2_expr.ExprAssign(ir.IRDst, loc_next_expr)) e1 = IRBlock(loc_df_1, [AssignBlock(e1, instr)]) - e.append(m2_expr.ExprAff(ir.IRDst, + e.append(m2_expr.ExprAssign(ir.IRDst, m2_expr.ExprCond(df, loc_df_1_expr, loc_df_0_expr))) return e, [e0, e1] @@ -2056,7 +2056,7 @@ def movsd(_, instr, dst, src): src = m2_expr.ExprMem(src.arg, 64) # Erase dst high bits src = src.zeroExtend(dst.size) - return [m2_expr.ExprAff(dst, src)], [] + return [m2_expr.ExprAssign(dst, src)], [] def movsd_dispatch(ir, instr, dst=None, src=None): @@ -2087,14 +2087,14 @@ def float_pop(avoid_flt=None, popcount=1): e = [] for i in xrange(8 - popcount): if avoid_flt != float_list[i]: - e.append(m2_expr.ExprAff(float_list[i], + e.append(m2_expr.ExprAssign(float_list[i], float_list[i + popcount])) fill_value = m2_expr.ExprOp("sint_to_fp", m2_expr.ExprInt(0, 64)) for i in xrange(8 - popcount, 8): - e.append(m2_expr.ExprAff(float_list[i], + e.append(m2_expr.ExprAssign(float_list[i], fill_value)) e.append( - m2_expr.ExprAff(float_stack_ptr, + m2_expr.ExprAssign(float_stack_ptr, float_stack_ptr - m2_expr.ExprInt(popcount, 3))) return e @@ -2111,10 +2111,10 @@ def fcom(_, instr, dst=None, src=None): e = [] - e.append(m2_expr.ExprAff(float_c0, m2_expr.ExprOp('fcom_c0', dst, src))) - e.append(m2_expr.ExprAff(float_c1, m2_expr.ExprOp('fcom_c1', dst, src))) - e.append(m2_expr.ExprAff(float_c2, m2_expr.ExprOp('fcom_c2', dst, src))) - e.append(m2_expr.ExprAff(float_c3, m2_expr.ExprOp('fcom_c3', dst, src))) + e.append(m2_expr.ExprAssign(float_c0, m2_expr.ExprOp('fcom_c0', dst, src))) + e.append(m2_expr.ExprAssign(float_c1, m2_expr.ExprOp('fcom_c1', dst, src))) + e.append(m2_expr.ExprAssign(float_c2, m2_expr.ExprOp('fcom_c2', dst, src))) + e.append(m2_expr.ExprAssign(float_c3, m2_expr.ExprOp('fcom_c3', dst, src))) e += set_float_cs_eip(instr) return e, [] @@ -2125,10 +2125,10 @@ def ftst(_, instr): e = [] src = m2_expr.ExprOp('sint_to_fp', m2_expr.ExprInt(0, 64)) - e.append(m2_expr.ExprAff(float_c0, m2_expr.ExprOp('fcom_c0', dst, src))) - e.append(m2_expr.ExprAff(float_c1, m2_expr.ExprOp('fcom_c1', dst, src))) - e.append(m2_expr.ExprAff(float_c2, m2_expr.ExprOp('fcom_c2', dst, src))) - e.append(m2_expr.ExprAff(float_c3, m2_expr.ExprOp('fcom_c3', dst, src))) + e.append(m2_expr.ExprAssign(float_c0, m2_expr.ExprOp('fcom_c0', dst, src))) + e.append(m2_expr.ExprAssign(float_c1, m2_expr.ExprOp('fcom_c1', dst, src))) + e.append(m2_expr.ExprAssign(float_c2, m2_expr.ExprOp('fcom_c2', dst, src))) + e.append(m2_expr.ExprAssign(float_c3, m2_expr.ExprOp('fcom_c3', dst, src))) e += set_float_cs_eip(instr) return e, [] @@ -2188,8 +2188,8 @@ def fxam(ir, instr): ) ) ) - base = [m2_expr.ExprAff(ir.IRDst, irdst), - m2_expr.ExprAff(float_c1, dst.msb()) + base = [m2_expr.ExprAssign(ir.IRDst, irdst), + m2_expr.ExprAssign(float_c1, dst.msb()) ] base += set_float_cs_eip(instr) @@ -2234,16 +2234,16 @@ def ficom(_, instr, dst, src=None): e = [] - e.append(m2_expr.ExprAff(float_c0, + e.append(m2_expr.ExprAssign(float_c0, m2_expr.ExprOp('fcom_c0', dst, src.zeroExtend(dst.size)))) - e.append(m2_expr.ExprAff(float_c1, + e.append(m2_expr.ExprAssign(float_c1, m2_expr.ExprOp('fcom_c1', dst, src.zeroExtend(dst.size)))) - e.append(m2_expr.ExprAff(float_c2, + e.append(m2_expr.ExprAssign(float_c2, m2_expr.ExprOp('fcom_c2', dst, src.zeroExtend(dst.size)))) - e.append(m2_expr.ExprAff(float_c3, + e.append(m2_expr.ExprAssign(float_c3, m2_expr.ExprOp('fcom_c3', dst, src.zeroExtend(dst.size)))) @@ -2261,13 +2261,13 @@ def fcomi(_, instr, dst=None, src=None): e = [] - e.append(m2_expr.ExprAff(cf, m2_expr.ExprOp('fcom_c0', dst, src))) - e.append(m2_expr.ExprAff(pf, m2_expr.ExprOp('fcom_c2', dst, src))) - e.append(m2_expr.ExprAff(zf, m2_expr.ExprOp('fcom_c3', dst, src))) + e.append(m2_expr.ExprAssign(cf, m2_expr.ExprOp('fcom_c0', dst, src))) + e.append(m2_expr.ExprAssign(pf, m2_expr.ExprOp('fcom_c2', dst, src))) + e.append(m2_expr.ExprAssign(zf, m2_expr.ExprOp('fcom_c3', dst, src))) - e.append(m2_expr.ExprAff(of, m2_expr.ExprInt(0, 1))) - e.append(m2_expr.ExprAff(nf, m2_expr.ExprInt(0, 1))) - e.append(m2_expr.ExprAff(af, m2_expr.ExprInt(0, 1))) + e.append(m2_expr.ExprAssign(of, m2_expr.ExprInt(0, 1))) + e.append(m2_expr.ExprAssign(nf, m2_expr.ExprInt(0, 1))) + e.append(m2_expr.ExprAssign(af, m2_expr.ExprInt(0, 1))) e += set_float_cs_eip(instr) return e, [] @@ -2334,13 +2334,13 @@ def comiss(_, instr, dst, src): dst = m2_expr.ExprOp('sint_to_fp', dst[:32]) src = m2_expr.ExprOp('sint_to_fp', src[:32]) - e.append(m2_expr.ExprAff(cf, m2_expr.ExprOp('fcom_c0', dst, src))) - e.append(m2_expr.ExprAff(pf, m2_expr.ExprOp('fcom_c2', dst, src))) - e.append(m2_expr.ExprAff(zf, m2_expr.ExprOp('fcom_c3', dst, src))) + e.append(m2_expr.ExprAssign(cf, m2_expr.ExprOp('fcom_c0', dst, src))) + e.append(m2_expr.ExprAssign(pf, m2_expr.ExprOp('fcom_c2', dst, src))) + e.append(m2_expr.ExprAssign(zf, m2_expr.ExprOp('fcom_c3', dst, src))) - e.append(m2_expr.ExprAff(of, m2_expr.ExprInt(0, 1))) - e.append(m2_expr.ExprAff(nf, m2_expr.ExprInt(0, 1))) - e.append(m2_expr.ExprAff(af, m2_expr.ExprInt(0, 1))) + e.append(m2_expr.ExprAssign(of, m2_expr.ExprInt(0, 1))) + e.append(m2_expr.ExprAssign(nf, m2_expr.ExprInt(0, 1))) + e.append(m2_expr.ExprAssign(af, m2_expr.ExprInt(0, 1))) e += set_float_cs_eip(instr) return e, [] @@ -2354,13 +2354,13 @@ def comisd(_, instr, dst, src): dst = m2_expr.ExprOp('sint_to_fp', dst[:64]) src = m2_expr.ExprOp('sint_to_fp', src[:64]) - e.append(m2_expr.ExprAff(cf, m2_expr.ExprOp('fcom_c0', dst, src))) - e.append(m2_expr.ExprAff(pf, m2_expr.ExprOp('fcom_c2', dst, src))) - e.append(m2_expr.ExprAff(zf, m2_expr.ExprOp('fcom_c3', dst, src))) + e.append(m2_expr.ExprAssign(cf, m2_expr.ExprOp('fcom_c0', dst, src))) + e.append(m2_expr.ExprAssign(pf, m2_expr.ExprOp('fcom_c2', dst, src))) + e.append(m2_expr.ExprAssign(zf, m2_expr.ExprOp('fcom_c3', dst, src))) - e.append(m2_expr.ExprAff(of, m2_expr.ExprInt(0, 1))) - e.append(m2_expr.ExprAff(nf, m2_expr.ExprInt(0, 1))) - e.append(m2_expr.ExprAff(af, m2_expr.ExprInt(0, 1))) + e.append(m2_expr.ExprAssign(of, m2_expr.ExprInt(0, 1))) + e.append(m2_expr.ExprAssign(nf, m2_expr.ExprInt(0, 1))) + e.append(m2_expr.ExprAssign(af, m2_expr.ExprInt(0, 1))) e += set_float_cs_eip(instr) return e, [] @@ -2374,16 +2374,16 @@ def fld(_, instr, src): raise NotImplementedError('convert from 80bits') e = [] - e.append(m2_expr.ExprAff(float_st7, float_st6)) - e.append(m2_expr.ExprAff(float_st6, float_st5)) - e.append(m2_expr.ExprAff(float_st5, float_st4)) - e.append(m2_expr.ExprAff(float_st4, float_st3)) - e.append(m2_expr.ExprAff(float_st3, float_st2)) - e.append(m2_expr.ExprAff(float_st2, float_st1)) - e.append(m2_expr.ExprAff(float_st1, float_st0)) - e.append(m2_expr.ExprAff(float_st0, src)) + e.append(m2_expr.ExprAssign(float_st7, float_st6)) + e.append(m2_expr.ExprAssign(float_st6, float_st5)) + e.append(m2_expr.ExprAssign(float_st5, float_st4)) + e.append(m2_expr.ExprAssign(float_st4, float_st3)) + e.append(m2_expr.ExprAssign(float_st3, float_st2)) + e.append(m2_expr.ExprAssign(float_st2, float_st1)) + e.append(m2_expr.ExprAssign(float_st1, float_st0)) + e.append(m2_expr.ExprAssign(float_st0, src)) e.append( - m2_expr.ExprAff(float_stack_ptr, + m2_expr.ExprAssign(float_stack_ptr, float_stack_ptr + m2_expr.ExprInt(1, 3))) e += set_float_cs_eip(instr) @@ -2399,7 +2399,7 @@ def fst(_, instr, dst): if dst.size == 32: src = m2_expr.ExprOp("fpconvert_fp32", src) - e.append(m2_expr.ExprAff(dst, src)) + e.append(m2_expr.ExprAssign(dst, src)) e += set_float_cs_eip(instr) return e, [] @@ -2414,13 +2414,13 @@ def fstp(ir, instr, dst): src = float_st0 if dst.size == 32: src = m2_expr.ExprOp("fpconvert_fp32", src) - e.append(m2_expr.ExprAff(dst, src)) + e.append(m2_expr.ExprAssign(dst, src)) else: src = float_st0 if float_list.index(dst) > 1: # a = st0 -> st0 is dropped # a = st1 -> st0 = st0, useless - e.append(m2_expr.ExprAff(float_prev(dst), src)) + e.append(m2_expr.ExprAssign(float_prev(dst), src)) e += set_float_cs_eip(instr) e += float_pop(dst) @@ -2429,7 +2429,7 @@ def fstp(ir, instr, dst): def fist(_, instr, dst): e = [] - e.append(m2_expr.ExprAff(dst, m2_expr.ExprOp('fp_to_sint%d' % dst.size, + e.append(m2_expr.ExprAssign(dst, m2_expr.ExprOp('fp_to_sint%d' % dst.size, float_st0))) e += set_float_cs_eip(instr) @@ -2444,7 +2444,7 @@ def fistp(ir, instr, dst): def fisttp(_, instr, dst): e = [] - e.append(m2_expr.ExprAff( + e.append(m2_expr.ExprAssign( dst, m2_expr.ExprOp('fp_to_sint%d' % dst.size, m2_expr.ExprOp('fpround_towardszero', float_st0) @@ -2516,7 +2516,7 @@ def fadd(_, instr, dst, src=None): dst, src = float_implicit_st0(dst, src) e = [] src = mem2double(instr, src) - e.append(m2_expr.ExprAff(dst, m2_expr.ExprOp('fadd', dst, src))) + e.append(m2_expr.ExprAssign(dst, m2_expr.ExprOp('fadd', dst, src))) e += set_float_cs_eip(instr) return e, [] @@ -2526,7 +2526,7 @@ def fiadd(_, instr, dst, src=None): dst, src = float_implicit_st0(dst, src) e = [] src = mem2double(instr, src) - e.append(m2_expr.ExprAff(dst, m2_expr.ExprOp('fiadd', dst, src))) + e.append(m2_expr.ExprAssign(dst, m2_expr.ExprOp('fiadd', dst, src))) e += set_float_cs_eip(instr) return e, [] @@ -2535,7 +2535,7 @@ def fisub(_, instr, dst, src=None): dst, src = float_implicit_st0(dst, src) e = [] src = mem2double(instr, src) - e.append(m2_expr.ExprAff(dst, m2_expr.ExprOp('fisub', dst, src))) + e.append(m2_expr.ExprAssign(dst, m2_expr.ExprOp('fisub', dst, src))) e += set_float_cs_eip(instr) return e, [] @@ -2544,7 +2544,7 @@ def fisubr(_, instr, dst, src=None): dst, src = float_implicit_st0(dst, src) e = [] src = mem2double(instr, src) - e.append(m2_expr.ExprAff(dst, m2_expr.ExprOp('fisub', src, dst))) + e.append(m2_expr.ExprAssign(dst, m2_expr.ExprOp('fisub', src, dst))) e += set_float_cs_eip(instr) return e, [] @@ -2552,7 +2552,7 @@ def fisubr(_, instr, dst, src=None): def fpatan(_, instr): e = [] a = float_st1 - e.append(m2_expr.ExprAff(float_prev(a), + e.append(m2_expr.ExprAssign(float_prev(a), m2_expr.ExprOp('fpatan', float_st0, float_st1))) e += set_float_cs_eip(instr) e += float_pop(a) @@ -2562,14 +2562,14 @@ def fpatan(_, instr): def fprem(_, instr): e = [] e.append( - m2_expr.ExprAff(float_st0, m2_expr.ExprOp('fprem', float_st0, float_st1))) + m2_expr.ExprAssign(float_st0, m2_expr.ExprOp('fprem', float_st0, float_st1))) # Remaining bits (ex: used in argument reduction in tan) quotient = m2_expr.ExprOp('fp_to_sint32', m2_expr.ExprOp('fpround_towardszero', m2_expr.ExprOp('fdiv', float_st0, float_st1))) - e += [m2_expr.ExprAff(float_c0, quotient[2:3]), - m2_expr.ExprAff(float_c3, quotient[1:2]), - m2_expr.ExprAff(float_c1, quotient[0:1]), + e += [m2_expr.ExprAssign(float_c0, quotient[2:3]), + m2_expr.ExprAssign(float_c3, quotient[1:2]), + m2_expr.ExprAssign(float_c1, quotient[0:1]), # Consider the reduction is always completed - m2_expr.ExprAff(float_c2, m2_expr.ExprInt(0, 1)), + m2_expr.ExprAssign(float_c2, m2_expr.ExprInt(0, 1)), ] e += set_float_cs_eip(instr) return e, [] @@ -2578,7 +2578,7 @@ def fprem(_, instr): def fprem1(_, instr): e = [] e.append( - m2_expr.ExprAff(float_st0, m2_expr.ExprOp('fprem1', float_st0, float_st1))) + m2_expr.ExprAssign(float_st0, m2_expr.ExprOp('fprem1', float_st0, float_st1))) e += set_float_cs_eip(instr) return e, [] @@ -2587,7 +2587,7 @@ def faddp(_, instr, dst, src=None): dst, src = float_implicit_st0(dst, src) e = [] src = mem2double(instr, src) - e.append(m2_expr.ExprAff(float_prev(dst), m2_expr.ExprOp('fadd', dst, src))) + e.append(m2_expr.ExprAssign(float_prev(dst), m2_expr.ExprOp('fadd', dst, src))) e += set_float_cs_eip(instr) e += float_pop(dst) return e, [] @@ -2603,7 +2603,7 @@ def fyl2x(_, instr): e = [] a = float_st1 e.append( - m2_expr.ExprAff(float_prev(a), m2_expr.ExprOp('fyl2x', float_st0, float_st1))) + m2_expr.ExprAssign(float_prev(a), m2_expr.ExprOp('fyl2x', float_st0, float_st1))) e += set_float_cs_eip(instr) e += float_pop(a) return e, [] @@ -2622,22 +2622,22 @@ def fnstenv(ir, instr, dst): # This will truncate addresses size = min(32, s) ad = ir.ExprMem(dst.arg, size=16) - e.append(m2_expr.ExprAff(ad, float_control)) + e.append(m2_expr.ExprAssign(ad, float_control)) ad = ir.ExprMem(dst.arg + m2_expr.ExprInt(size / 8 * 1, dst.arg.size), size=16) - e.append(m2_expr.ExprAff(ad, status_word)) + e.append(m2_expr.ExprAssign(ad, status_word)) ad = ir.ExprMem(dst.arg + m2_expr.ExprInt(size / 8 * 3, dst.arg.size), size=size) - e.append(m2_expr.ExprAff(ad, float_eip[:size])) + e.append(m2_expr.ExprAssign(ad, float_eip[:size])) ad = ir.ExprMem(dst.arg + m2_expr.ExprInt(size / 8 * 4, dst.arg.size), size=16) - e.append(m2_expr.ExprAff(ad, float_cs)) + e.append(m2_expr.ExprAssign(ad, float_cs)) ad = ir.ExprMem(dst.arg + m2_expr.ExprInt(size / 8 * 5, dst.arg.size), size=size) - e.append(m2_expr.ExprAff(ad, float_address[:size])) + e.append(m2_expr.ExprAssign(ad, float_address[:size])) ad = ir.ExprMem(dst.arg + m2_expr.ExprInt(size / 8 * 6, dst.arg.size), size=16) - e.append(m2_expr.ExprAff(ad, float_ds)) + e.append(m2_expr.ExprAssign(ad, float_ds)) return e, [] @@ -2652,12 +2652,12 @@ def fldenv(ir, instr, src): # Float control ad = ir.ExprMem(src.arg, size=16) - e.append(m2_expr.ExprAff(float_control, ad)) + e.append(m2_expr.ExprAssign(float_control, ad)) # Status word ad = ir.ExprMem(src.arg + m2_expr.ExprInt(size / 8 * 1, size=src.arg.size), size=16) - e += [m2_expr.ExprAff(x, y) for x, y in ((float_c0, ad[8:9]), + e += [m2_expr.ExprAssign(x, y) for x, y in ((float_c0, ad[8:9]), (float_c1, ad[9:10]), (float_c2, ad[10:11]), (float_stack_ptr, ad[11:14]), @@ -2672,7 +2672,7 @@ def fldenv(ir, instr, src): ad = ir.ExprMem(src.arg + m2_expr.ExprInt(size / 8 * offset, size=src.arg.size), size=target.size) - e.append(m2_expr.ExprAff(target, ad)) + e.append(m2_expr.ExprAssign(target, ad)) return e, [] @@ -2681,7 +2681,7 @@ def fsub(_, instr, dst, src=None): dst, src = float_implicit_st0(dst, src) e = [] src = mem2double(instr, src) - e.append(m2_expr.ExprAff(dst, m2_expr.ExprOp('fsub', dst, src))) + e.append(m2_expr.ExprAssign(dst, m2_expr.ExprOp('fsub', dst, src))) e += set_float_cs_eip(instr) return e, [] @@ -2690,7 +2690,7 @@ def fsubp(_, instr, dst, src=None): dst, src = float_implicit_st0(dst, src) e = [] src = mem2double(instr, src) - e.append(m2_expr.ExprAff(float_prev(dst), m2_expr.ExprOp('fsub', dst, src))) + e.append(m2_expr.ExprAssign(float_prev(dst), m2_expr.ExprOp('fsub', dst, src))) e += set_float_cs_eip(instr) e += float_pop(dst) return e, [] @@ -2700,7 +2700,7 @@ def fsubr(_, instr, dst, src=None): dst, src = float_implicit_st0(dst, src) e = [] src = mem2double(instr, src) - e.append(m2_expr.ExprAff(dst, m2_expr.ExprOp('fsub', src, dst))) + e.append(m2_expr.ExprAssign(dst, m2_expr.ExprOp('fsub', src, dst))) e += set_float_cs_eip(instr) return e, [] @@ -2709,7 +2709,7 @@ def fsubrp(_, instr, dst, src=None): dst, src = float_implicit_st0(dst, src) e = [] src = mem2double(instr, src) - e.append(m2_expr.ExprAff(float_prev(dst), m2_expr.ExprOp('fsub', src, dst))) + e.append(m2_expr.ExprAssign(float_prev(dst), m2_expr.ExprOp('fsub', src, dst))) e += set_float_cs_eip(instr) e += float_pop(dst) return e, [] @@ -2719,7 +2719,7 @@ def fmul(_, instr, dst, src=None): dst, src = float_implicit_st0(dst, src) e = [] src = mem2double(instr, src) - e.append(m2_expr.ExprAff(dst, m2_expr.ExprOp('fmul', dst, src))) + e.append(m2_expr.ExprAssign(dst, m2_expr.ExprOp('fmul', dst, src))) e += set_float_cs_eip(instr) return e, [] @@ -2728,7 +2728,7 @@ def fimul(_, instr, dst, src=None): dst, src = float_implicit_st0(dst, src) e = [] src = mem2double(instr, src) - e.append(m2_expr.ExprAff(dst, m2_expr.ExprOp('fimul', dst, src))) + e.append(m2_expr.ExprAssign(dst, m2_expr.ExprOp('fimul', dst, src))) e += set_float_cs_eip(instr) return e, [] @@ -2737,7 +2737,7 @@ def fdiv(_, instr, dst, src=None): dst, src = float_implicit_st0(dst, src) e = [] src = mem2double(instr, src) - e.append(m2_expr.ExprAff(dst, m2_expr.ExprOp('fdiv', dst, src))) + e.append(m2_expr.ExprAssign(dst, m2_expr.ExprOp('fdiv', dst, src))) e += set_float_cs_eip(instr) return e, [] @@ -2746,7 +2746,7 @@ def fdivr(_, instr, dst, src=None): dst, src = float_implicit_st0(dst, src) e = [] src = mem2double(instr, src) - e.append(m2_expr.ExprAff(dst, m2_expr.ExprOp('fdiv', src, dst))) + e.append(m2_expr.ExprAssign(dst, m2_expr.ExprOp('fdiv', src, dst))) e += set_float_cs_eip(instr) return e, [] @@ -2755,7 +2755,7 @@ def fdivrp(_, instr, dst, src=None): dst, src = float_implicit_st0(dst, src) e = [] src = mem2double(instr, src) - e.append(m2_expr.ExprAff(float_prev(dst), m2_expr.ExprOp('fdiv', src, dst))) + e.append(m2_expr.ExprAssign(float_prev(dst), m2_expr.ExprOp('fdiv', src, dst))) e += set_float_cs_eip(instr) e += float_pop(dst) return e, [] @@ -2765,7 +2765,7 @@ def fidiv(_, instr, dst, src=None): dst, src = float_implicit_st0(dst, src) e = [] src = mem2double(instr, src) - e.append(m2_expr.ExprAff(dst, m2_expr.ExprOp('fidiv', dst, src))) + e.append(m2_expr.ExprAssign(dst, m2_expr.ExprOp('fidiv', dst, src))) e += set_float_cs_eip(instr) return e, [] @@ -2774,7 +2774,7 @@ def fidivr(_, instr, dst, src=None): dst, src = float_implicit_st0(dst, src) e = [] src = mem2double(instr, src) - e.append(m2_expr.ExprAff(dst, m2_expr.ExprOp('fidiv', src, dst))) + e.append(m2_expr.ExprAssign(dst, m2_expr.ExprOp('fidiv', src, dst))) e += set_float_cs_eip(instr) return e, [] @@ -2784,7 +2784,7 @@ def fdivp(_, instr, dst, src=None): dst, src = float_implicit_st0(dst, src) e = [] src = mem2double(instr, src) - e.append(m2_expr.ExprAff(float_prev(dst), m2_expr.ExprOp('fdiv', dst, src))) + e.append(m2_expr.ExprAssign(float_prev(dst), m2_expr.ExprOp('fdiv', dst, src))) e += set_float_cs_eip(instr) e += float_pop(dst) return e, [] @@ -2795,7 +2795,7 @@ def fmulp(_, instr, dst, src=None): dst, src = float_implicit_st0(dst, src) e = [] src = mem2double(instr, src) - e.append(m2_expr.ExprAff(float_prev(dst), m2_expr.ExprOp('fmul', dst, src))) + e.append(m2_expr.ExprAssign(float_prev(dst), m2_expr.ExprOp('fmul', dst, src))) e += set_float_cs_eip(instr) e += float_pop(dst) return e, [] @@ -2804,7 +2804,7 @@ def fmulp(_, instr, dst, src=None): def ftan(_, instr, src): e = [] src = mem2double(instr, src) - e.append(m2_expr.ExprAff(float_st0, m2_expr.ExprOp('ftan', src))) + e.append(m2_expr.ExprAssign(float_st0, m2_expr.ExprOp('ftan', src))) e += set_float_cs_eip(instr) return e, [] @@ -2812,23 +2812,23 @@ def ftan(_, instr, src): def fxch(_, instr, src): e = [] src = mem2double(instr, src) - e.append(m2_expr.ExprAff(float_st0, src)) - e.append(m2_expr.ExprAff(src, float_st0)) + e.append(m2_expr.ExprAssign(float_st0, src)) + e.append(m2_expr.ExprAssign(src, float_st0)) e += set_float_cs_eip(instr) return e, [] def fptan(_, instr): e = [] - e.append(m2_expr.ExprAff(float_st7, float_st6)) - e.append(m2_expr.ExprAff(float_st6, float_st5)) - e.append(m2_expr.ExprAff(float_st5, float_st4)) - e.append(m2_expr.ExprAff(float_st4, float_st3)) - e.append(m2_expr.ExprAff(float_st3, float_st2)) - e.append(m2_expr.ExprAff(float_st2, float_st1)) - e.append(m2_expr.ExprAff(float_st1, m2_expr.ExprOp('ftan', float_st0))) + e.append(m2_expr.ExprAssign(float_st7, float_st6)) + e.append(m2_expr.ExprAssign(float_st6, float_st5)) + e.append(m2_expr.ExprAssign(float_st5, float_st4)) + e.append(m2_expr.ExprAssign(float_st4, float_st3)) + e.append(m2_expr.ExprAssign(float_st3, float_st2)) + e.append(m2_expr.ExprAssign(float_st2, float_st1)) + e.append(m2_expr.ExprAssign(float_st1, m2_expr.ExprOp('ftan', float_st0))) e.append( - m2_expr.ExprAff( + m2_expr.ExprAssign( float_st0, m2_expr.ExprOp( 'sint_to_fp', @@ -2837,51 +2837,51 @@ def fptan(_, instr): ) ) e.append( - m2_expr.ExprAff(float_stack_ptr, + m2_expr.ExprAssign(float_stack_ptr, float_stack_ptr + m2_expr.ExprInt(1, 3))) return e, [] def frndint(_, instr): e = [] - e.append(m2_expr.ExprAff(float_st0, m2_expr.ExprOp('frndint', float_st0))) + e.append(m2_expr.ExprAssign(float_st0, m2_expr.ExprOp('frndint', float_st0))) e += set_float_cs_eip(instr) return e, [] def fsin(_, instr): e = [] - e.append(m2_expr.ExprAff(float_st0, m2_expr.ExprOp('fsin', float_st0))) + e.append(m2_expr.ExprAssign(float_st0, m2_expr.ExprOp('fsin', float_st0))) e += set_float_cs_eip(instr) return e, [] def fcos(_, instr): e = [] - e.append(m2_expr.ExprAff(float_st0, m2_expr.ExprOp('fcos', float_st0))) + e.append(m2_expr.ExprAssign(float_st0, m2_expr.ExprOp('fcos', float_st0))) e += set_float_cs_eip(instr) return e, [] def fsincos(_, instr): e = [] - e.append(m2_expr.ExprAff(float_st7, float_st6)) - e.append(m2_expr.ExprAff(float_st6, float_st5)) - e.append(m2_expr.ExprAff(float_st5, float_st4)) - e.append(m2_expr.ExprAff(float_st4, float_st3)) - e.append(m2_expr.ExprAff(float_st3, float_st2)) - e.append(m2_expr.ExprAff(float_st2, float_st1)) - e.append(m2_expr.ExprAff(float_st1, m2_expr.ExprOp('fsin', float_st0))) - e.append(m2_expr.ExprAff(float_st0, m2_expr.ExprOp('fcos', float_st0))) + e.append(m2_expr.ExprAssign(float_st7, float_st6)) + e.append(m2_expr.ExprAssign(float_st6, float_st5)) + e.append(m2_expr.ExprAssign(float_st5, float_st4)) + e.append(m2_expr.ExprAssign(float_st4, float_st3)) + e.append(m2_expr.ExprAssign(float_st3, float_st2)) + e.append(m2_expr.ExprAssign(float_st2, float_st1)) + e.append(m2_expr.ExprAssign(float_st1, m2_expr.ExprOp('fsin', float_st0))) + e.append(m2_expr.ExprAssign(float_st0, m2_expr.ExprOp('fcos', float_st0))) e.append( - m2_expr.ExprAff(float_stack_ptr, + m2_expr.ExprAssign(float_stack_ptr, float_stack_ptr + m2_expr.ExprInt(1, 3))) return e, [] def fscale(_, instr): e = [] - e.append(m2_expr.ExprAff(float_st0, m2_expr.ExprOp('fscale', float_st0, + e.append(m2_expr.ExprAssign(float_st0, m2_expr.ExprOp('fscale', float_st0, float_st1))) e += set_float_cs_eip(instr) return e, [] @@ -2889,28 +2889,28 @@ def fscale(_, instr): def f2xm1(_, instr): e = [] - e.append(m2_expr.ExprAff(float_st0, m2_expr.ExprOp('f2xm1', float_st0))) + e.append(m2_expr.ExprAssign(float_st0, m2_expr.ExprOp('f2xm1', float_st0))) e += set_float_cs_eip(instr) return e, [] def fchs(_, instr): e = [] - e.append(m2_expr.ExprAff(float_st0, m2_expr.ExprOp('fchs', float_st0))) + e.append(m2_expr.ExprAssign(float_st0, m2_expr.ExprOp('fchs', float_st0))) e += set_float_cs_eip(instr) return e, [] def fsqrt(_, instr): e = [] - e.append(m2_expr.ExprAff(float_st0, m2_expr.ExprOp('fsqrt', float_st0))) + e.append(m2_expr.ExprAssign(float_st0, m2_expr.ExprOp('fsqrt', float_st0))) e += set_float_cs_eip(instr) return e, [] def fabs(_, instr): e = [] - e.append(m2_expr.ExprAff(float_st0, m2_expr.ExprOp('fabs', float_st0))) + e.append(m2_expr.ExprAssign(float_st0, m2_expr.ExprOp('fabs', float_st0))) e += set_float_cs_eip(instr) return e, [] @@ -2926,19 +2926,19 @@ def fnstsw(_, instr, dst): float_c3, # B: FPU is not busy -> 0 m2_expr.ExprInt(0, 1)] - e = [m2_expr.ExprAff(dst, m2_expr.ExprCompose(*args))] + e = [m2_expr.ExprAssign(dst, m2_expr.ExprCompose(*args))] return e, [] def fnstcw(_, instr, dst): e = [] - e.append(m2_expr.ExprAff(dst, float_control)) + e.append(m2_expr.ExprAssign(dst, float_control)) return e, [] def fldcw(_, instr, src): e = [] - e.append(m2_expr.ExprAff(float_control, src)) + e.append(m2_expr.ExprAssign(float_control, src)) return e, [] @@ -3030,7 +3030,7 @@ def sfence(_, instr, src=None): def ud2(_, instr, src=None): - e = [m2_expr.ExprAff(exception_flags, m2_expr.ExprInt( + e = [m2_expr.ExprAssign(exception_flags, m2_expr.ExprInt( EXCEPT_ILLEGAL_INSN, exception_flags.size))] return e, [] @@ -3038,18 +3038,18 @@ def ud2(_, instr, src=None): def hlt(_, instr): e = [] except_int = EXCEPT_PRIV_INSN - e.append(m2_expr.ExprAff(exception_flags, m2_expr.ExprInt(except_int, 32))) + e.append(m2_expr.ExprAssign(exception_flags, m2_expr.ExprInt(except_int, 32))) return e, [] def rdtsc(_, instr): e = [] - e.append(m2_expr.ExprAff(tsc1, tsc1 + m2_expr.ExprInt(1, 32))) - e.append(m2_expr.ExprAff(tsc2, tsc2 + m2_expr.ExprCond(tsc1 - tsc1.mask, + e.append(m2_expr.ExprAssign(tsc1, tsc1 + m2_expr.ExprInt(1, 32))) + e.append(m2_expr.ExprAssign(tsc2, tsc2 + m2_expr.ExprCond(tsc1 - tsc1.mask, m2_expr.ExprInt(0, 32), m2_expr.ExprInt(1, 32)))) - e.append(m2_expr.ExprAff(mRAX[32], tsc1)) - e.append(m2_expr.ExprAff(mRDX[32], tsc2)) + e.append(m2_expr.ExprAssign(mRAX[32], tsc1)) + e.append(m2_expr.ExprAssign(mRDX[32], tsc2)) return e, [] @@ -3058,7 +3058,7 @@ def daa(_, instr): r_al = mRAX[instr.mode][:8] cond1 = m2_expr.expr_is_unsigned_greater(r_al[:4], m2_expr.ExprInt(0x9, 4)) | af - e.append(m2_expr.ExprAff(af, cond1)) + e.append(m2_expr.ExprAssign(af, cond1)) cond2 = m2_expr.expr_is_unsigned_greater(m2_expr.ExprInt(6, 8), r_al) cond3 = m2_expr.expr_is_unsigned_greater(r_al, m2_expr.ExprInt(0x99, 8)) | cf @@ -3069,7 +3069,7 @@ def daa(_, instr): new_cf = m2_expr.ExprCond(cond3, m2_expr.ExprInt(1, 1), m2_expr.ExprInt(0, 1)) - e.append(m2_expr.ExprAff(cf, new_cf)) + e.append(m2_expr.ExprAssign(cf, new_cf)) al_c1 = m2_expr.ExprCond(cond1, r_al + m2_expr.ExprInt(6, 8), @@ -3078,7 +3078,7 @@ def daa(_, instr): new_al = m2_expr.ExprCond(cond3, al_c1 + m2_expr.ExprInt(0x60, 8), al_c1) - e.append(m2_expr.ExprAff(r_al, new_al)) + e.append(m2_expr.ExprAssign(r_al, new_al)) e += update_flag_znp(new_al) return e, [] @@ -3088,7 +3088,7 @@ def das(_, instr): r_al = mRAX[instr.mode][:8] cond1 = m2_expr.expr_is_unsigned_greater(r_al[:4], m2_expr.ExprInt(0x9, 4)) | af - e.append(m2_expr.ExprAff(af, cond1)) + e.append(m2_expr.ExprAssign(af, cond1)) cond2 = m2_expr.expr_is_unsigned_greater(m2_expr.ExprInt(6, 8), r_al) cond3 = m2_expr.expr_is_unsigned_greater(r_al, m2_expr.ExprInt(0x99, 8)) | cf @@ -3099,7 +3099,7 @@ def das(_, instr): new_cf = m2_expr.ExprCond(cond3, m2_expr.ExprInt(1, 1), cf_c1) - e.append(m2_expr.ExprAff(cf, new_cf)) + e.append(m2_expr.ExprAssign(cf, new_cf)) al_c1 = m2_expr.ExprCond(cond1, r_al - m2_expr.ExprInt(6, 8), @@ -3108,7 +3108,7 @@ def das(_, instr): new_al = m2_expr.ExprCond(cond3, al_c1 - m2_expr.ExprInt(0x60, 8), al_c1) - e.append(m2_expr.ExprAff(r_al, new_al)) + e.append(m2_expr.ExprAssign(r_al, new_al)) e += update_flag_znp(new_al) return e, [] @@ -3125,12 +3125,12 @@ def aam(ir, instr, src): m2_expr.ExprOp("udiv", tempAL, src), mRAX[instr.mode][16:] ) - e += [m2_expr.ExprAff(mRAX[instr.mode], newEAX)] + e += [m2_expr.ExprAssign(mRAX[instr.mode], newEAX)] e += update_flag_arith(newEAX) - e.append(m2_expr.ExprAff(af, m2_expr.ExprInt(0, 1))) + e.append(m2_expr.ExprAssign(af, m2_expr.ExprInt(0, 1))) else: e.append( - m2_expr.ExprAff( + m2_expr.ExprAssign( exception_flags, m2_expr.ExprInt(EXCEPT_DIV_BY_ZERO, exception_flags.size) ) @@ -3145,9 +3145,9 @@ def aad(_, instr, src): newEAX = m2_expr.ExprCompose((tempAL + (tempAH * src)) & m2_expr.ExprInt(0xFF, 8), m2_expr.ExprInt(0, 8), mRAX[instr.mode][16:]) - e += [m2_expr.ExprAff(mRAX[instr.mode], newEAX)] + e += [m2_expr.ExprAssign(mRAX[instr.mode], newEAX)] e += update_flag_arith(newEAX) - e.append(m2_expr.ExprAff(af, m2_expr.ExprInt(0, 1))) + e.append(m2_expr.ExprAssign(af, m2_expr.ExprInt(0, 1))) return e, [] @@ -3175,9 +3175,9 @@ def _tpl_aaa(_, instr, op): new_ax = first_part & m2_expr.ExprInt(0xff0f, size=r_ax.size) # set AL - e.append(m2_expr.ExprAff(r_ax, m2_expr.ExprCond(cond, new_ax, r_ax))) - e.append(m2_expr.ExprAff(af, cond)) - e.append(m2_expr.ExprAff(cf, cond)) + e.append(m2_expr.ExprAssign(r_ax, m2_expr.ExprCond(cond, new_ax, r_ax))) + e.append(m2_expr.ExprAssign(af, cond)) + e.append(m2_expr.ExprAssign(cf, cond)) return e, [] @@ -3203,18 +3203,18 @@ def bsr_bsf(ir, instr, dst, src, op_func): loc_next = ir.get_next_loc_key(instr) loc_next_expr = m2_expr.ExprLoc(loc_next, ir.IRDst.size) - aff_dst = m2_expr.ExprAff(ir.IRDst, loc_next_expr) - e = [m2_expr.ExprAff(ir.IRDst, m2_expr.ExprCond(src, + aff_dst = m2_expr.ExprAssign(ir.IRDst, loc_next_expr) + e = [m2_expr.ExprAssign(ir.IRDst, m2_expr.ExprCond(src, loc_src_not_null_expr, loc_src_null_expr))] e_src_null = [] - e_src_null.append(m2_expr.ExprAff(zf, m2_expr.ExprInt(1, zf.size))) + e_src_null.append(m2_expr.ExprAssign(zf, m2_expr.ExprInt(1, zf.size))) # XXX destination is undefined e_src_null.append(aff_dst) e_src_not_null = [] - e_src_not_null.append(m2_expr.ExprAff(zf, m2_expr.ExprInt(0, zf.size))) - e_src_not_null.append(m2_expr.ExprAff(dst, op_func(src))) + e_src_not_null.append(m2_expr.ExprAssign(zf, m2_expr.ExprInt(0, zf.size))) + e_src_not_null.append(m2_expr.ExprAssign(dst, op_func(src))) e_src_not_null.append(aff_dst) return e, [IRBlock(loc_src_null, [AssignBlock(e_src_null, instr)]), @@ -3235,13 +3235,13 @@ def bsr(ir, instr, dst, src): def arpl(_, instr, dst, src): e = [] - e.append(m2_expr.ExprAff(exception_flags, m2_expr.ExprInt(1 << 7, 32))) + e.append(m2_expr.ExprAssign(exception_flags, m2_expr.ExprInt(1 << 7, 32))) return e, [] def ins(_, instr, size): e = [] - e.append(m2_expr.ExprAff(exception_flags, m2_expr.ExprInt(1 << 7, 32))) + e.append(m2_expr.ExprAssign(exception_flags, m2_expr.ExprInt(1 << 7, 32))) return e, [] @@ -3251,17 +3251,17 @@ def sidt(ir, instr, dst): raise ValueError('not exprmem 32bit instance!!') ptr = dst.arg LOG_X86_SEM.warning("DEFAULT SIDT ADDRESS %s!!", str(dst)) - e.append(m2_expr.ExprAff(ir.ExprMem(ptr, 32), + e.append(m2_expr.ExprAssign(ir.ExprMem(ptr, 32), m2_expr.ExprInt(0xe40007ff, 32))) e.append( - m2_expr.ExprAff(ir.ExprMem(ptr + m2_expr.ExprInt(4, ptr.size), 16), + m2_expr.ExprAssign(ir.ExprMem(ptr + m2_expr.ExprInt(4, ptr.size), 16), m2_expr.ExprInt(0x8245, 16))) return e, [] def sldt(_, instr, dst): LOG_X86_SEM.warning("DEFAULT SLDT ADDRESS %s!!", str(dst)) - e = [m2_expr.ExprAff(dst, m2_expr.ExprInt(0, dst.size))] + e = [m2_expr.ExprAssign(dst, m2_expr.ExprInt(0, dst.size))] return e, [] @@ -3343,7 +3343,7 @@ def cmovns(ir, instr, dst, src): def icebp(_, instr): e = [] - e.append(m2_expr.ExprAff(exception_flags, + e.append(m2_expr.ExprAssign(exception_flags, m2_expr.ExprInt(EXCEPT_SOFT_BP, 32))) return e, [] # XXX @@ -3356,22 +3356,22 @@ def l_int(_, instr, src): except_int = EXCEPT_SOFT_BP else: except_int = EXCEPT_INT_XX - e.append(m2_expr.ExprAff(exception_flags, + e.append(m2_expr.ExprAssign(exception_flags, m2_expr.ExprInt(except_int, 32))) - e.append(m2_expr.ExprAff(interrupt_num, src)) + e.append(m2_expr.ExprAssign(interrupt_num, src)) return e, [] def l_sysenter(_, instr): e = [] - e.append(m2_expr.ExprAff(exception_flags, + e.append(m2_expr.ExprAssign(exception_flags, m2_expr.ExprInt(EXCEPT_PRIV_INSN, 32))) return e, [] def l_syscall(_, instr): e = [] - e.append(m2_expr.ExprAff(exception_flags, + e.append(m2_expr.ExprAssign(exception_flags, m2_expr.ExprInt(EXCEPT_PRIV_INSN, 32))) return e, [] @@ -3380,7 +3380,7 @@ def l_syscall(_, instr): def l_out(_, instr, src1, src2): e = [] - e.append(m2_expr.ExprAff(exception_flags, + e.append(m2_expr.ExprAssign(exception_flags, m2_expr.ExprInt(EXCEPT_PRIV_INSN, 32))) return e, [] @@ -3389,7 +3389,7 @@ def l_out(_, instr, src1, src2): def l_outs(_, instr, size): e = [] - e.append(m2_expr.ExprAff(exception_flags, + e.append(m2_expr.ExprAssign(exception_flags, m2_expr.ExprInt(EXCEPT_PRIV_INSN, 32))) return e, [] @@ -3400,23 +3400,23 @@ def xlat(ir, instr): e = [] ptr = mRAX[instr.mode][0:8].zeroExtend(mRBX[instr.mode].size) src = ir.ExprMem(mRBX[instr.mode] + ptr, 8) - e.append(m2_expr.ExprAff(mRAX[instr.mode][0:8], src)) + e.append(m2_expr.ExprAssign(mRAX[instr.mode][0:8], src)) return e, [] def cpuid(_, instr): e = [] e.append( - m2_expr.ExprAff(mRAX[instr.mode], + m2_expr.ExprAssign(mRAX[instr.mode], m2_expr.ExprOp('x86_cpuid', mRAX[instr.mode], m2_expr.ExprInt(0, instr.mode)))) e.append( - m2_expr.ExprAff(mRBX[instr.mode], + m2_expr.ExprAssign(mRBX[instr.mode], m2_expr.ExprOp('x86_cpuid', mRAX[instr.mode], m2_expr.ExprInt(1, instr.mode)))) e.append( - m2_expr.ExprAff(mRCX[instr.mode], + m2_expr.ExprAssign(mRCX[instr.mode], m2_expr.ExprOp('x86_cpuid', mRAX[instr.mode], m2_expr.ExprInt(2, instr.mode)))) e.append( - m2_expr.ExprAff(mRDX[instr.mode], + m2_expr.ExprAssign(mRDX[instr.mode], m2_expr.ExprOp('x86_cpuid', mRAX[instr.mode], m2_expr.ExprInt(3, instr.mode)))) return e, [] @@ -3454,17 +3454,17 @@ def bt(ir, instr, src, index): index = index.zeroExtend(src.size) d, off_bit = bittest_get(ir, instr, src, index) d = d >> off_bit - e.append(m2_expr.ExprAff(cf, d[:1])) + e.append(m2_expr.ExprAssign(cf, d[:1])) return e, [] def btc(ir, instr, src, index): e = [] d, off_bit = bittest_get(ir, instr, src, index) - e.append(m2_expr.ExprAff(cf, (d >> off_bit)[:1])) + e.append(m2_expr.ExprAssign(cf, (d >> off_bit)[:1])) m = m2_expr.ExprInt(1, src.size) << off_bit - e.append(m2_expr.ExprAff(d, d ^ m)) + e.append(m2_expr.ExprAssign(d, d ^ m)) return e, [] @@ -3472,9 +3472,9 @@ def btc(ir, instr, src, index): def bts(ir, instr, src, index): e = [] d, off_bit = bittest_get(ir, instr, src, index) - e.append(m2_expr.ExprAff(cf, (d >> off_bit)[:1])) + e.append(m2_expr.ExprAssign(cf, (d >> off_bit)[:1])) m = m2_expr.ExprInt(1, src.size) << off_bit - e.append(m2_expr.ExprAff(d, d | m)) + e.append(m2_expr.ExprAssign(d, d | m)) return e, [] @@ -3482,9 +3482,9 @@ def bts(ir, instr, src, index): def btr(ir, instr, src, index): e = [] d, off_bit = bittest_get(ir, instr, src, index) - e.append(m2_expr.ExprAff(cf, (d >> off_bit)[:1])) + e.append(m2_expr.ExprAssign(cf, (d >> off_bit)[:1])) m = ~(m2_expr.ExprInt(1, src.size) << off_bit) - e.append(m2_expr.ExprAff(d, d & m)) + e.append(m2_expr.ExprAssign(d, d & m)) return e, [] @@ -3495,7 +3495,7 @@ def into(_, instr): def l_in(_, instr, src1, src2): e = [] - e.append(m2_expr.ExprAff(exception_flags, + e.append(m2_expr.ExprAssign(exception_flags, m2_expr.ExprInt(EXCEPT_PRIV_INSN, 32))) return e, [] @@ -3537,46 +3537,46 @@ def cmpxchg16b(arg1): def lds(ir, instr, dst, src): e = [] - e.append(m2_expr.ExprAff(dst, ir.ExprMem(src.arg, size=dst.size))) + e.append(m2_expr.ExprAssign(dst, ir.ExprMem(src.arg, size=dst.size))) DS_value = ir.ExprMem(src.arg + m2_expr.ExprInt(dst.size / 8, src.arg.size), size=16) - e.append(m2_expr.ExprAff(DS, DS_value)) + e.append(m2_expr.ExprAssign(DS, DS_value)) return e, [] def les(ir, instr, dst, src): e = [] - e.append(m2_expr.ExprAff(dst, ir.ExprMem(src.arg, size=dst.size))) + e.append(m2_expr.ExprAssign(dst, ir.ExprMem(src.arg, size=dst.size))) ES_value = ir.ExprMem(src.arg + m2_expr.ExprInt(dst.size / 8, src.arg.size), size=16) - e.append(m2_expr.ExprAff(ES, ES_value)) + e.append(m2_expr.ExprAssign(ES, ES_value)) return e, [] def lss(ir, instr, dst, src): e = [] - e.append(m2_expr.ExprAff(dst, ir.ExprMem(src.arg, size=dst.size))) + e.append(m2_expr.ExprAssign(dst, ir.ExprMem(src.arg, size=dst.size))) SS_value = ir.ExprMem(src.arg + m2_expr.ExprInt(dst.size / 8, src.arg.size), size=16) - e.append(m2_expr.ExprAff(SS, SS_value)) + e.append(m2_expr.ExprAssign(SS, SS_value)) return e, [] def lfs(ir, instr, dst, src): e = [] - e.append(m2_expr.ExprAff(dst, ir.ExprMem(src.arg, size=dst.size))) + e.append(m2_expr.ExprAssign(dst, ir.ExprMem(src.arg, size=dst.size))) FS_value = ir.ExprMem(src.arg + m2_expr.ExprInt(dst.size / 8, src.arg.size), size=16) - e.append(m2_expr.ExprAff(FS, FS_value)) + e.append(m2_expr.ExprAssign(FS, FS_value)) return e, [] def lgs(ir, instr, dst, src): e = [] - e.append(m2_expr.ExprAff(dst, ir.ExprMem(src.arg, size=dst.size))) + e.append(m2_expr.ExprAssign(dst, ir.ExprMem(src.arg, size=dst.size))) GS_value = ir.ExprMem(src.arg + m2_expr.ExprInt(dst.size / 8, src.arg.size), size=16) - e.append(m2_expr.ExprAff(GS, GS_value)) + e.append(m2_expr.ExprAssign(GS, GS_value)) return e, [] @@ -3585,32 +3585,32 @@ def lahf(_, instr): args = [cf, m2_expr.ExprInt(1, 1), pf, m2_expr.ExprInt(0, 1), af, m2_expr.ExprInt(0, 1), zf, nf] e.append( - m2_expr.ExprAff(mRAX[instr.mode][8:16], m2_expr.ExprCompose(*args))) + m2_expr.ExprAssign(mRAX[instr.mode][8:16], m2_expr.ExprCompose(*args))) return e, [] def sahf(_, instr): tmp = mRAX[instr.mode][8:16] e = [] - e.append(m2_expr.ExprAff(cf, tmp[0:1])) - e.append(m2_expr.ExprAff(pf, tmp[2:3])) - e.append(m2_expr.ExprAff(af, tmp[4:5])) - e.append(m2_expr.ExprAff(zf, tmp[6:7])) - e.append(m2_expr.ExprAff(nf, tmp[7:8])) + e.append(m2_expr.ExprAssign(cf, tmp[0:1])) + e.append(m2_expr.ExprAssign(pf, tmp[2:3])) + e.append(m2_expr.ExprAssign(af, tmp[4:5])) + e.append(m2_expr.ExprAssign(zf, tmp[6:7])) + e.append(m2_expr.ExprAssign(nf, tmp[7:8])) return e, [] def lar(_, instr, dst, src): e = [] - e.append(m2_expr.ExprAff(dst, m2_expr.ExprOp('access_segment', src))) - e.append(m2_expr.ExprAff(zf, m2_expr.ExprOp('access_segment_ok', src))) + e.append(m2_expr.ExprAssign(dst, m2_expr.ExprOp('access_segment', src))) + e.append(m2_expr.ExprAssign(zf, m2_expr.ExprOp('access_segment_ok', src))) return e, [] def lsl(_, instr, dst, src): e = [] - e.append(m2_expr.ExprAff(dst, m2_expr.ExprOp('load_segment_limit', src))) - e.append(m2_expr.ExprAff(zf, m2_expr.ExprOp('load_segment_limit_ok', src))) + e.append(m2_expr.ExprAssign(dst, m2_expr.ExprOp('load_segment_limit', src))) + e.append(m2_expr.ExprAssign(zf, m2_expr.ExprOp('load_segment_limit_ok', src))) return e, [] @@ -3626,7 +3626,7 @@ def fnclex(_, instr): def l_str(_, instr, dst): e = [] - e.append(m2_expr.ExprAff(dst, m2_expr.ExprOp('load_tr_segment_selector', + e.append(m2_expr.ExprAssign(dst, m2_expr.ExprOp('load_tr_segment_selector', m2_expr.ExprInt(0, 32)))) return e, [] @@ -3634,57 +3634,57 @@ def l_str(_, instr, dst): def movd(_, instr, dst, src): e = [] if dst in regs_mm_expr: - e.append(m2_expr.ExprAff( + e.append(m2_expr.ExprAssign( dst, m2_expr.ExprCompose(src, m2_expr.ExprInt(0, 32)))) elif dst in regs_xmm_expr: - e.append(m2_expr.ExprAff( + e.append(m2_expr.ExprAssign( dst, m2_expr.ExprCompose(src, m2_expr.ExprInt(0, 96)))) else: - e.append(m2_expr.ExprAff(dst, src[:32])) + e.append(m2_expr.ExprAssign(dst, src[:32])) return e, [] def movdqu(_, instr, dst, src): # XXX TODO alignement check - return [m2_expr.ExprAff(dst, src)], [] + return [m2_expr.ExprAssign(dst, src)], [] def movapd(_, instr, dst, src): # XXX TODO alignement check - return [m2_expr.ExprAff(dst, src)], [] + return [m2_expr.ExprAssign(dst, src)], [] def andps(_, instr, dst, src): e = [] - e.append(m2_expr.ExprAff(dst, m2_expr.ExprOp('&', dst, src))) + e.append(m2_expr.ExprAssign(dst, m2_expr.ExprOp('&', dst, src))) return e, [] def andnps(_, instr, dst, src): e = [] - e.append(m2_expr.ExprAff(dst, m2_expr.ExprOp('&', dst ^ dst.mask, src))) + e.append(m2_expr.ExprAssign(dst, m2_expr.ExprOp('&', dst ^ dst.mask, src))) return e, [] def orps(_, instr, dst, src): e = [] - e.append(m2_expr.ExprAff(dst, m2_expr.ExprOp('|', dst, src))) + e.append(m2_expr.ExprAssign(dst, m2_expr.ExprOp('|', dst, src))) return e, [] def xorps(_, instr, dst, src): e = [] - e.append(m2_expr.ExprAff(dst, m2_expr.ExprOp('^', dst, src))) + e.append(m2_expr.ExprAssign(dst, m2_expr.ExprOp('^', dst, src))) return e, [] def rdmsr(ir, instr): - e = [m2_expr.ExprAff(exception_flags,m2_expr.ExprInt(EXCEPT_PRIV_INSN, 32))] + e = [m2_expr.ExprAssign(exception_flags,m2_expr.ExprInt(EXCEPT_PRIV_INSN, 32))] return e, [] def wrmsr(ir, instr): - e = [m2_expr.ExprAff(exception_flags,m2_expr.ExprInt(EXCEPT_PRIV_INSN, 32))] + e = [m2_expr.ExprAssign(exception_flags,m2_expr.ExprInt(EXCEPT_PRIV_INSN, 32))] return e, [] # MMX/SSE/AVX operations @@ -3703,7 +3703,7 @@ def vec_op_clip(op, size, callback=None): result = m2_expr.ExprOp(op, dst[:size], src[:size]) if callback is not None: result = callback(result) - return [m2_expr.ExprAff(dst[:size], result)], [] + return [m2_expr.ExprAssign(dst[:size], result)], [] return vec_op_clip_instr # Generic vertical operation @@ -3734,7 +3734,7 @@ def __vec_vertical_instr_gen(op, elt_size, sem, apply_on_output): if isinstance(src, m2_expr.ExprMem): src = ir.ExprMem(src.arg, dst.size) reg_size = dst.size - e.append(m2_expr.ExprAff(dst, sem(op, elt_size, reg_size, dst, src, + e.append(m2_expr.ExprAssign(dst, sem(op, elt_size, reg_size, dst, src, apply_on_output))) return e, [] return vec_instr @@ -3839,16 +3839,16 @@ pmulhq = vec_vertical_instr('*', 64, lambda x: _keep_mul_high(x, signed=True)) def pmuludq(ir, instr, dst, src): e = [] if dst.size == 64: - e.append(m2_expr.ExprAff( + e.append(m2_expr.ExprAssign( dst, src[:32].zeroExtend(64) * dst[:32].zeroExtend(64) )) elif dst.size == 128: - e.append(m2_expr.ExprAff( + e.append(m2_expr.ExprAssign( dst[:64], src[:32].zeroExtend(64) * dst[:32].zeroExtend(64) )) - e.append(m2_expr.ExprAff( + e.append(m2_expr.ExprAssign( dst[64:], src[64:96].zeroExtend(64) * dst[64:96].zeroExtend(64) )) @@ -3870,7 +3870,7 @@ def pmaddwd(ir, instr, dst, src): base += sizesrc mul2 = src[base: base + sizesrc].signExtend(sizedst) * dst[base: base + sizesrc].signExtend(sizedst) out.append(mul1 + mul2) - return [m2_expr.ExprAff(dst, m2_expr.ExprCompose(*out))], [] + return [m2_expr.ExprAssign(dst, m2_expr.ExprCompose(*out))], [] def _absolute(expr): @@ -3895,7 +3895,7 @@ def psadbw(ir, instr, dst, src): out_dst.append(m2_expr.ExprOp("+", *out)) out_dst.append(m2_expr.ExprInt(0, 64 - sizedst)) - return [m2_expr.ExprAff(dst, m2_expr.ExprCompose(*out_dst))], [] + return [m2_expr.ExprAssign(dst, m2_expr.ExprCompose(*out_dst))], [] def _average(expr): assert expr.is_op("avg") and len(expr.args) == 2 @@ -4031,7 +4031,7 @@ def pand(_, instr, dst, src): e = [] result = dst & src # No flag affected - e.append(m2_expr.ExprAff(dst, result)) + e.append(m2_expr.ExprAssign(dst, result)) return e, [] @@ -4039,21 +4039,21 @@ def pandn(_, instr, dst, src): e = [] result = (dst ^ dst.mask) & src # No flag affected - e.append(m2_expr.ExprAff(dst, result)) + e.append(m2_expr.ExprAssign(dst, result)) return e, [] def por(_, instr, dst, src): e = [] result = dst | src - e.append(m2_expr.ExprAff(dst, result)) + e.append(m2_expr.ExprAssign(dst, result)) return e, [] def cvtdq2pd(_, instr, dst, src): e = [] e.append( - m2_expr.ExprAff( + m2_expr.ExprAssign( dst[:64], m2_expr.ExprOp( 'sint_to_fp', @@ -4062,7 +4062,7 @@ def cvtdq2pd(_, instr, dst, src): ) ) e.append( - m2_expr.ExprAff( + m2_expr.ExprAssign( dst[64:128], m2_expr.ExprOp( 'sint_to_fp', @@ -4076,49 +4076,49 @@ def cvtdq2pd(_, instr, dst, src): def cvtdq2ps(_, instr, dst, src): e = [] e.append( - m2_expr.ExprAff(dst[:32], m2_expr.ExprOp('sint_to_fp', src[:32]))) + m2_expr.ExprAssign(dst[:32], m2_expr.ExprOp('sint_to_fp', src[:32]))) e.append( - m2_expr.ExprAff(dst[32:64], m2_expr.ExprOp('sint_to_fp', src[32:64]))) + m2_expr.ExprAssign(dst[32:64], m2_expr.ExprOp('sint_to_fp', src[32:64]))) e.append( - m2_expr.ExprAff(dst[64:96], m2_expr.ExprOp('sint_to_fp', src[64:96]))) + m2_expr.ExprAssign(dst[64:96], m2_expr.ExprOp('sint_to_fp', src[64:96]))) e.append( - m2_expr.ExprAff(dst[96:128], m2_expr.ExprOp('sint_to_fp', src[96:128]))) + m2_expr.ExprAssign(dst[96:128], m2_expr.ExprOp('sint_to_fp', src[96:128]))) return e, [] def cvtpd2dq(_, instr, dst, src): e = [] e.append( - m2_expr.ExprAff(dst[:32], m2_expr.ExprOp('fp_to_sint32', src[:64]))) + m2_expr.ExprAssign(dst[:32], m2_expr.ExprOp('fp_to_sint32', src[:64]))) e.append( - m2_expr.ExprAff(dst[32:64], m2_expr.ExprOp('fp_to_sint32', src[64:128]))) - e.append(m2_expr.ExprAff(dst[64:128], m2_expr.ExprInt(0, 64))) + m2_expr.ExprAssign(dst[32:64], m2_expr.ExprOp('fp_to_sint32', src[64:128]))) + e.append(m2_expr.ExprAssign(dst[64:128], m2_expr.ExprInt(0, 64))) return e, [] def cvtpd2pi(_, instr, dst, src): e = [] e.append( - m2_expr.ExprAff(dst[:32], m2_expr.ExprOp('fp_to_sint32', src[:64]))) + m2_expr.ExprAssign(dst[:32], m2_expr.ExprOp('fp_to_sint32', src[:64]))) e.append( - m2_expr.ExprAff(dst[32:64], m2_expr.ExprOp('fp_to_sint32', src[64:128]))) + m2_expr.ExprAssign(dst[32:64], m2_expr.ExprOp('fp_to_sint32', src[64:128]))) return e, [] def cvtpd2ps(_, instr, dst, src): e = [] e.append( - m2_expr.ExprAff(dst[:32], m2_expr.ExprOp('fpconvert_fp32', src[:64]))) + m2_expr.ExprAssign(dst[:32], m2_expr.ExprOp('fpconvert_fp32', src[:64]))) e.append( - m2_expr.ExprAff(dst[32:64], m2_expr.ExprOp('fpconvert_fp32', src[64:128]))) - e.append(m2_expr.ExprAff(dst[64:128], m2_expr.ExprInt(0, 64))) + m2_expr.ExprAssign(dst[32:64], m2_expr.ExprOp('fpconvert_fp32', src[64:128]))) + e.append(m2_expr.ExprAssign(dst[64:128], m2_expr.ExprInt(0, 64))) return e, [] def cvtpi2pd(_, instr, dst, src): e = [] e.append( - m2_expr.ExprAff( + m2_expr.ExprAssign( dst[:64], m2_expr.ExprOp( 'sint_to_fp', @@ -4127,7 +4127,7 @@ def cvtpi2pd(_, instr, dst, src): ) ) e.append( - m2_expr.ExprAff( + m2_expr.ExprAssign( dst[64:128], m2_expr.ExprOp( 'sint_to_fp', @@ -4140,61 +4140,61 @@ def cvtpi2pd(_, instr, dst, src): def cvtpi2ps(_, instr, dst, src): e = [] e.append( - m2_expr.ExprAff(dst[:32], m2_expr.ExprOp('sint_to_fp', src[:32]))) + m2_expr.ExprAssign(dst[:32], m2_expr.ExprOp('sint_to_fp', src[:32]))) e.append( - m2_expr.ExprAff(dst[32:64], m2_expr.ExprOp('sint_to_fp', src[32:64]))) + m2_expr.ExprAssign(dst[32:64], m2_expr.ExprOp('sint_to_fp', src[32:64]))) return e, [] def cvtps2dq(_, instr, dst, src): e = [] e.append( - m2_expr.ExprAff(dst[:32], m2_expr.ExprOp('fp_to_sint32', src[:32]))) + m2_expr.ExprAssign(dst[:32], m2_expr.ExprOp('fp_to_sint32', src[:32]))) e.append( - m2_expr.ExprAff(dst[32:64], m2_expr.ExprOp('fp_to_sint32', src[32:64]))) + m2_expr.ExprAssign(dst[32:64], m2_expr.ExprOp('fp_to_sint32', src[32:64]))) e.append( - m2_expr.ExprAff(dst[64:96], m2_expr.ExprOp('fp_to_sint32', src[64:96]))) + m2_expr.ExprAssign(dst[64:96], m2_expr.ExprOp('fp_to_sint32', src[64:96]))) e.append( - m2_expr.ExprAff(dst[96:128], m2_expr.ExprOp('fp_to_sint32', src[96:128]))) + m2_expr.ExprAssign(dst[96:128], m2_expr.ExprOp('fp_to_sint32', src[96:128]))) return e, [] def cvtps2pd(_, instr, dst, src): e = [] e.append( - m2_expr.ExprAff(dst[:64], m2_expr.ExprOp('fpconvert_fp64', src[:32]))) + m2_expr.ExprAssign(dst[:64], m2_expr.ExprOp('fpconvert_fp64', src[:32]))) e.append( - m2_expr.ExprAff(dst[64:128], m2_expr.ExprOp('fpconvert_fp64', src[32:64]))) + m2_expr.ExprAssign(dst[64:128], m2_expr.ExprOp('fpconvert_fp64', src[32:64]))) return e, [] def cvtps2pi(_, instr, dst, src): e = [] e.append( - m2_expr.ExprAff(dst[:32], m2_expr.ExprOp('fp_to_sint32', src[:32]))) + m2_expr.ExprAssign(dst[:32], m2_expr.ExprOp('fp_to_sint32', src[:32]))) e.append( - m2_expr.ExprAff(dst[32:64], m2_expr.ExprOp('fp_to_sint32', src[32:64]))) + m2_expr.ExprAssign(dst[32:64], m2_expr.ExprOp('fp_to_sint32', src[32:64]))) return e, [] def cvtsd2si(_, instr, dst, src): e = [] e.append( - m2_expr.ExprAff(dst[:32], m2_expr.ExprOp('fp_to_sint32', src[:64]))) + m2_expr.ExprAssign(dst[:32], m2_expr.ExprOp('fp_to_sint32', src[:64]))) return e, [] def cvtsd2ss(_, instr, dst, src): e = [] e.append( - m2_expr.ExprAff(dst[:32], m2_expr.ExprOp('fpconvert_fp32', src[:64]))) + m2_expr.ExprAssign(dst[:32], m2_expr.ExprOp('fpconvert_fp32', src[:64]))) return e, [] def cvtsi2sd(_, instr, dst, src): e = [] e.append( - m2_expr.ExprAff( + m2_expr.ExprAssign( dst[:64], m2_expr.ExprOp( 'sint_to_fp', @@ -4208,21 +4208,21 @@ def cvtsi2sd(_, instr, dst, src): def cvtsi2ss(_, instr, dst, src): e = [] e.append( - m2_expr.ExprAff(dst[:32], m2_expr.ExprOp('sint_to_fp', src[:32]))) + m2_expr.ExprAssign(dst[:32], m2_expr.ExprOp('sint_to_fp', src[:32]))) return e, [] def cvtss2sd(_, instr, dst, src): e = [] e.append( - m2_expr.ExprAff(dst[:64], m2_expr.ExprOp('fpconvert_fp64', src[:32]))) + m2_expr.ExprAssign(dst[:64], m2_expr.ExprOp('fpconvert_fp64', src[:32]))) return e, [] def cvtss2si(_, instr, dst, src): e = [] e.append( - m2_expr.ExprAff(dst[:32], m2_expr.ExprOp('fp_to_sint32', src[:32]))) + m2_expr.ExprAssign(dst[:32], m2_expr.ExprOp('fp_to_sint32', src[:32]))) return e, [] @@ -4236,7 +4236,7 @@ def _cvtt_tpl(dst, src, numbers, double): else: tmp_src = src[i*32:i*32 + 32] - e.append(m2_expr.ExprAff( + e.append(m2_expr.ExprAssign( dst[i*32:i*32 + 32], m2_expr.ExprOp('fp_to_sint32', m2_expr.ExprOp( 'fpround_towardszero', @@ -4249,7 +4249,7 @@ def cvttpd2pi(_, instr, dst, src): def cvttpd2dq(_, instr, dst, src): e = _cvtt_tpl(dst, src, [0, 1], double=True) - e.append(m2_expr.ExprAff(dst[64:128], m2_expr.ExprInt(0, 64))) + e.append(m2_expr.ExprAssign(dst[64:128], m2_expr.ExprInt(0, 64))) return e, [] def cvttsd2si(_, instr, dst, src): @@ -4268,44 +4268,44 @@ def movss(_, instr, dst, src): e = [] if not isinstance(dst, m2_expr.ExprMem) and not isinstance(src, m2_expr.ExprMem): # Source and Destination xmm - e.append(m2_expr.ExprAff(dst[:32], src[:32])) + e.append(m2_expr.ExprAssign(dst[:32], src[:32])) elif not isinstance(src, m2_expr.ExprMem) and isinstance(dst, m2_expr.ExprMem): # Source XMM Destination Mem - e.append(m2_expr.ExprAff(dst, src[:32])) + e.append(m2_expr.ExprAssign(dst, src[:32])) else: # Source Mem Destination XMM - e.append(m2_expr.ExprAff( + e.append(m2_expr.ExprAssign( dst, m2_expr.ExprCompose(src, m2_expr.ExprInt(0, 96)))) return e, [] def ucomiss(_, instr, src1, src2): e = [] - e.append(m2_expr.ExprAff(zf, m2_expr.ExprOp( + e.append(m2_expr.ExprAssign(zf, m2_expr.ExprOp( 'ucomiss_zf', src1[:32], src2[:32]))) - e.append(m2_expr.ExprAff(pf, m2_expr.ExprOp( + e.append(m2_expr.ExprAssign(pf, m2_expr.ExprOp( 'ucomiss_pf', src1[:32], src2[:32]))) - e.append(m2_expr.ExprAff(cf, m2_expr.ExprOp( + e.append(m2_expr.ExprAssign(cf, m2_expr.ExprOp( 'ucomiss_cf', src1[:32], src2[:32]))) - e.append(m2_expr.ExprAff(of, m2_expr.ExprInt(0, 1))) - e.append(m2_expr.ExprAff(af, m2_expr.ExprInt(0, 1))) - e.append(m2_expr.ExprAff(nf, m2_expr.ExprInt(0, 1))) + e.append(m2_expr.ExprAssign(of, m2_expr.ExprInt(0, 1))) + e.append(m2_expr.ExprAssign(af, m2_expr.ExprInt(0, 1))) + e.append(m2_expr.ExprAssign(nf, m2_expr.ExprInt(0, 1))) return e, [] def ucomisd(_, instr, src1, src2): e = [] - e.append(m2_expr.ExprAff(zf, m2_expr.ExprOp( + e.append(m2_expr.ExprAssign(zf, m2_expr.ExprOp( 'ucomisd_zf', src1[:64], src2[:64]))) - e.append(m2_expr.ExprAff(pf, m2_expr.ExprOp( + e.append(m2_expr.ExprAssign(pf, m2_expr.ExprOp( 'ucomisd_pf', src1[:64], src2[:64]))) - e.append(m2_expr.ExprAff(cf, m2_expr.ExprOp( + e.append(m2_expr.ExprAssign(cf, m2_expr.ExprOp( 'ucomisd_cf', src1[:64], src2[:64]))) - e.append(m2_expr.ExprAff(of, m2_expr.ExprInt(0, 1))) - e.append(m2_expr.ExprAff(af, m2_expr.ExprInt(0, 1))) - e.append(m2_expr.ExprAff(nf, m2_expr.ExprInt(0, 1))) + e.append(m2_expr.ExprAssign(of, m2_expr.ExprInt(0, 1))) + e.append(m2_expr.ExprAssign(af, m2_expr.ExprInt(0, 1))) + e.append(m2_expr.ExprAssign(nf, m2_expr.ExprInt(0, 1))) return e, [] @@ -4322,7 +4322,7 @@ def pshufb(_, instr, dst, src): index = src[ i:i + bit_l].zeroExtend(dst.size) << m2_expr.ExprInt(3, dst.size) value = (dst >> index)[:8] - e.append(m2_expr.ExprAff(dst[i:i + 8], + e.append(m2_expr.ExprAssign(dst[i:i + 8], m2_expr.ExprCond(src[i + 7:i + 8], m2_expr.ExprInt(0, 8), value))) @@ -4337,7 +4337,7 @@ def pshufd(_, instr, dst, src, imm): # shift is 2 bits long, expr.size is 128 # => shift + 32 <= src.size out.append(src[shift: shift + 32]) - return [m2_expr.ExprAff(dst, m2_expr.ExprCompose(*out))], [] + return [m2_expr.ExprAssign(dst, m2_expr.ExprCompose(*out))], [] def pshuflw(_, instr, dst, src, imm): @@ -4347,7 +4347,7 @@ def pshuflw(_, instr, dst, src, imm): shift = ((control >> (i * 2)) & 3) * 16 out.append(src[shift: shift + 16]) out.append(src[64:]) - return [m2_expr.ExprAff(dst, m2_expr.ExprCompose(*out))], [] + return [m2_expr.ExprAssign(dst, m2_expr.ExprCompose(*out))], [] def pshufhw(_, instr, dst, src, imm): @@ -4356,7 +4356,7 @@ def pshufhw(_, instr, dst, src, imm): for i in xrange(4): shift = ((control >> (i * 2)) & 3) * 16 out.append(src[shift + 64: shift + 16 + 64]) - return [m2_expr.ExprAff(dst, m2_expr.ExprCompose(*out))], [] + return [m2_expr.ExprAssign(dst, m2_expr.ExprCompose(*out))], [] def ps_rl_ll(ir, instr, dst, src, op, size): @@ -4378,7 +4378,7 @@ def ps_rl_ll(ir, instr, dst, src, op, size): out = [] for i in xrange(0, dst.size, size): out.append(m2_expr.ExprOp(op, dst[i:i + size], count)) - return [m2_expr.ExprAff(dst, m2_expr.ExprCompose(*out))], [] + return [m2_expr.ExprAssign(dst, m2_expr.ExprCompose(*out))], [] def psrlw(ir, instr, dst, src): @@ -4418,18 +4418,18 @@ def pslldq(_, instr, dst, src): e = [] count = int(src) if count > 15: - return [m2_expr.ExprAff(dst, m2_expr.ExprInt(0, dst.size))], [] + return [m2_expr.ExprAssign(dst, m2_expr.ExprInt(0, dst.size))], [] else: - return [m2_expr.ExprAff(dst, dst << m2_expr.ExprInt(8 * count, dst.size))], [] + return [m2_expr.ExprAssign(dst, dst << m2_expr.ExprInt(8 * count, dst.size))], [] def psrldq(_, instr, dst, src): assert src.is_int() count = int(src) if count > 15: - return [m2_expr.ExprAff(dst, m2_expr.ExprInt(0, dst.size))], [] + return [m2_expr.ExprAssign(dst, m2_expr.ExprInt(0, dst.size))], [] else: - return [m2_expr.ExprAff(dst, dst >> m2_expr.ExprInt(8 * count, dst.size))], [] + return [m2_expr.ExprAssign(dst, dst >> m2_expr.ExprInt(8 * count, dst.size))], [] def iret(ir, instr): @@ -4447,7 +4447,7 @@ def pcmpeq(_, instr, dst, src, size): e = [] for i in xrange(0, dst.size, size): test = m2_expr.expr_is_equal(dst[i:i + size], src[i:i + size]) - e.append(m2_expr.ExprAff(dst[i:i + size], + e.append(m2_expr.ExprAssign(dst[i:i + size], m2_expr.ExprCond(test, m2_expr.ExprInt(-1, size), m2_expr.ExprInt(0, size)))) @@ -4458,7 +4458,7 @@ def pcmpgt(_, instr, dst, src, size): e = [] for i in xrange(0, dst.size, size): test = m2_expr.expr_is_signed_greater(dst[i:i + size], src[i:i + size]) - e.append(m2_expr.ExprAff(dst[i:i + size], + e.append(m2_expr.ExprAssign(dst[i:i + size], m2_expr.ExprCond(test, m2_expr.ExprInt(-1, size), m2_expr.ExprInt(0, size)))) @@ -4500,7 +4500,7 @@ def punpck(_, instr, dst, src, size, off): for i in xrange(dst.size / (2 * size)): slices.append(dst[size * i + off: size * i + off + size]) slices.append(src[size * i + off: size * i + off + size]) - e.append(m2_expr.ExprAff(dst, m2_expr.ExprCompose(*slices))) + e.append(m2_expr.ExprAssign(dst, m2_expr.ExprCompose(*slices))) return e, [] @@ -4545,7 +4545,7 @@ def pinsr(_, instr, dst, src, imm, size): 64: 0x1}[size] sel = (int(imm) & mask) * size - e.append(m2_expr.ExprAff(dst[sel:sel + size], src[:size])) + e.append(m2_expr.ExprAssign(dst[sel:sel + size], src[:size])) return e, [] @@ -4575,7 +4575,7 @@ def pextr(_, instr, dst, src, imm, size): 64: 0x1}[size] sel = (int(imm) & mask) * size - e.append(m2_expr.ExprAff(dst, src[sel:sel + size].zeroExtend(dst.size))) + e.append(m2_expr.ExprAssign(dst, src[sel:sel + size].zeroExtend(dst.size))) return e, [] @@ -4599,49 +4599,49 @@ def pextrq(ir, instr, dst, src, imm): def unpckhps(_, instr, dst, src): e = [] src = m2_expr.ExprCompose(dst[64:96], src[64:96], dst[96:128], src[96:128]) - e.append(m2_expr.ExprAff(dst, src)) + e.append(m2_expr.ExprAssign(dst, src)) return e, [] def unpckhpd(_, instr, dst, src): e = [] src = m2_expr.ExprCompose(dst[64:128], src[64:128]) - e.append(m2_expr.ExprAff(dst, src)) + e.append(m2_expr.ExprAssign(dst, src)) return e, [] def unpcklps(_, instr, dst, src): e = [] src = m2_expr.ExprCompose(dst[0:32], src[0:32], dst[32:64], src[32:64]) - e.append(m2_expr.ExprAff(dst, src)) + e.append(m2_expr.ExprAssign(dst, src)) return e, [] def unpcklpd(_, instr, dst, src): e = [] src = m2_expr.ExprCompose(dst[0:64], src[0:64]) - e.append(m2_expr.ExprAff(dst, src)) + e.append(m2_expr.ExprAssign(dst, src)) return e, [] def movlpd(_, instr, dst, src): e = [] - e.append(m2_expr.ExprAff(dst[:64], src[:64])) + e.append(m2_expr.ExprAssign(dst[:64], src[:64])) return e, [] def movlps(_, instr, dst, src): e = [] - e.append(m2_expr.ExprAff(dst[:64], src[:64])) + e.append(m2_expr.ExprAssign(dst[:64], src[:64])) return e, [] def movhpd(_, instr, dst, src): e = [] if src.size == 64: - e.append(m2_expr.ExprAff(dst[64:128], src)) + e.append(m2_expr.ExprAssign(dst[64:128], src)) elif dst.size == 64: - e.append(m2_expr.ExprAff(dst, src[64:128])) + e.append(m2_expr.ExprAssign(dst, src[64:128])) else: raise RuntimeError("bad encoding!") return e, [] @@ -4649,25 +4649,25 @@ def movhpd(_, instr, dst, src): def movlhps(_, instr, dst, src): e = [] - e.append(m2_expr.ExprAff(dst[64:128], src[:64])) + e.append(m2_expr.ExprAssign(dst[64:128], src[:64])) return e, [] def movhlps(_, instr, dst, src): e = [] - e.append(m2_expr.ExprAff(dst[:64], src[64:128])) + e.append(m2_expr.ExprAssign(dst[:64], src[64:128])) return e, [] def movdq2q(_, instr, dst, src): e = [] - e.append(m2_expr.ExprAff(dst, src[:64])) + e.append(m2_expr.ExprAssign(dst, src[:64])) return e, [] def movq2dq(_, instr, dst, src): e = [] - e.append(m2_expr.ExprAff(dst, src[:64].zeroExtend(dst.size))) + e.append(m2_expr.ExprAssign(dst, src[:64].zeroExtend(dst.size))) return e, [] @@ -4678,7 +4678,7 @@ def sqrt_gen(_, instr, dst, src, size): out.append(m2_expr.ExprOp('fsqrt', src[i * size: (i + 1) * size])) src = m2_expr.ExprCompose(*out) - e.append(m2_expr.ExprAff(dst, src)) + e.append(m2_expr.ExprAssign(dst, src)) return e, [] @@ -4692,7 +4692,7 @@ def sqrtps(ir, instr, dst, src): def sqrtsd(_, instr, dst, src): e = [] - e.append(m2_expr.ExprAff(dst[:64], + e.append(m2_expr.ExprAssign(dst[:64], m2_expr.ExprOp('fsqrt', src[:64]))) return e, [] @@ -4700,7 +4700,7 @@ def sqrtsd(_, instr, dst, src): def sqrtss(_, instr, dst, src): e = [] - e.append(m2_expr.ExprAff(dst[:32], + e.append(m2_expr.ExprAssign(dst[:32], m2_expr.ExprOp('fsqrt', src[:32]))) return e, [] @@ -4712,14 +4712,14 @@ def pmovmskb(_, instr, dst, src): for i in xrange(src.size / 8): out.append(src[8 * i + 7:8 * (i + 1)]) src = m2_expr.ExprCompose(*out) - e.append(m2_expr.ExprAff(dst, src.zeroExtend(dst.size))) + e.append(m2_expr.ExprAssign(dst, src.zeroExtend(dst.size))) return e, [] def smsw(ir, instr, dst): e = [] LOG_X86_SEM.warning("DEFAULT SMSW %s!!", str(dst)) - e.append(m2_expr.ExprAff(dst, m2_expr.ExprInt(0x80050033, 32)[:dst.size])) + e.append(m2_expr.ExprAssign(dst, m2_expr.ExprInt(0x80050033, 32)[:dst.size])) return e, [] @@ -4744,7 +4744,7 @@ def palignr(ir, instr, dst, src, imm): dst[:shift], ) - return [m2_expr.ExprAff(dst, result)], [] + return [m2_expr.ExprAssign(dst, result)], [] def _signed_saturation(expr, dst_size): @@ -4816,7 +4816,7 @@ def packsswb(ir, instr, dst, src): for source in [dst, src]: for start in xrange(0, dst.size, 16): out.append(_signed_saturation(source[start:start + 16], 8)) - return [m2_expr.ExprAff(dst, m2_expr.ExprCompose(*out))], [] + return [m2_expr.ExprAssign(dst, m2_expr.ExprCompose(*out))], [] def packssdw(ir, instr, dst, src): @@ -4824,7 +4824,7 @@ def packssdw(ir, instr, dst, src): for source in [dst, src]: for start in xrange(0, dst.size, 32): out.append(_signed_saturation(source[start:start + 32], 16)) - return [m2_expr.ExprAff(dst, m2_expr.ExprCompose(*out))], [] + return [m2_expr.ExprAssign(dst, m2_expr.ExprCompose(*out))], [] def packuswb(ir, instr, dst, src): @@ -4832,7 +4832,7 @@ def packuswb(ir, instr, dst, src): for source in [dst, src]: for start in xrange(0, dst.size, 16): out.append(_unsigned_saturation(source[start:start + 16], 8)) - return [m2_expr.ExprAff(dst, m2_expr.ExprCompose(*out))], [] + return [m2_expr.ExprAssign(dst, m2_expr.ExprCompose(*out))], [] def _saturation_sub_unsigned(expr): @@ -4912,7 +4912,7 @@ def maskmovq(ir, instr, src, mask): cur_label = check_labels[i] next_check_label = check_labels[i + 1] if (i + 1) < len(check_labels) else loc_next_expr write_label = write_labels[i] - check = m2_expr.ExprAff(ir.IRDst, + check = m2_expr.ExprAssign(ir.IRDst, m2_expr.ExprCond(bit, write_label, next_check_label)) @@ -4926,13 +4926,13 @@ def maskmovq(ir, instr, src, mask): write_addr = dst_addr + m2_expr.ExprInt(i, dst_addr.size) # @8[DI/EDI/RDI + i] = src[byte i] - write_mem = m2_expr.ExprAff(m2_expr.ExprMem(write_addr, 8), + write_mem = m2_expr.ExprAssign(m2_expr.ExprMem(write_addr, 8), src[start: start + 8]) - jump = m2_expr.ExprAff(ir.IRDst, next_check_label) + jump = m2_expr.ExprAssign(ir.IRDst, next_check_label) blks.append(IRBlock(cur_label.loc_key, [AssignBlock([write_mem, jump], instr)])) # If mask is null, bypass all - e = [m2_expr.ExprAff(ir.IRDst, m2_expr.ExprCond(mask, + e = [m2_expr.ExprAssign(ir.IRDst, m2_expr.ExprCond(mask, check_labels[0], loc_next_expr))] return e, blks @@ -4945,7 +4945,7 @@ def emms(ir, instr): # Common value without too many option, 0x1fa0 STMXCSR_VALUE = 0x1fa0 def stmxcsr(ir, instr, dst): - return [m2_expr.ExprAff(dst, m2_expr.ExprInt(STMXCSR_VALUE, dst.size))], [] + return [m2_expr.ExprAssign(dst, m2_expr.ExprInt(STMXCSR_VALUE, dst.size))], [] def ldmxcsr(ir, instr, dst): # Implemented as a NOP @@ -4977,7 +4977,7 @@ def shufps(ir, instr, dst, src, imm8): else: source = src out.append(_select4(source, (control >> (i * 2)) & 3)) - return [m2_expr.ExprAff(dst, m2_expr.ExprCompose(*out))], [] + return [m2_expr.ExprAssign(dst, m2_expr.ExprCompose(*out))], [] def shufpd(ir, instr, dst, src, imm8): @@ -4985,19 +4985,19 @@ def shufpd(ir, instr, dst, src, imm8): control = int(imm8) out.append(dst[64:] if control & 1 else dst[:64]) out.append(src[64:] if control & 2 else src[:64]) - return [m2_expr.ExprAff(dst, m2_expr.ExprCompose(*out))], [] + return [m2_expr.ExprAssign(dst, m2_expr.ExprCompose(*out))], [] def movmskps(ir, instr, dst, src): out = [] for i in xrange(4): out.append(src[(32 * i) + 31:(32 * i) + 32]) - return [m2_expr.ExprAff(dst, m2_expr.ExprCompose(*out).zeroExtend(dst.size))], [] + return [m2_expr.ExprAssign(dst, m2_expr.ExprCompose(*out).zeroExtend(dst.size))], [] def movmskpd(ir, instr, dst, src): out = [] for i in xrange(2): out.append(src[(64 * i) + 63:(64 * i) + 64]) - return [m2_expr.ExprAff(dst, m2_expr.ExprCompose(*out).zeroExtend(dst.size))], [] + return [m2_expr.ExprAssign(dst, m2_expr.ExprCompose(*out).zeroExtend(dst.size))], [] mnemo_func = {'mov': mov, @@ -5692,17 +5692,17 @@ class ir_x86_16(IntermediateRepresentation): for irblock in extra_ir] cond_bloc = [] - cond_bloc.append(m2_expr.ExprAff(c_reg, + cond_bloc.append(m2_expr.ExprAssign(c_reg, c_reg - m2_expr.ExprInt(1, c_reg.size))) - cond_bloc.append(m2_expr.ExprAff(self.IRDst, m2_expr.ExprCond(c_cond, + cond_bloc.append(m2_expr.ExprAssign(self.IRDst, m2_expr.ExprCond(c_cond, loc_skip_expr, loc_do_expr))) cond_bloc = IRBlock(loc_end, [AssignBlock(cond_bloc, instr)]) e_do = instr_ir c = IRBlock(loc_do, [AssignBlock(e_do, instr)]) - e_n = [m2_expr.ExprAff(self.IRDst, m2_expr.ExprCond(c_reg, loc_do_expr, + e_n = [m2_expr.ExprAssign(self.IRDst, m2_expr.ExprCond(c_reg, loc_do_expr, loc_skip_expr))] return e_n, [cond_bloc, c] + new_extra_ir @@ -5712,7 +5712,7 @@ class ir_x86_16(IntermediateRepresentation): def expraff_fix_regs_for_mode(self, e, mode=64): dst = self.expr_fix_regs_for_mode(e.dst, mode) src = self.expr_fix_regs_for_mode(e.src, mode) - return m2_expr.ExprAff(dst, src) + return m2_expr.ExprAssign(dst, src) def irbloc_fix_regs_for_mode(self, irblock, mode=64): irs = [] @@ -5771,7 +5771,7 @@ class ir_x86_64(ir_x86_16): if dst != self.pc: dst = dst.replace_expr(pc_fixed) src = src.replace_expr(pc_fixed) - instr_ir[i] = m2_expr.ExprAff(dst, src) + instr_ir[i] = m2_expr.ExprAssign(dst, src) for idx, irblock in enumerate(extra_ir): extra_ir[idx] = irblock.modify_exprs(lambda expr: expr.replace_expr(pc_fixed) \ diff --git a/miasm2/core/sembuilder.py b/miasm2/core/sembuilder.py index ab1af953..67c6c257 100644 --- a/miasm2/core/sembuilder.py +++ b/miasm2/core/sembuilder.py @@ -161,7 +161,7 @@ class SemBuilder(object): """Recursive function transforming a @body to a block expression Return: - AST to append to body (real python statements) - - a list of blocks, ie list of affblock, ie list of ExprAff (AST)""" + - a list of blocks, ie list of affblock, ie list of ExprAssign (AST)""" # Init ## Real instructions @@ -188,7 +188,7 @@ class SemBuilder(object): dst.ctx = ast.Load() - res = ast.Call(func=ast.Name(id='ExprAff', + res = ast.Call(func=ast.Name(id='ExprAssign', ctx=ast.Load()), args=[dst, src], keywords=[], @@ -230,7 +230,7 @@ class SemBuilder(object): IRDst = ast.Attribute(value=ast.Name(id='ir', ctx=ast.Load()), attr='IRDst', ctx=ast.Load()) - blocks[-1][-1].append(ast.Call(func=ast.Name(id='ExprAff', + blocks[-1][-1].append(ast.Call(func=ast.Name(id='ExprAssign', ctx=ast.Load()), args=[IRDst, dst], keywords=[], @@ -248,7 +248,7 @@ class SemBuilder(object): raise RuntimeError("Imbricated if unimplemented") ## Close the last block - jmp_end = ast.Call(func=ast.Name(id='ExprAff', + jmp_end = ast.Call(func=ast.Name(id='ExprAssign', ctx=ast.Load()), args=[IRDst, loc_end], keywords=[], diff --git a/miasm2/expression/expression.py b/miasm2/expression/expression.py index d617a8fa..58ebda60 100644 --- a/miasm2/expression/expression.py +++ b/miasm2/expression/expression.py @@ -20,7 +20,7 @@ # - ExprInt # - ExprId # - ExprLoc -# - ExprAff +# - ExprAssign # - ExprCond # - ExprMem # - ExprOp @@ -50,7 +50,7 @@ TOK_POS_STRICT = "Spos" EXPRINT = 1 EXPRID = 2 EXPRLOC = 3 -EXPRAFF = 4 +EXPRASSIGN = 4 EXPRCOND = 5 EXPRMEM = 6 EXPROP = 7 @@ -675,9 +675,9 @@ class ExprLoc(Expr): return True -class ExprAff(Expr): +class ExprAssign(Expr): - """An ExprAff represent an affection from an Expression to another one. + """An ExprAssign represent an affection from an Expression to another one. Some use cases: - var1 <- 2 @@ -686,7 +686,7 @@ class ExprAff(Expr): __slots__ = Expr.__slots__ + ["_dst", "_src"] def __init__(self, dst, src): - """Create an ExprAff for dst <- src + """Create an ExprAssign for dst <- src @dst: Expr, affectation destination @src: Expr, affectation source """ @@ -696,10 +696,10 @@ class ExprAff(Expr): if dst.size != src.size: raise ValueError( - "sanitycheck: ExprAff args must have same size! %s" % + "sanitycheck: ExprAssign args must have same size! %s" % ([(str(arg), arg.size) for arg in [dst, src]])) - super(ExprAff, self).__init__(self.dst.size) + super(ExprAssign, self).__init__(self.dst.size) dst = property(lambda self: self._dst) src = property(lambda self: self._src) @@ -743,7 +743,7 @@ class ExprAff(Expr): return self._dst.get_w() def _exprhash(self): - return hash((EXPRAFF, hash(self._dst), hash(self._src))) + return hash((EXPRASSIGN, hash(self._dst), hash(self._src))) def _exprrepr(self): return "%s(%r, %r)" % (self.__class__.__name__, self._dst, self._src) @@ -759,10 +759,10 @@ class ExprAff(Expr): if dst == self._dst and src == self._src: return self else: - return ExprAff(dst, src) + return ExprAssign(dst, src) def copy(self): - return ExprAff(self._dst.copy(), self._src.copy()) + return ExprAssign(self._dst.copy(), self._src.copy()) def depth(self): return max(self._src.depth(), self._dst.depth()) + 1 @@ -777,6 +777,17 @@ class ExprAff(Expr): return True +class ExprAff(ExprAssign): + """ + DEPRECATED class. + Use ExprAssign instead of ExprAff + """ + + def __init__(self, dst, src): + warnings.warn('DEPRECATION WARNING: use ExprAssign instead of ExprAff') + super(ExprAff, self).__init__(dst, src) + + class ExprCond(Expr): """An ExprCond stand for a condition on an Expr @@ -1402,9 +1413,9 @@ def compare_exprs(expr1, expr2): if ret: return ret return cmp(expr1.size, expr2.size) - elif cls1 == ExprAff: + elif cls1 == ExprAssign: raise NotImplementedError( - "Comparaison from an ExprAff not yet implemented") + "Comparaison from an ExprAssign not yet implemented") elif cls2 == ExprCond: ret = compare_exprs(expr1.cond, expr2.cond) if ret: diff --git a/miasm2/expression/expression_helper.py b/miasm2/expression/expression_helper.py index 5de9e04f..7db41394 100644 --- a/miasm2/expression/expression_helper.py +++ b/miasm2/expression/expression_helper.py @@ -515,7 +515,7 @@ class CondConstraintZero(CondConstraint): operator = m2_expr.TOK_EQUAL def to_constraint(self): - return m2_expr.ExprAff(self.expr, m2_expr.ExprInt(0, self.expr.size)) + return m2_expr.ExprAssign(self.expr, m2_expr.ExprInt(0, self.expr.size)) class CondConstraintNotZero(CondConstraint): @@ -525,7 +525,7 @@ class CondConstraintNotZero(CondConstraint): def to_constraint(self): cst1, cst2 = m2_expr.ExprInt(0, 1), m2_expr.ExprInt(1, 1) - return m2_expr.ExprAff(cst1, m2_expr.ExprCond(self.expr, cst1, cst2)) + return m2_expr.ExprAssign(cst1, m2_expr.ExprCond(self.expr, cst1, cst2)) ConstrainedValue = collections.namedtuple("ConstrainedValue", @@ -568,7 +568,7 @@ def possible_values(expr): m2_expr.ExprMem(consval.value, expr.size)) for consval in possible_values(expr.arg)) - elif isinstance(expr, m2_expr.ExprAff): + elif isinstance(expr, m2_expr.ExprAssign): consvals.update(possible_values(expr.src)) # Special case: constraint insertion elif isinstance(expr, m2_expr.ExprCond): diff --git a/miasm2/expression/parser.py b/miasm2/expression/parser.py index cbfd58d0..71efc849 100644 --- a/miasm2/expression/parser.py +++ b/miasm2/expression/parser.py @@ -1,6 +1,6 @@ import pyparsing from miasm2.expression.expression import ExprInt, ExprId, ExprLoc, ExprSlice, \ - ExprMem, ExprCond, ExprCompose, ExprOp, ExprAff, LocKey + ExprMem, ExprCond, ExprCompose, ExprOp, ExprAssign, LocKey integer = pyparsing.Word(pyparsing.nums).setParseAction(lambda t: int(t[0])) @@ -22,7 +22,7 @@ STR_EXPRMEM = pyparsing.Suppress("ExprMem") STR_EXPRCOND = pyparsing.Suppress("ExprCond") STR_EXPRCOMPOSE = pyparsing.Suppress("ExprCompose") STR_EXPROP = pyparsing.Suppress("ExprOp") -STR_EXPRAFF = pyparsing.Suppress("ExprAff") +STR_EXPRASSIGN = pyparsing.Suppress("ExprAssign") LOCKEY = pyparsing.Suppress("LocKey") @@ -51,7 +51,7 @@ expr_mem = STR_EXPRMEM + LPARENTHESIS + expr + STR_COMMA + str_int + RPARENTHESI expr_cond = STR_EXPRCOND + LPARENTHESIS + expr + STR_COMMA + expr + STR_COMMA + expr + RPARENTHESIS expr_compose = STR_EXPRCOMPOSE + LPARENTHESIS + pyparsing.delimitedList(expr, delim=',') + RPARENTHESIS expr_op = STR_EXPROP + LPARENTHESIS + string + STR_COMMA + pyparsing.delimitedList(expr, delim=',') + RPARENTHESIS -expr_aff = STR_EXPRAFF + LPARENTHESIS + expr + STR_COMMA + expr + RPARENTHESIS +expr_aff = STR_EXPRASSIGN + LPARENTHESIS + expr + STR_COMMA + expr + RPARENTHESIS expr << (expr_int | expr_id | expr_loc | expr_slice | expr_mem | expr_cond | \ expr_compose | expr_op | expr_aff) @@ -69,7 +69,7 @@ expr_mem.setParseAction(lambda t: ExprMem(*t)) expr_cond.setParseAction(lambda t: ExprCond(*t)) expr_compose.setParseAction(lambda t: ExprCompose(*t)) expr_op.setParseAction(lambda t: ExprOp(*t)) -expr_aff.setParseAction(lambda t: ExprAff(*t)) +expr_aff.setParseAction(lambda t: ExprAssign(*t)) def str_to_expr(str_in): diff --git a/miasm2/ir/analysis.py b/miasm2/ir/analysis.py index d49f6b4e..9158aceb 100644 --- a/miasm2/ir/analysis.py +++ b/miasm2/ir/analysis.py @@ -4,7 +4,7 @@ import warnings import logging from miasm2.ir.ir import IntermediateRepresentation, AssignBlock -from miasm2.expression.expression import ExprOp, ExprAff +from miasm2.expression.expression import ExprOp, ExprAssign from miasm2.analysis.data_flow import dead_simp as new_dead_simp_imp @@ -45,8 +45,8 @@ class ira(IntermediateRepresentation): call_assignblk = AssignBlock( [ - ExprAff(self.ret_reg, ExprOp('call_func_ret', addr, self.sp)), - ExprAff(self.sp, ExprOp('call_func_stack', addr, self.sp)) + ExprAssign(self.ret_reg, ExprOp('call_func_ret', addr, self.sp)), + ExprAssign(self.sp, ExprOp('call_func_stack', addr, self.sp)) ], instr ) diff --git a/miasm2/ir/ir.py b/miasm2/ir/ir.py index db47d4ef..a77ce992 100644 --- a/miasm2/ir/ir.py +++ b/miasm2/ir/ir.py @@ -58,7 +58,7 @@ class AssignBlock(object): def __init__(self, irs=None, instr=None): """Create a new AssignBlock - @irs: (optional) sequence of ExprAff, or dictionnary dst (Expr) -> src + @irs: (optional) sequence of ExprAssign, or dictionnary dst (Expr) -> src (Expr) @instr: (optional) associate an instruction with this AssignBlock @@ -66,7 +66,7 @@ class AssignBlock(object): if irs is None: irs = [] self._instr = instr - self._assigns = {} # ExprAff.dst -> ExprAff.src + self._assigns = {} # ExprAssign.dst -> ExprAssign.src # Concurrent assignments are handled in _set if hasattr(irs, "iteritems"): @@ -250,10 +250,10 @@ class AssignBlock(object): out.append("%s = %s" % (dst, src)) return "\n".join(out) - def dst2ExprAff(self, dst): - """Return an ExprAff corresponding to @dst equation + def dst2ExprAssign(self, dst): + """Return an ExprAssign corresponding to @dst equation @dst: Expr instance""" - return m2_expr.ExprAff(dst, self[dst]) + return m2_expr.ExprAssign(dst, self[dst]) def simplify(self, simplifier): """ diff --git a/miasm2/ir/translators/C.py b/miasm2/ir/translators/C.py index 71f42636..1146dce6 100644 --- a/miasm2/ir/translators/C.py +++ b/miasm2/ir/translators/C.py @@ -77,7 +77,7 @@ class TranslatorC(Translator): value, int_size = int_size_to_bn(offset, 64) return 'bignum_from_string("%s", %d)' % (value, int_size) - def from_ExprAff(self, expr): + def from_ExprAssign(self, expr): new_dst = self.from_expr(expr.dst) new_src = self.from_expr(expr.src) return "%s = %s" % (new_dst, new_src) diff --git a/miasm2/ir/translators/miasm.py b/miasm2/ir/translators/miasm.py index b390eb51..d8509d24 100644 --- a/miasm2/ir/translators/miasm.py +++ b/miasm2/ir/translators/miasm.py @@ -30,8 +30,8 @@ class TranslatorMiasm(Translator): args = ["%s" % self.from_expr(arg) for arg in expr.args] return "ExprCompose(%s)" % ", ".join(args) - def from_ExprAff(self, expr): - return "ExprAff(%s, %s)" % (self.from_expr(expr.dst), + def from_ExprAssign(self, expr): + return "ExprAssign(%s, %s)" % (self.from_expr(expr.dst), self.from_expr(expr.src)) def from_ExprMem(self, expr): diff --git a/miasm2/ir/translators/python.py b/miasm2/ir/translators/python.py index e05f5e4d..c6eb0ba8 100644 --- a/miasm2/ir/translators/python.py +++ b/miasm2/ir/translators/python.py @@ -74,7 +74,7 @@ class TranslatorPython(Translator): raise NotImplementedError("Unknown operator: %s" % expr.op) - def from_ExprAff(self, expr): + def from_ExprAssign(self, expr): return "%s = %s" % tuple(map(self.from_expr, (expr.dst, expr.src))) diff --git a/miasm2/ir/translators/smt2.py b/miasm2/ir/translators/smt2.py index f285c92a..408eb53f 100644 --- a/miasm2/ir/translators/smt2.py +++ b/miasm2/ir/translators/smt2.py @@ -278,7 +278,7 @@ class TranslatorSMT2(Translator): return res - def from_ExprAff(self, expr): + def from_ExprAssign(self, expr): src = self.from_expr(expr.src) dst = self.from_expr(expr.dst) return smt2_assert(smt2_eq(src, dst)) diff --git a/miasm2/ir/translators/translator.py b/miasm2/ir/translators/translator.py index 557fdabe..a56c6a62 100644 --- a/miasm2/ir/translators/translator.py +++ b/miasm2/ir/translators/translator.py @@ -83,9 +83,9 @@ class Translator(object): """ raise NotImplementedError("Abstract method") - def from_ExprAff(self, expr): - """Translate an ExprAff - @expr: ExprAff to translate + def from_ExprAssign(self, expr): + """Translate an ExprAssign + @expr: ExprAssign to translate """ raise NotImplementedError("Abstract method") @@ -111,7 +111,7 @@ class Translator(object): m2_expr.ExprSlice: self.from_ExprSlice, m2_expr.ExprOp: self.from_ExprOp, m2_expr.ExprMem: self.from_ExprMem, - m2_expr.ExprAff: self.from_ExprAff, + m2_expr.ExprAssign: self.from_ExprAssign, m2_expr.ExprCond: self.from_ExprCond } for target, handler in handlers.iteritems(): diff --git a/miasm2/ir/translators/z3_ir.py b/miasm2/ir/translators/z3_ir.py index a481acd7..97a0397a 100644 --- a/miasm2/ir/translators/z3_ir.py +++ b/miasm2/ir/translators/z3_ir.py @@ -239,7 +239,7 @@ class TranslatorZ3(Translator): return res - def from_ExprAff(self, expr): + def from_ExprAssign(self, expr): src = self.from_expr(expr.src) dst = self.from_expr(expr.dst) return (src == dst) |