7 EXCEPT_PRIV_INSN = (1 << 17)
13 return [m2_expr.ExprAff(zf, m2_expr.ExprCond(a, m2_expr.ExprInt1(0), m2_expr.ExprInt1(1)))]
17 return [m2_expr.ExprAff(nf, a.msb())]
42 if not a
or not b
or not c
or a != b
or a != c:
43 raise ValueError(
'bad ops size %s %s %s' % (a, b, c))
47 a_s, b_s, c_s = a.size, b.size, c.size
49 a_s, b_s, c_s = a.msb(), b.msb(), c.msb()
56 "Compute cf in @res = @op1 + @op2"
57 return m2_expr.ExprAff(cf, (((op1 ^ op2) ^ res) ^ ((op1 ^ res) & (~(op1 ^ op2)))).msb())
61 "Compute of in @res = @op1 + @op2"
62 return m2_expr.ExprAff(of, (((op1 ^ res) & (~(op1 ^ op2)))).msb())
67 "Compote CF in @res = @op1 - @op2"
68 return m2_expr.ExprAff(cf,
69 ((((op1 ^ op2) ^ res) ^ ((op1 ^ res) & (op1 ^ op2))).msb()) ^ m2_expr.ExprInt1(1))
73 "Compote OF in @res = @op1 - @op2"
74 return m2_expr.ExprAff(of, (((op1 ^ res) & (op1 ^ op2))).msb())
95 cond2expr = {
'EQ': zf,
96 'NE': zf ^ m2_expr.ExprInt1(1),
98 'CC': cf ^ m2_expr.ExprInt1(1),
100 'PL': nf ^ m2_expr.ExprInt1(1),
102 'VC': of ^ m2_expr.ExprInt1(1),
103 'HI': cf & (zf ^ m2_expr.ExprInt1(1)),
104 'LS': (cf ^ m2_expr.ExprInt1(1)) | zf,
105 'GE': nf ^ of ^ m2_expr.ExprInt1(1),
107 'GT': ((zf ^ m2_expr.ExprInt1(1)) &
108 (nf ^ of ^ m2_expr.ExprInt1(1))),
109 'LE': zf | (nf ^ of),
110 'AL': m2_expr.ExprInt1(1),
111 'NV': m2_expr.ExprInt1(0)
116 if not isinstance(arg, m2_expr.ExprOp):
119 op, (reg, shift) = arg.op, arg.args
121 base = reg.signExtend(dst.size)
123 base = reg.zeroExtend(dst.size)
125 out = base << (shift.zeroExtend(dst.size)
126 & m2_expr.ExprInt_from(dst, dst.size - 1))
137 "cond2expr": cond2expr,
138 "extend_arg": extend_arg,
148 def add(arg1, arg2, arg3):
153 def sub(arg1, arg2, arg3):
168 def eor(arg1, arg2, arg3):
173 def eon(arg1, arg2, arg3):
178 def orr(arg1, arg2, arg3):
183 def orn(arg1, arg2, arg3):
188 def bic(arg1, arg2, arg3):
197 def adds(ir, instr, arg1, arg2, arg3):
203 e.append(m2_expr.ExprAff(arg1, res))
207 def subs(ir, instr, arg1, arg2, arg3):
213 e.append(m2_expr.ExprAff(arg1, res))
217 def cmp(ir, instr, arg1, arg2):
226 def cmn(ir, instr, arg1, arg2):
235 def ands(ir, instr, arg1, arg2, arg3):
240 e.append(m2_expr.ExprAff(arg1, res))
243 def tst(ir, instr, arg1, arg2):
252 def lsl(arg1, arg2, arg3):
253 arg1 = arg2 << (arg3 & m2_expr.ExprInt_from(arg3, arg3.size - 1))
257 def lsr(arg1, arg2, arg3):
258 arg1 = arg2 >> (arg3 & m2_expr.ExprInt_from(arg3, arg3.size - 1))
262 def asr(arg1, arg2, arg3):
263 arg1 = m2_expr.ExprOp(
264 'a>>', arg2, (arg3 & m2_expr.ExprInt_from(arg3, arg3.size - 1)))
272 def movk(ir, instr, arg1, arg2):
274 if isinstance(arg2, m2_expr.ExprOp):
275 assert(arg2.op ==
'slice_at' and
276 isinstance(arg2.args[0], m2_expr.ExprInt)
and
277 isinstance(arg2.args[1], m2_expr.ExprInt))
278 value, shift = int(arg2.args[0].arg), int(arg2.args[1].arg)
280 m2_expr.ExprAff(arg1[shift:shift + 16], m2_expr.ExprInt16(value)))
282 e.append(m2_expr.ExprAff(arg1[:16], m2_expr.ExprInt16(int(arg2.arg))))
301 LR = m2_expr.ExprInt64(instr.offset + instr.l)
304 def csel(arg1, arg2, arg3, arg4):
305 cond_expr = cond2expr[arg4.name]
306 arg1 = arg2
if cond_expr
else arg3
309 def csinc(ir, instr, arg1, arg2, arg3, arg4):
311 cond_expr = cond2expr[arg4.name]
312 e.append(m2_expr.ExprAff(arg1, m2_expr.ExprCond(cond_expr,
314 arg3 + m2_expr.ExprInt_from(arg3, 1))))
318 def csinv(ir, instr, arg1, arg2, arg3, arg4):
320 cond_expr = cond2expr[arg4.name]
321 e.append(m2_expr.ExprAff(arg1, m2_expr.ExprCond(cond_expr,
327 def csneg(ir, instr, arg1, arg2, arg3, arg4):
329 cond_expr = cond2expr[arg4.name]
330 e.append(m2_expr.ExprAff(arg1, m2_expr.ExprCond(cond_expr,
336 def cset(ir, instr, arg1, arg2):
338 cond_expr = cond2expr[arg2.name]
339 e.append(m2_expr.ExprAff(arg1, m2_expr.ExprCond(cond_expr,
340 m2_expr.ExprInt_from(
342 m2_expr.ExprInt_from(arg1, 0))))
348 cond_expr = cond2expr[arg2.name]
349 e.append(m2_expr.ExprAff(arg1, m2_expr.ExprCond(cond_expr,
350 m2_expr.ExprInt_from(
352 m2_expr.ExprInt_from(arg1, 0))))
358 if isinstance(mem, m2_expr.ExprOp):
359 if mem.op ==
'preinc':
360 addr = mem.args[0] + mem.args[1]
361 elif mem.op ==
'segm':
363 op, (reg, shift) = mem.args[1].op, mem.args[1].args
365 off = reg.signExtend(base.size) << shift.zeroExtend(base.size)
368 off = reg.zeroExtend(base.size) << shift.zeroExtend(base.size)
371 if isinstance(shift, m2_expr.ExprInt)
and int(shift.arg) == 0:
372 addr = base + reg.zeroExtend(base.size)
375 (reg.zeroExtend(base.size)
376 << shift.zeroExtend(base.size))
378 raise NotImplementedError(
'bad op')
379 elif mem.op ==
"postinc":
381 updt = m2_expr.ExprAff(addr, addr + off)
382 elif mem.op ==
"preinc_wb":
385 updt = m2_expr.ExprAff(base, base + off)
387 raise NotImplementedError(
'bad op')
389 raise NotImplementedError(
'bad op')
394 def ldr(ir, instr, arg1, arg2):
397 e.append(m2_expr.ExprAff(arg1, m2_expr.ExprMem(addr, arg1.size)))
403 def ldrb(ir, instr, arg1, arg2):
407 m2_expr.ExprAff(arg1, m2_expr.ExprMem(addr, 8).zeroExtend(arg1.size)))
413 def ldrh(ir, instr, arg1, arg2):
417 m2_expr.ExprAff(arg1, m2_expr.ExprMem(addr, 16).zeroExtend(arg1.size)))
426 e.append(m2_expr.ExprAff(m2_expr.ExprMem(addr, arg1.size), arg1))
432 def strb(ir, instr, arg1, arg2):
435 e.append(m2_expr.ExprAff(m2_expr.ExprMem(addr, 8), arg1[:8]))
441 def strh(ir, instr, arg1, arg2):
444 e.append(m2_expr.ExprAff(m2_expr.ExprMem(addr, 16), arg1[:16]))
450 def stp(ir, instr, arg1, arg2, arg3):
453 e.append(m2_expr.ExprAff(m2_expr.ExprMem(addr, arg1.size), arg1))
455 m2_expr.ExprAff(m2_expr.ExprMem(addr + m2_expr.ExprInt_from(addr, arg1.size / 8), arg2.size), arg2))
461 def ldp(ir, instr, arg1, arg2, arg3):
464 e.append(m2_expr.ExprAff(arg1, m2_expr.ExprMem(addr, arg1.size)))
466 m2_expr.ExprAff(arg2, m2_expr.ExprMem(addr + m2_expr.ExprInt_from(addr, arg1.size / 8), arg2.size)))
476 m2_expr.ExprAff(arg1, m2_expr.ExprMem(addr, 32).signExtend(arg1.size)))
482 def sbfm(ir, instr, arg1, arg2, arg3, arg4):
484 rim, sim = int(arg3.arg), int(arg4.arg) + 1
486 res = arg2[rim:sim].signExtend(arg1.size)
488 shift = m2_expr.ExprInt_from(arg2, arg2.size - rim)
489 res = (arg2[:sim].signExtend(arg1.size) << shift)
490 e.append(m2_expr.ExprAff(arg1, res))
494 def ubfm(ir, instr, arg1, arg2, arg3, arg4):
496 rim, sim = int(arg3.arg), int(arg4.arg) + 1
498 res = arg2[rim:sim].zeroExtend(arg1.size)
500 shift = m2_expr.ExprInt_from(arg2, arg2.size - rim)
501 res = (arg2[:sim].zeroExtend(arg1.size) << shift)
502 e.append(m2_expr.ExprAff(arg1, res))
505 def bfm(ir, instr, arg1, arg2, arg3, arg4):
507 rim, sim = int(arg3.arg), int(arg4.arg) + 1
510 e.append(m2_expr.ExprAff(arg1[:sim-rim], res))
512 shift_i = arg2.size - rim
513 shift = m2_expr.ExprInt_from(arg2, shift_i)
515 e.append(m2_expr.ExprAff(arg1[shift_i:shift_i+sim], res))
520 def madd(arg1, arg2, arg3, arg4):
521 arg1 = arg2 * arg3 + arg4
525 def msub(arg1, arg2, arg3, arg4):
526 arg1 = arg4 - (arg2 * arg3)
531 arg1 = m2_expr.ExprOp(
'udiv', arg2, arg3)
536 dst = m2_expr.ExprId(ir.get_next_label(instr), 64)
if arg1
else arg2
543 dst = arg2
if arg1
else m2_expr.ExprId(ir.get_next_label(instr), 64)
549 def tbz(arg1, arg2, arg3):
550 bitmask = m2_expr.ExprInt_from(arg1, 1) << arg2
551 dst = m2_expr.ExprId(
552 ir.get_next_label(instr), 64)
if arg1 & bitmask
else arg3
559 bitmask = m2_expr.ExprInt_from(arg1, 1) << arg2
560 dst = arg3
if arg1 & bitmask
else m2_expr.ExprId(
561 ir.get_next_label(instr), 64)
568 dst = m2_expr.ExprId(ir.get_next_label(instr), 64)
if zf
else arg1
575 dst = arg1
if zf
else m2_expr.ExprId(ir.get_next_label(instr), 64)
582 cond = cond2expr[
'GE']
583 dst = arg1
if cond
else m2_expr.ExprId(ir.get_next_label(instr), 64)
590 cond = cond2expr[
'GT']
591 dst = arg1
if cond
else m2_expr.ExprId(ir.get_next_label(instr), 64)
598 cond = cond2expr[
'CC']
599 dst = arg1
if cond
else m2_expr.ExprId(ir.get_next_label(instr), 64)
606 cond = cond2expr[
'CS']
607 dst = arg1
if cond
else m2_expr.ExprId(ir.get_next_label(instr), 64)
614 cond = cond2expr[
'HI']
615 dst = arg1
if cond
else m2_expr.ExprId(ir.get_next_label(instr), 64)
622 cond = cond2expr[
'LE']
623 dst = arg1
if cond
else m2_expr.ExprId(ir.get_next_label(instr), 64)
630 cond = cond2expr[
'LS']
631 dst = arg1
if cond
else m2_expr.ExprId(ir.get_next_label(instr), 64)
638 cond = cond2expr[
'LT']
639 dst = arg1
if cond
else m2_expr.ExprId(ir.get_next_label(instr), 64)
652 arg1 = (PC & m2_expr.ExprInt64(0xfffffffffffff000)) + arg2
674 def extr(arg1, arg2, arg3, arg4):
675 compose = m2_expr.ExprCompose([(arg2, 0, arg2.size),
676 (arg3, arg2.size, arg2.size+arg3.size)])
677 arg1 = compose[int(arg4.arg):int(arg4.arg)+arg1.size]
679 mnemo_func = sbuild.functions
739 if not instr.name.lower()
in mnemo_func:
740 raise NotImplementedError(
'unknown mnemo %s' % instr)
741 instr, extra_ir = mnemo_func[instr.name.lower()](ir, instr, *args)
742 return instr, extra_ir
753 ir.__init__(self, mn_aarch64,
"l", symbol_pool)
756 self.
IRDst = m2_expr.ExprId(
'IRDst', 64)
760 if len(args)
and isinstance(args[-1], m2_expr.ExprOp):
761 if (args[-1].op
in [
'<<',
'>>',
'<<a',
'a>>',
'<<<',
'>>>']
and
762 isinstance(args[-1].args[-1], m2_expr.ExprId)):
763 args[-1] = m2_expr.ExprOp(args[-1].op,
765 args[-1].args[-1][:8].zeroExtend(32))
767 self.
mod_pc(instr, instr_ir, extra_ir)
768 instr_ir, extra_ir = self.
del_dst_zr(instr, instr_ir, extra_ir)
770 return instr_ir, extra_ir
773 return e.replace_expr(replace_regs)
778 return m2_expr.ExprAff(dst, src)
781 for irs
in irbloc.irs:
782 for i, e
in enumerate(irs):
784 special case for 64 bits:
785 if destination is a 32 bit reg, zero extend the 64 bit reg
787 if (isinstance(e.dst, m2_expr.ExprId)
and
789 e.dst
in replace_regs):
791 dst = replace_regs[e.dst].arg
792 e = m2_expr.ExprAff(dst, src.zeroExtend(64))
796 def mod_pc(self, instr, instr_ir, extra_ir):
797 "Replace PC by the instruction's offset"
798 cur_offset = m2_expr.ExprInt64(instr.offset)
799 for i, expr
in enumerate(instr_ir):
800 dst, src = expr.dst, expr.src
802 dst = dst.replace_expr({self.
pc: cur_offset})
803 src = src.replace_expr({self.
pc: cur_offset})
804 instr_ir[i] = m2_expr.ExprAff(dst, src)
807 for i, expr
in enumerate(irs):
808 dst, src = expr.dst, expr.src
810 dst = dst.replace_expr({self.
pc: cur_offset})
811 src = src.replace_expr({self.
pc: cur_offset})
812 irs[i] = m2_expr.ExprAff(dst, src)
816 "Writes to zero register are discarded"
817 regs_to_fix = [WZR, XZR]
818 instr_ir = [expr
for expr
in instr_ir
if expr.dst
not in regs_to_fix]
821 for i, irs
in enumerate(b.irs):
822 b.irs[i] = [expr
for expr
in irs
if expr.dst
not in regs_to_fix]
824 return instr_ir, extra_ir
830 ir.__init__(self, mn_aarch64,
"b", symbol_pool)
833 self.
IRDst = m2_expr.ExprId(
'IRDst', 64)
def irbloc_fix_regs_for_mode
def expr_fix_regs_for_mode
def expraff_fix_regs_for_mode