def get_annotation(self, xdata: InstrXData) -> str:
"""data format: a:vvvxxxxxx .
vars[0]: lhs (memory location)
vars[1]: srcptrlhs (esi)
vars[2]: dstptrlhs (edi)
xprs[0]: rhs (memory location)
xprs[1]: rhs (simplified)
xprs[2]: srcptrrhs
xprs[3]: srcptrrhs (simplified)
xprs[4]: dstptrrhs
xprs[5]: dstptrrhs (simplified
"""
lhs = str(xdata.vars[0])
rhs = xdata.xprs[0]
rrhs = xdata.xprs[1]
xrhs = simplify_result(xdata.args[3], xdata.args[4], rhs, rrhs)
srcptrrhs = xdata.xprs[2]
rsrcptrrhs = xdata.xprs[3]
xsrcptrrhs = simplify_result(xdata.args[5], xdata.args[6], srcptrrhs,
rsrcptrrhs)
dstptrrhs = xdata.xprs[4]
rdstptrrhs = xdata.xprs[5]
xdstptrrhs = simplify_result(xdata.args[7], xdata.args[8], dstptrrhs,
rdstptrrhs)
return (lhs + ' = ' + xrhs + '; esi = ' + xsrcptrrhs + '; edi = ' +
xdstptrrhs)
def annotation(self, xdata: InstrXData) -> str:
"""data format a:vxxxxxx
vars[0]: lhs
xprs[0]: rhs1 (dst)
xprs[1]: rhs2 (src)
xprs[2]: rhs1 - rhs2 (syntactic)
xprs[3]: (rhs1 - rhs2) + 1 (syntactic)
xprs[4]: rhs1 - rhs2 (simplified)
xprs[5]: (rhs1 - rhs2) + 2 (simplified)
"""
lhs = str(xdata.vars[0])
rhsx = xdata.xprs[2]
rrhsx = xdata.xprs[3]
xrhsx = simplify_result(xdata.args[3], xdata.args[4], rhsx, rrhsx)
rhsx1 = xdata.xprs[4]
rrhsx1 = xdata.xprs[5]
xrhsx1 = simplify_result(xdata.args[5], xdata.args[6], rhsx1, rrhsx1)
return (lhs + ' = ' + xrhsx + ' or ' + xrhsx1)
def annotation(self, xdata: InstrXData) -> str:
"""data format: a:vvxxxxxx
vars[0]: quotient-lhs
vars[1]: remainder-lhs
xprs[0]: dividend
xprs[1]: divisor
xprs[2]: quotient-rhs (syntactic)
xprs[3]: quotient-rhs (simplified)
xprs]4]: remainder-rhs (syntactic)
xprs[5]: remainder-rhs (simplified)
"""
lhs1 = str(xdata.vars[0])
lhs2 = str(xdata.vars[1])
quot = xdata.xprs[2]
rquot = xdata.xprs[3]
rem = xdata.xprs[4]
rrem = xdata.xprs[5]
xquot = simplify_result(xdata.args[4], xdata.args[5], quot, rquot)
xrem = simplify_result(xdata.args[6], xdata.args[7], rem, rrem)
return lhs1 + ' = ' + xquot + '; ' + lhs2 + ' = ' + xrem
def annotation(self, xdata: InstrXData) -> str:
"""data format: a:vxxx .
vars[0]: lhs
xprs[0]: rhs
xprs[1]: rhs simplified
"""
lhs = str(xdata.vars[0])
rhs = xdata.xprs[0]
rrhs = xdata.xprs[1]
xrhs = simplify_result(xdata.args[1], xdata.args[2], rhs, rrhs)
return lhs + ' = ' + xrhs
def annotation(self, xdata: InstrXData) -> str:
"""data format a:vxx
vars[0]: dst
xprs[0]: src
xprs[1]: src simplified
"""
lhs = str(xdata.vars[0])
rhs = xdata.xprs[0]
rrhs = xdata.xprs[1]
xrhs = simplify_result(xdata.args[1], xdata.args[2], rhs, rrhs)
return lhs + ' = sign-extend ' + xrhs
def annotation(self, xdata: InstrXData) -> str:
"""data format: a:vxxx .
vars[0]: dst
xprs[0]: src
xprs[1]: src - 1 (syntactic)
xprs[2]: src - 1 (simplified)
"""
lhs = str(xdata.vars[0])
rhs = xdata.xprs[1]
rrhs = xdata.xprs[2]
xrhs = simplify_result(xdata.args[2], xdata.args[3], rhs, rrhs)
return lhs + ' = ' + xrhs
def annotation(self, xdata: InstrXData) -> str:
"""data format: a:vxxx
vars[0]: lhs
xprs[0]: rhs
xprs[1]: rhs 2's complement (syntactic)
xprs[2]: rhs 2's complement (simplified)
"""
lhs = str(xdata.vars[0])
rhsx = xdata.xprs[1]
rrhsx = xdata.xprs[2]
xrhs = simplify_result(xdata.args[2], xdata.args[3], rhsx, rrhsx)
return lhs + ' = ' + xrhs
def annotation(self, xdata: InstrXData) -> str:
"""data format a:vxxxx
vars[0]: dst
xprs[0]: rhs-base
xprs[1]: rhs-expr
xprs[2]: rhs-result (syntactic)
xprs[3]: rhs-result (simplified)
"""
lhs = str(xdata.vars[0])
rhs = xdata.xprs[2]
rrhs = xdata.xprs[3]
xrhs = simplify_result(xdata.args[3], xdata.args[4], rhs, rrhs)
return lhs + ' = ' + xrhs
def annotation(self, xdata: InstrXData) -> str:
"""data format a:xx .
xprs[0]: value of eax
xprs[1]: value of eax simplified
"""
eax = xdata.xprs[0]
reax = xdata.xprs[1]
xeax = simplify_result(xdata.args[0], xdata.args[1], eax, reax)
popped = self.bytes_popped
if popped == 0:
return 'return (' + xeax + ')'
else:
return "return (" + xeax + ") (adj: " + str(popped) + ")"
def annotation(self, xdata: InstrXData) -> str:
"""data format
vars[0]: lhs
xprs[0]: rhs1
xprs[1]: rhs2
xprs[2]: rhs1 * rhs2 (syntactic)
xprs[3]: rhs1 * rhs2 (simplified)
"""
lhs = str(xdata.vars[0])
rhs = xdata.xprs[2]
rrhs = xdata.xprs[3]
xrhs = simplify_result(xdata.args[3], xdata.args[4], rhs, rrhs)
return lhs + ' = ' + xrhs
def annotation(self, xdata: InstrXData) -> str:
"""data format: a:vxxxx .
vars[0]: dst-lhs
xprs[0]: src
xprs[1]: dst-rhs
xprs[2]: src + dst (syntactic)
xprs[3]: src + dst (simplified)
"""
lhs = str(xdata.vars[0])
result = xdata.xprs[2]
rresult = xdata.xprs[3]
xresult = simplify_result(xdata.args[3], xdata.args[4], result,
rresult)
return lhs + ' := ' + xresult
def annotation(self, xdata: InstrXData) -> str:
"""data format: """
if len(xdata.tags) > 1 and xdata.tags[1] == 'arg':
callsite = xdata.tags[1]
argindex = xdata.args[2]
xval = str(xdata.xprs[1])
return '[' + str(callsite) + ':' + str(
argindex) + ': ' + xval + ']'
if len(xdata.xprs) == 2:
lhs = str(xdata.vars[0])
rhs = xdata.xprs[0]
rrhs = xdata.xprs[1]
xrhs = simplify_result(xdata.args[1], xdata.args[2], rhs, rrhs)
return lhs + ' = ' + xrhs
else:
if len(xdata.tags) > 0:
return xdata.tags[0]
else:
return 'mov:????'
def annotation(self, xdata: InstrXData) -> str:
"""data format a:vvxxxx
vars[0]: srclhs
vars[1]: dstlhs
xprs[0]: rhs1
xprs[1]: rhs2
xprs[2]: sum (syntactic)
xprs[3]: sum (simplified)
"""
srclhs = str(xdata.vars[0])
dstlhs = str(xdata.vars[1])
srcrhs = str(xdata.xprs[0])
dstrhs = str(xdata.xprs[1])
result = xdata.xprs[2]
rresult = xdata.xprs[3]
xresult = simplify_result(xdata.args[4], xdata.args[5], result,
rresult)
return dstlhs + ' = ' + xresult + '; ' + srclhs + ' = ' + dstrhs
def annotation(self, xdata: InstrXData) -> str:
"""data format
a:v, restore : restore initial value of register
a:vxxx otherwise
vars[0]: dst
xprs[0]: rhs
xprs[1]: esp
xprs[2]: esp (simplified)
"""
if len(xdata.tags) == 2 and xdata.tags[1] == "restore":
return "restore " + str(xdata.vars[0])
else:
lhs = str(xdata.vars[0])
rhs = xdata.xprs[0]
esp = xdata.xprs[1]
resp = xdata.xprs[2]
xresp = simplify_result(xdata.args[2], xdata.args[3], esp, resp)
return lhs + ' = ' + str(rhs) + '; esp = ' + xresp
def annotation(self, xdata: InstrXData) -> str:
""""data format: a:vxxxx
vars[0]: lhs
xprs[0]: rhs1
xprs[1]: rhs2
xprs[2]: rhs1 xor rhs2 (syntactic)
xprs[3]: rhs1 xor rhs2 (simplified)
"""
if len(xdata.xprs) == 0: # src, dst are the same, result is zero
lhs = str(xdata.vars[0])
return lhs + ' = 0'
else:
lhs = str(xdata.vars[0])
result = xdata.xprs[2]
rresult = xdata.xprs[3]
xresult = simplify_result(xdata.args[3], xdata.args[4], result,
rresult)
return lhs + ' = ' + xresult
def annotation(self, xdata: InstrXData) -> str:
"""Different formats dependent on operands.
1) stack realignment: "stack-realign", with number of bytes
2) zero assignement: "a:v"
3) rewrite register: "a:vxx" (dst = src (register))
4) general case: "a:vxxxx"
vars[x]: lhs
xprs[0]: src
xprs[1]: dst-rhs
xprs[2]: src & dst (syntactic)
xprs[3]: src & dst (simplified)
"""
if xdata.tags[0] == 'stack-realign':
alignment = str(xdata.args[0])
return 'align stack on ' + alignment + ' bytes'
elif len(xdata.xprs) == 0: # rhs is zero, result is zero
lhs = str(xdata.vars[0])
return lhs + ' = 0'
elif len(xdata.xprs) == 1: # dst = src, value is unchanged
lhs = str(xdata.vars[0])
rhs = str(xdata.xprs[1])
return lhs + ' = ' + rhs + ' (unchanged)'
else:
lhs = str(xdata.vars[0])
result = xdata.xprs[2]
rresult = xdata.xprs[3]
xresult = simplify_result(xdata.args[3], xdata.args[4], result,
rresult)
return lhs + ' = ' + xresult
def annotation(self, xdata: InstrXData) -> str:
"""data formats:
a:v second operand is -1, result is -1
a:vxxxx otherwise
vars[0]: dst
xprs[0]: src-rhs
xprs[1]: dst-rhs
xprs[2]: src-rhs | dst-rhs (syntactic)
xprs[3]: src-rhs | dst-rhs (simplified)
"""
if len(xdata.xprs) == 0:
# second operand is -1
lhs = str(xdata.vars[0])
return lhs + ' = -1'
else:
lhs = str(xdata.vars[0])
result = xdata.xprs[2]
rresult = xdata.xprs[3]
xresult = simplify_result(xdata.args[2], xdata.args[3], result,
rresult)
return lhs + ' = ' + xresult
