def alias_SMADDL(i):
m = mnemo(i)
r = regs(i)
if i.a == 0:
m = tok_mnemo("smull")
r.pop()
return m + TokenListJoin(", ", r)
def alias_UMSUBL(i):
m = mnemo(i)
r = regs(i)
if i.a == 0:
m = tok_mnemo("umnegl")
r.pop()
return m + TokenListJoin(", ", r)
def alias_AND(i):
m = mnemo(i)
r = regs(i)
if i.setflags and i.d == 0:
m = tok_mnemo("tst")
r = r[1:]
return m + TokenListJoin(", ", r)
def ops(i):
s = []
for o in i.operands:
if o._is_slc:
assert i.BW
o = o.x
if o._is_reg:
s.append((Token.Register, str(o)))
elif o._is_cst:
s.append((Token.Constant, '#%s' % o))
else:
assert o._is_mem
a = o.a.base
disp = o.a.disp
if disp == 0 and a._is_reg:
if i.misc['autoinc'] is a:
s.append((Token.Memory, '@%s+' % a))
else:
s.append((Token.Memory, '@%s' % a))
elif a._is_cst:
a.sf = False
s.append((Token.Memory, '&%s' % a))
else:
if a._is_eqn:
l, r = a.l, a.r
else:
l, r = a, disp
if l == pc and i.address:
s.append((Token.Address, '*%s' % (i.address + r)))
else:
s.append((Token.Memory, '%s(%s)' % (r, l)))
return TokenListJoin(', ', s)
def alias_EXTR(i):
m = mnemo(i)
r = regs(i)
if i.n is i.m:
m = tok_mnemo("ror")
r.pop(1)
return m + TokenListJoin(", ", r)
def alias_ORN(i):
m = mnemo(i)
r = regs(i)
if i.n == 0:
m = tok_mnemo("mvn")
r.pop(1)
return m + TokenListJoin(", ", r)
def alias_SBC(i):
m = mnemo(i)
r = regs(i)
if i.n == 0:
m = m[0][1].replace("sbc", "ngc")
m = tok_mnemo(m)
r.pop(1)
return m + TokenListJoin(", ", r)
def alias_CSNEG(i):
m = mnemo(i)
r = regs(i)
if i.n is i.m:
if i.cond >> 1 != 0b111:
m = tok_mnemo("cneg")
r = r[:2]
r.append((Token.Literal, "%s" % CONDITION[i.cond ^ 1][0]))
return m + TokenListJoin(", ", r)
def alias_BFM(i):
r = regs(i)
if i.imms < i.immr:
r[3] = (Token.Constant, str(i.immr + 1))
r[2] = (Token.Constant, str(-i.imms % i.datasize))
m = tok_mnemo("bfi")
else:
r[3] = (Token.Constant, str(i.imms - i.immr + 1))
m = tok_mnemo("bfxil")
return m + TokenListJoin(", ", r)
def alias_ADD(i):
m = mnemo(i)
r = regs(i)
if not i.setflags:
if (i.d == 0 or i.n == 0) and i.operands[-1] == 0:
m = tok_mnemo("mov")
r.pop(0)
elif i.setflags and i.d == 0:
m = tok_mnemo("cmn")
r = r.pop(0)
return m + TokenListJoin(", ", r)
def alias_CSINV(i):
m = mnemo(i)
r = regs(i)
if i.n is i.m:
if i.cond >> 1 != 0b111:
if i.n != 0:
m = tok_mnemo("cinv")
r = r[:2]
else:
m = tok_mnemo("csetm")
r = r[:1]
r.append((Token.Literal, "%s" % CONDITION[i.cond ^ 1][0]))
return m + TokenListJoin(", ", r)
def alias_SUB(i):
m = mnemo(i)
r = regs(i)
if not i.setflags:
if i.n == 0:
m = tok_mnemo("neg")
r.pop(1)
elif i.setflags:
if i.d == 0:
m = tok_mnemo("cmp")
r.pop(1)
elif i.n == 0:
m = tok_mnemo("negs")
r.pop(1)
return m + TokenListJoin(", ", r)
def alias_SBFM(i):
m = mnemo(i)
r = regs(i)
if i.imms == i.datasize - 1:
r.pop()
m = tok_mnemo("asr")
elif i.imms < i.immr:
m = tok_mnemo("sbfiz")
r[3] = (Token.Constant, str(i.immr + 1))
r[2] = (Token.Constant, str(-i.imms % i.datasize))
elif i.immr == 0:
if i.immr == 7:
m = tok_mnemo("sxtb")
if i.immr == 15:
m = tok_mnemo("sxth")
if i.immr == 31:
m = tok_mnemo("sxtw")
r.pop(1)
return m + TokenListJoin(", ", r)
def specreg(i):
spec_reg = "%s_" % apsr
if i.write_nzcvq:
spec_reg += "nzcvq"
if i.write_g:
spec_reg += "g"
return [(Token.Register, "%s, %s" % (i.operands[0], spec_reg))]
def reglistcomma(i):
return ", " if len(i.operands) > 1 else ""
format_allregs = [lambda i: TokenListJoin(", ", regs(i))]
format_default = [mnemo] + format_allregs
format_sreg = format_default
format_label = [mnemo, label]
format_adr = [mnemo, lambda i: regs(i, 1), ", ", lambda i: label(i, 1)]
format_bits = format_default
format_reglist = [
mnemo,
(lambda i: TokenListJoin(", ", regs(i, -1))),
reglistcomma,
reglist,
]
format_deref = [
mnemo, lambda i: TokenListJoin(", ",
regs(i, -2) + deref(i, -2))
]
_pc = i.address
if _pc is None:
_pc = pc
if i.operands[0]._is_ext:
return [(Token.Address, str(i.operands[0].ref))]
if i.operands[0]._is_reg:
return [(Token.Register, "%%%s" % (i.operands[0].ref))]
if i.operands[0]._is_cst:
offset = i.operands[0].signextend(32) * 4
target = i.misc["dst"] or (_pc + offset)
return [(Token.Address, str(target))]
raise TypeError("operand type not supported")
format_ld = [
mnemo, lambda i: TokenListJoin(", ",
deref(i.operands[0]) + regn(i, 1))
]
format_st = [
mnemo, lambda i: TokenListJoin(", ",
regn(i, 0) + deref(i.operands[1]))
]
format_logic = [
mnemo_icc,
lambda i: TokenListJoin(
", ",
regn(i, 0) + reg_or_imm(i.operands[1], "%#x") + regn(i, 2)),
]
format_sethi = [
mnemo,
lambda i: TokenListJoin(", ",
reg_or_imm(i.operands[0]) + regn(i, 1)),
if offset._is_cst:
ostr = '#%c%d' % (sign, offset.value)
else:
ostr = sign + str(offset)
loc = [(Token.Memory, '[%s, %s]' % (base, ostr))]
return m + loc
def specreg(i):
spec_reg = "%s_" % apsr
if i.write_nzcvq: spec_reg += 'nzcvq'
if i.write_g: spec_reg += 'g'
return [(Token.Register, '%s, %s' % (i.operands[0], spec_reg))]
format_allregs = [lambda i: TokenListJoin(', ', regs(i))]
format_default = [mnemo] + format_allregs
format_sreg = format_default
format_label = [mnemo, label]
format_adr = [mnemo, lambda i: regs(i, 1), lambda i: label(i, 1)]
format_bits = format_default
format_reglist = [mnemo, (lambda i: TokenListJoin(', ', regs(i, -1))), reglist]
format_deref = [
mnemo, lambda i: TokenListJoin(', ',
regs(i, -2) + deref(i, -2))
]
format_plx = [plx]
format_msr = [mnemo, specreg]
format_setend = [setend]
ARM_V7_full_formats = {
0b0011: 'tl',
0b1100: 'tgu',
0b0100: 'tleu',
0b1101: 'tcc',
0b0101: 'tcs',
0b1110: 'tpos',
0b0110: 'tneg',
0b1111: 'tvc',
0b0111: 'tvs'
}
CONDxB = {'b': CONDB, 'fb': CONDFB, 'cb': CONDCB}
mnemo = lambda i: [(Token.Mnemonic, '{i.mnemonic}'.format(i=i))]
format_mn = [mnemo]
format_regs = [mnemo, lambda i: TokenListJoin(', ', regs(i))]
format_ld = [
mnemo, lambda i: TokenListJoin(', ',
deref(i.operands[0]) + regn(i, 1))
]
format_st = [
mnemo, lambda i: TokenListJoin(', ',
regn(i, 0) + deref(i.operands[1]))
]
format_logic = [
mnemo_icc, lambda i: TokenListJoin(
', ',
regn(i, 0) + reg_or_imm(i.operands[1], '%#x') + regn(i, 2))
]
format_sethi = [
mnemo, lambda i: TokenListJoin(', ',
def alias_SBC(i):
m = mnemo(i)
r = regs(i)
if i.n == 0:
m = m[0][1].replace("sbc", "ngc")
m = tok_mnemo(m)
r.pop(1)
return m + TokenListJoin(", ", r)
condreg = lambda i: [(Token.Literal, "'%s'" % CONDITION[i.cond][0])]
allregs = LambdaTokenListJoin(", ", regs)
format_default = [mnemo, LambdaTokenListJoin(", ", regs)]
format_ld_st = [
mnemo, lambda i: TokenListJoin(", ",
regs(i, -2) + deref(i, -2))
]
format_B = [mnemo, label]
format_ADR = [
mnemo, lambda i: TokenListJoin(", ", i.operands[0].toks() + label_adr(i))
]
format_CBx = [mnemo, lambda i: TokenListJoin(", ", i.t.toks() + label(i, 1))]
format_CCMx = [
mnemo, lambda i: TokenListJoin(", ", regs(i, 2)), lambda i: i.flags.toks(),
condreg
]
ARM_V8_full_formats = {
"A64_generic": format_default,
"A64_load_store": format_ld_st,
"A64_adr": format_ADR,
def subr(i, pos=pos):
o = i.operands[pos]
L = [(Token.Literal, "{")]
L += TokenListJoin(", ", [(Token.Register, "{0}".format(x)) for x in o])
L += [(Token.Literal, "}")]
return L
def subf(i, L=args):
X = []
for l in L:
X.extend(l(i))
return TokenListJoin(", ", X)
def subr(i,pos=pos):
o = i.operands[pos]
L = [(Token.Literal,'{')]
L += TokenListJoin(', ',[(Token.Register,'{0}'.format(x)) for x in o])
L += [(Token.Literal,'}')]
return L
