def ConvertMovzbl(x):
if IsMemory(x[1]) and Is32Register(x[2]):
addr = CalculateAddress(x[1])
dest = x[2]
tempString = dest + " = zeroext(mem:8[" + addr + "], 24);\n"
if config.Is64BitArch():
dest64 = Get64BitRepFromRegister(x[2])[0]
tempString = tempString + dest64 + " = " + "zeroext(" + dest + ", 32);\n"
elif Is8Register(x[1]) and Is32Register(x[2]):
if x[1] in reg8lowRev:
source = "split(" + reg32[reg8lowRev[x[1]]] + ", 0, 7)"
elif x[1] in reg8highRev:
source = "split(" + reg32[reg8highRev[x[1]]] + ", 8, 15)"
dest = x[2]
tempString = dest + " = zeroext(" + source + ", 24);\n"
if config.Is64BitArch():
dest64 = Get64BitRepFromRegister(x[2])[0]
tempString = tempString + dest64 + " = zeroext(" + dest + ", 32);\n"
else:
sys.exit("Convertmovzbl operand error: %s" % (x))
return dslparse.dslToAst(tempString)
def ConvertDecl(x):
oldDest = "oldDest"
if Is32Register(x[1]):
dest = x[1]
tempString = (oldDest + " = " + dest + ";\n" + dest + " = " + dest +
" - 1;\n")
if config.Is64BitArch():
dest64 = Get64BitRepFromRegister(x[1])[0]
tempString = tempString + dest64 + " = " + "zeroext(" + dest + ", 32);\n"
elif IsMemory(x[1]):
dest = "tempDest"
addr = CalculateAddress(x[1])
tempString = (LoadFromMemoryString(addr, 4, dest) + oldDest + " = " +
dest + ";\n" + dest + " = " + dest + " - 1;\n" +
StoreToMemoryString(addr, 4, dest))
else:
sys.exit("Convertdecl operand error: %s" % (x))
# Add flags
tempString = tempString + (
"zf:1 = " + dest + " == 0 ? 1:1 : 0:1;\n" + "cf:1 = 1 > " + oldDest +
" ? 1:1 : 0:1;\n" + "of_part1:1 = 0 != split(" + oldDest +
", 31, 31) ? 1:1 : 0:1;\n" + "of_part2:1 = split(" + oldDest +
", 31, 31) == split(" + dest + ", 31, 31) ? 1:1 : 0:1;\n" +
"of:1 = of_part1:1 & of_part2:1;\n" + "sf:1 = split(" + dest +
", 31, 31);\n")
return dslparse.dslToAst(tempString)
def ConvertMovd(x):
tempString = ""
# Movd xmm, 32-bit reg
if Is128Register(x[1]) and Is32Register(x[2]):
source = [x[1] + "_0", x[1] + "_1", x[1] + "_2", x[1] + "_3"]
dest = x[2]
dest64 = Get64BitRepFromRegister(x[2])[0]
tempString = (dest + " = " + source[0] + ";\n" + dest64 + " = " +
"zeroext(" + dest + ", 32);\n")
# Movd xmm, 32-bit memory
elif Is128Register(x[1]) and IsMemory(x[2]):
source = [x[1] + "_0", x[1] + "_1", x[1] + "_2", x[1] + "_3"]
addr = CalculateAddress(x[2])
tempString = StoreToMemoryString(addr, 4, source[0])
# Movd 32-bit reg, xmm
elif Is32Register(x[1]) and Is128Register(x[2]):
source = x[1]
dest = [x[2] + "_0", x[2] + "_1", x[2] + "_2", x[2] + "_3"]
tempString = (dest[0] + " = " + source + ";\n" + dest[1] + " = 0;\n" +
dest[2] + " = 0;\n" + dest[3] + " = 0;\n")
# Movd 32-bit mem, xmm
elif IsMemory(x[1]) and Is128Register(x[2]):
addr = CalculateAddress(x[1])
dest = [x[2] + "_0", x[2] + "_1", x[2] + "_2", x[2] + "_3"]
tempString = (LoadFromMemoryString(addr, 4, dest[0]) + dest[1] +
" = 0;\n" + dest[2] + " = 0;\n" + dest[3] + " = 0;\n")
else:
sys.exit("ConvertMovd operand error: %s" % (x))
return dslparse.dslToAst(tempString)
def ConvertBswapl(x):
dest = x[1]
dest64 = Get64BitRepFromRegister(x[1])[0]
tempString = (dest + " = merge(split(" + dest + ", 0, 7), merge(split(" +
dest + ", 8, 15), merge(split(" + dest +
", 16, 23), split(" + dest + ", 24, 31))));\n" + dest64 +
" = zeroext(" + dest + ", 32);\n")
return dslparse.dslToAst(tempString)
def ConvertPopq(x):
if Is64Register(x[1]):
addr = "rsp:64"
dest = x[1] + ":64"
tempString = (LoadFromMemoryString(addr, 8, dest) + addr + " = " +
addr + " + 8:64" + ";\n")
else:
sys.exit("Convertpopq operand error: %s" % (x))
return dslparse.dslToAst(tempString)
def ConvertPushq(x):
if Is64Register(x[1]):
dest = x[1] + ":64"
addr = "rsp:64"
tempString = (addr + " = " + addr + " - 8:64" + ";\n" +
StoreToMemoryString(addr, 8, dest))
else:
sys.exit("Convertpushq operand error: %s" % (x))
return dslparse.dslToAst(tempString)
def ConvertLeaq(x):
if IsMemory(x[1]) and Is64Register(x[2]):
dest = x[2] + ":64"
addr = CalculateAddress(x[1])
dest32 = Get32BitRepFromRegister(x[2])[0]
tempString = (dest + " = " + addr + ";\n" + dest32 + " = " + "split(" +
dest + ", 0, 31);\n")
return dslparse.dslToAst(tempString)
else:
sys.exit("Convertleaq operand error: %s" % (x))
def ConvertAndl(x):
source, dest, oldDest, addr, tempString = SetupOperand32Bit(x)
tempString = tempString + (
dest + " = " + dest + " & " + source + ";\n" +
SaveToOperand32Bit(x, source, dest, oldDest, addr))
# Add flags
tempString = tempString + ("zf:1 = " + dest + " == 0 ? 1:1 : 0:1;\n" +
"cf:1 = 0:1;\n" + "of:1 = 0:1;\n" +
"sf:1 = split(" + dest + ", 31, 31);\n")
return dslparse.dslToAst(tempString)
def ConvertXorq(x):
source, dest, oldDest, addr, tempString = SetupOperand64Bit(x)
tempString = tempString + (
dest + " = " + dest + " ^ " + source + ";\n" +
SaveToOperand64Bit(x, source, dest, oldDest, addr))
# Add flags
tempString = tempString + ("zf:1 = " + dest + " == 0:64 ? 1:1 : 0:1;\n" +
"cf:1 = 0:1;\n" + "of:1 = 0:1;\n" +
"sf:1 = split(" + dest + ", 63, 63);\n")
return dslparse.dslToAst(tempString)
def ConvertCmpb(x):
temp = "tempCmpb:8"
source, dest, oldDest, addr, tempString = SetupOperand8Bit(x)
tempString = tempString + temp + " = " + dest + " - " + source + ";\n"
# Add flags
tempString = tempString + (
"zf:1 = " + temp + " == 0:8 ? 1:1 : 0:1;\n" + "of_part1:1 = split(" +
source + ", 7, 7) != split(" + dest + ", 7, 7) ? 1:1 : 0:1;\n" +
"of_part2:1 = split(" + dest + ", 7, 7) == split(" + temp +
", 7, 7) ? 1:1 : 0:1;\n" + "of:1 = of_part1:1 & of_part2:1;\n" +
"cf:1 = " + source + " > " + dest + " ? 1:1 : 0:1;\n" +
"sf:1 = split(" + temp + ", 7, 7);\n")
return dslparse.dslToAst(tempString)
def ConvertSubl(x):
source, dest, oldDest, addr, tempString = SetupOperand32Bit(x)
tempString = tempString + (
oldDest + " = " + dest + ";\n" + dest + " = " + dest + " - " + source +
";\n" + SaveToOperand32Bit(x, source, dest, oldDest, addr))
# Add flags
tempString = tempString + (
"zf:1 = " + dest + " == 0 ? 1:1 : 0:1;\n" + "of_part1:1 = split(" +
oldDest + ", 31, 31) != split(" + source + ", 31, 31) ? 1:1 : 0:1;\n" +
"of_part2:1 = split(" + source + ", 31, 31) == split(" + dest +
", 31, 31) ? 1:1 : 0:1;\n" + "of:1 = of_part1:1 & of_part2:1;\n" +
"cf:1 = " + source + " > " + oldDest + " ? 1:1 : 0:1;\n" +
"sf:1 = split(" + dest + ", 31, 31);\n")
return dslparse.dslToAst(tempString)
def ConvertShll(x):
source, dest, oldDest, addr, tempString = SetupOperandForShifts32Bit(x)
tempString = tempString + (
oldDest + " = " + dest + ";\n" + dest + " = " + dest + " << " + source
+ ";\n" + SaveToOperandForShifts32Bit(x, source, dest, oldDest, addr))
# Add flags
tempString = tempString + "cf:1 = split(" + dest + ", 31, 31);\n"
if int(x[1], 0) == 1:
tempString = tempString + "of:1 = split(" + dest + ", 31, 31) ^ cf:1;\n"
else:
tempString = tempString + "of:1 = builtin_undef;\n"
tempString = tempString + ("zf:1 = " + dest + " == 0 ? 1:1 : 0:1;\n" +
"sf:1 = split(" + dest + ", 31, 31);\n")
return dslparse.dslToAst(tempString)
def ConvertSbbq(x):
source, dest, oldDest, addr, tempString = SetupOperand64Bit(x)
tempString = tempString + (
oldDest + " = " + dest + ";\n" + dest + " = " + dest + " - " + source +
" - zeroext(cf:1, 63);\n" +
SaveToOperand64Bit(x, source, dest, oldDest, addr))
# Add flags
tempString = tempString + (
"zf:1 = " + dest + " == 0:64 ? 1:1 : 0:1;\n" + "of_part1:1 = split(" +
oldDest + ", 63, 63) != split(" + source + ", 63, 63) ? 1:1 : 0:1;\n" +
"of_part2:1 = split(" + source + ", 63, 63) == split(" + dest +
", 63, 63) ? 1:1 : 0:1;\n" + "of:1 = of_part1:1 & of_part2:1;\n" +
"cf:1 = " + source + " > " + oldDest + " ? 1:1 : 0:1;\n" +
"sf:1 = split(" + dest + ", 63, 63);\n")
return dslparse.dslToAst(tempString)
def ConvertMovq(x):
tempString = ""
# 64-bit reg to 64-bit reg
if (isImmediate(x[1]) or Is64Register(x[1])) and Is64Register(x[2]):
source = x[1] + ":64"
dest = x[2] + ":64"
dest32 = Get32BitRepFromRegister(x[2])[0]
tempString = (dest + " = " + source + ";\n" + dest32 + " = " +
"split(" + dest + ", 0, 31);\n")
# 64-bit reg to 64-bit mem
elif (isImmediate(x[1]) or Is64Register(x[1])) and IsMemory(x[2]):
source = x[1] + ":64"
addr = CalculateAddress(x[2])
tempString = StoreToMemoryString(addr, 8, source)
# 64-bit mem to 64-bit reg
elif IsMemory(x[1]) and Is64Register(x[2]):
addr = CalculateAddress(x[1])
dest = x[2] + ":64"
dest32 = Get32BitRepFromRegister(x[2])[0]
tempString = (LoadFromMemoryString(addr, 8, dest) + dest32 +
" = split(" + dest + ", 0, 31);\n")
# 128-bit reg to 64-bit reg
elif Is128Register(x[1]) and Is64Register(x[2]):
source = [x[1] + "_0", x[1] + "_1", x[1] + "_2", x[1] + "_3"]
dest = x[2] + ":64"
dest32 = Get32BitRepFromRegister(x[2])[0]
tempString = (dest + " = merge(" + source[1] + ", " + source[0] +
");\n" + dest32 + " = split(" + dest + ", 0, 31);\n")
# 64-bit reg to 128-bit reg
elif Is64Register(x[1]) and Is128Register(x[2]):
source = x[1] + ":64"
dest = [x[2] + "_0", x[2] + "_1", x[2] + "_2", x[2] + "_3"]
tempString = (dest[0] + " = split(" + source + ", 0, 31);\n" +
dest[1] + " = split(" + source + ", 32, 63);\n" +
dest[2] + " = 0;\n" + dest[3] + " = 0;\n")
else:
sys.exit("ConvertMovd operand error: %s" % (x))
return dslparse.dslToAst(tempString)
def ParseSpecStringToDsl(specString, progOrig):
# Parse dsl program string
specAst = dslparse.dslToAst(specString)
# Separate out function definitions and other parts.
functions, specAst = ProcessFunctions(specAst)
# Inline the function calls with function definition.
replaceFunctions(functions, specAst)
# Unroll Loops
specAst = UnrollLoops(specAst)
# Once replaced, see if it's a "memory" store or load.
for sa in specAst:
if isinstance(sa.lhs, di.ArrayCall) and sa.comparator == "=":
sa.comparator = "<-"
# Set programOrigin.
for sa in specAst:
sa.SetProgramOrigin(progOrig, False)
return specAst
# p1Ast : AST of p1
# p2Ast : AST of p2
# postAst : AST of the postcondition
#
####################################################################################################
# Read from file
ansiCode.PrintOnThisLineBold("Reading Files")
preString = readFile(args.pre)
p1String = readFile(args.p1)
p2String = readFile(args.p2)
postString = readFile(args.post)
# Turn everything into dslinstruction
ansiCode.PrintOnThisLineBold("ParsingFiles: ")
ansiCode.Print("pre condition")
preAst = dslparse.dslToAst(preString)
ansiCode.PrintFromLeft("p1", 13)
p1Ast = ParseProgramToDsl(p1String, config.p1lang, "P1")
ansiCode.PrintFromLeft("p2", 2)
p2Ast = ParseProgramToDsl(p2String, config.p2lang, "P2")
ansiCode.PrintFromLeft("post condition", 2)
postAst = dslparse.dslToAst(postString)
# Constant propagate some numbers
ansiCode.PrintFromLeft("Constant propagating", 14)
ConstantPropagate(preAst)
ConstantPropagate(p1Ast)
ConstantPropagate(p2Ast)
def ConvertCmovccl(x, cc):
source, dest, oldDest, addr, tempString = SetupOperand32Bit(x)
tempString = tempString + (
dest + " = " + cc + " ? " + source + " : " + dest + ";\n" +
SaveToOperand32Bit(x, source, dest, oldDest, addr))
return dslparse.dslToAst(tempString)
