public void Exs_Cast_real()
{
Given_ExpressionSimplifier();
var expr = m.Cast(PrimitiveType.Real32, Constant.Real64(1.5));
Assert.AreEqual("1.5F", expr.Accept(simplifier).ToString());
}
public void TrashRepeatedDpbs()
{
p.Add("main", m =>
{
var eax = m.Frame.EnsureRegister(Registers.eax);
var v1 = m.Frame.CreateTemporary("v1", PrimitiveType.Byte);
var v2 = m.Frame.CreateTemporary("v2", PrimitiveType.Byte);
var v3 = m.Frame.CreateTemporary("v3", PrimitiveType.Byte);
m.Assign(v1, m.Or(m.Cast(v1.DataType, eax), 0));
m.Assign(eax, m.Dpb(eax, v1, 0));
m.Assign(v2, m.Or(m.Cast(v1.DataType, eax), 0));
m.Assign(eax, m.Dpb(eax, v2, 0));
m.Assign(v3, m.Or(m.Cast(v1.DataType, eax), 0));
m.Assign(eax, m.Dpb(eax, v3, 0));
m.Return();
});
var sExp =
@"main
main_entry esp:fp
l1 esp:fp
main_exit eax:eax esp:fp";
RunTest(p, sExp);
}
public void Vse_Cast_Truncate_SingleValue()
{
var r1 = m.Reg32("r1", 1);
Given_ValueSet(r1, IVS(0, -0x43F, -0x43F));
Given_Evaluator();
var vs = vse.Evaluate(m.Cast(PrimitiveType.Byte, r1));
Assert.AreEqual("0[-3F,-3F]", vs.Item1.ToString());
}
public void DfaCastCast()
{
var m = new ProcedureBuilder();
var r1 = m.Register("r1");
var r2 = m.Register("r2");
m.Assign(m.Frame.EnsureRegister(m.Architecture.StackRegister), m.Frame.FramePointer);
r1.DataType = PrimitiveType.Real32;
r2.DataType = PrimitiveType.Real32;
m.Assign(r2, m.Cast(PrimitiveType.Real64, r1));
m.MStore(m.Word32(0x123408), m.Cast(PrimitiveType.Real32, r2));
m.Return();
RunFileTest(m, "Analysis/DfaCastCast.txt");
}
public void VpCastCast()
{
var m = new ProcedureBuilder();
m.MStore(
m.Word32(0x1234000),
m.Cast(
PrimitiveType.Real32,
m.Cast(
PrimitiveType.Real64,
m.Mem(PrimitiveType.Real32, m.Word32(0x123400)))));
m.Return();
RunFileTest(m, "Analysis/VpCastCast.txt");
}
public void VpCastRealConstant()
{
var m = new ProcedureBuilder();
var r1 = m.Reg32("r1", 1);
m.Assign(r1, m.Cast(PrimitiveType.Real32, ConstantReal.Real64(1)));
var ssa = RunTest(m);
var sExp =
#region Expected
@"r1_1: orig: r1
def: r1_1 = 1.0F
// ProcedureBuilder
// Return size: 0
define ProcedureBuilder
ProcedureBuilder_entry:
// succ: l1
l1:
r1_1 = 1.0F
ProcedureBuilder_exit:
";
#endregion
AssertStringsEqual(sExp, ssa);
}
public void BwIndexInMemoryAddress()
{
// samples of switch statement emitted
// by the Microsoft VC compiler
var ebp = m.Frame.EnsureRegister(Registers.ebp);
var eax = m.Frame.EnsureRegister(Registers.eax);
var edx = m.Frame.EnsureRegister(Registers.edx);
// cmp [ebp-66],1D
m.Assign(SCZO, m.Cond(m.ISub(m.Mem32(m.ISub(ebp, 0xC4)), 0x1D)));
var block0 = m.CurrentBlock;
m.BranchIf(new TestCondition(ConditionCode.UGT, SCZO), "default");
// mov edx,[ebp-66]
// movzx eax,byte ptr [edx + 0x10000]
// jmp [eax + 0x12000]
m.Assign(edx, m.Mem32(m.ISub(ebp, 0xC4)));
m.Assign(eax, m.Cast(PrimitiveType.Word32, m.Mem8(m.IAdd(edx, 0x10000))));
var xfer = new RtlGoto(m.Mem32(m.IAdd(eax, 0x12000)), InstrClass.Transfer);
var block1 = m.CurrentBlock;
var bw = new Backwalker <Block, Instruction>(host, xfer, expSimp);
var ret = bw.BackwalkInstructions(Registers.eax, block1);
Assert.AreEqual("None", bw.Index.ToString());
Assert.AreEqual("Mem0[ebp - 0x000000C4:word32]", bw.IndexExpression.ToString());
Assert.AreEqual(4, bw.JumpSize);
Assert.IsTrue(ret);
ret = bw.BackwalkInstructions(null, block0);
}
public void VpUndoSlicingOfSegmentPointerCheckUses()
{
var es = Reg16("es");
var es_2 = Reg16("es_2");
var bx = Reg16("bx");
var bx_3 = Reg16("bx_3");
var bx_4 = Reg16("bx_4");
var es_bx_1 = Reg32("es_bx_1");
m.Store(SegMem(PrimitiveType.Byte, es, m.IAdd(bx, 4)), m.Byte(3));
m.Assign(es_bx_1, SegMem(PrimitiveType.Word32, es, bx));
m.Assign(es_2, m.Slice(PrimitiveType.Word16, es_bx_1, 16));
m.Assign(bx_3, m.Cast(PrimitiveType.Word16, es_bx_1));
var instr = m.Assign(bx_4, SegMem(PrimitiveType.Word16, es_2, m.IAdd(bx_3, 4)));
RunValuePropagator(m);
Assert.AreEqual("bx_4 = Mem8[es_bx_1 + 0x0004:word16]", instr.ToString());
}
public void VpUndoUnnecessarySlicingOfSegmentPointer()
{
var m = new ProcedureBuilder();
var es = m.Reg16("es", 1);
var bx = m.Reg16("bx", 3);
var es_bx = m.Frame.EnsureSequence(es.Storage, bx.Storage, PrimitiveType.Word32);
m.Assign(es_bx, m.SegMem(PrimitiveType.Word32, es, bx));
m.Assign(es, m.Slice(PrimitiveType.Word16, es_bx, 16));
m.Assign(bx, m.Cast(PrimitiveType.Word16, es_bx));
m.SStore(es, m.IAdd(bx, 4), m.Byte(3));
var ssa = RunTest(m);
var sExp =
#region Expected
@"es:es
def: def es
uses: es_bx_3 = Mem0[es:bx:word32]
bx:bx
def: def bx
uses: es_bx_3 = Mem0[es:bx:word32]
Mem0:Global memory
def: def Mem0
uses: es_bx_3 = Mem0[es:bx:word32]
es_bx_3: orig: es_bx
def: es_bx_3 = Mem0[es:bx:word32]
uses: es_4 = SLICE(es_bx_3, word16, 16)
bx_5 = (word16) es_bx_3
Mem6[es_bx_3 + 0x0004:byte] = 0x03
es_4: orig: es
def: es_4 = SLICE(es_bx_3, word16, 16)
bx_5: orig: bx
def: bx_5 = (word16) es_bx_3
Mem6: orig: Mem0
def: Mem6[es_bx_3 + 0x0004:byte] = 0x03
// ProcedureBuilder
// Return size: 0
void ProcedureBuilder()
ProcedureBuilder_entry:
def es
def bx
def Mem0
// succ: l1
l1:
es_bx_3 = Mem0[es:bx:word32]
es_4 = SLICE(es_bx_3, word16, 16)
bx_5 = (word16) es_bx_3
Mem6[es_bx_3 + 0x0004:byte] = 0x03
ProcedureBuilder_exit:
";
#endregion
AssertStringsEqual(sExp, ssa);
}
public void VpLoadDpbSmallerCast()
{
var m = new ProcedureBuilder();
var a2 = m.Reg32("a2", 10);
var d3 = m.Reg32("d3", 3);
var tmp = m.Temp(PrimitiveType.Word16, "tmp");
m.Assign(tmp, m.Mem16(a2));
m.Assign(d3, m.Dpb(d3, tmp, 0));
m.MStore(m.IAdd(a2, 4), m.Cast(PrimitiveType.Byte, d3));
SsaState ssa = RunTest(m);
var sExp =
#region Expected
@"a2:a2
def: def a2
uses: tmp_3 = Mem0[a2:word16]
Mem6[a2 + 4<32>:byte] = (byte) tmp_3
Mem0:Mem
def: def Mem0
uses: tmp_3 = Mem0[a2:word16]
tmp_3: orig: tmp
def: tmp_3 = Mem0[a2:word16]
uses: d3_5 = SEQ(SLICE(d3, word16, 16), tmp_3)
Mem6[a2 + 4<32>:byte] = (byte) tmp_3
d3:d3
def: def d3
uses: d3_5 = SEQ(SLICE(d3, word16, 16), tmp_3)
d3_5: orig: d3
def: d3_5 = SEQ(SLICE(d3, word16, 16), tmp_3)
uses: Mem6[a2 + 4<32>:byte] = (byte) tmp_3
Mem6: orig: Mem0
def: Mem6[a2 + 4<32>:byte] = (byte) tmp_3
// ProcedureBuilder
// Return size: 0
define ProcedureBuilder
ProcedureBuilder_entry:
def a2
def Mem0
def d3
// succ: l1
l1:
tmp_3 = Mem0[a2:word16]
d3_5 = SEQ(SLICE(d3, word16, 16), tmp_3)
Mem6[a2 + 4<32>:byte] = (byte) tmp_3
ProcedureBuilder_exit:
";
#endregion
AssertStringsEqual(sExp, ssa);
}
public void Usb_ParseFunctionDeclaration_WithRegisterArgs()
{
var arch = new FakeArchitecture();
var m = new ProcedureBuilder(arch, "test");
var r1 = m.Reg32("r1", 1);
var r2 = m.Reg32("r2", 2);
m.MStore(m.Word32(0x123400), m.Cast(PrimitiveType.Byte, r1));
m.MStore(m.Word32(0x123404), m.Cast(PrimitiveType.Real32, r2));
m.Return();
var usb = new UserSignatureBuilder(program);
usb.ApplySignatureToProcedure(
Address.Create(PrimitiveType.Ptr32, 0x1000),
FunctionType.Action(
new Identifier[] {
new Identifier("r2", PrimitiveType.Char, r1.Storage), // perverse but legal.
new Identifier("r1", PrimitiveType.Real32, r2.Storage)
}),
m.Procedure);
var sExp = @"// test
// Return size: 0
void test(char r2, real32 r1)
test_entry:
// succ: l1
l1:
r1 = r2
r2 = r1
Mem0[0x00123400:byte] = (byte) r1
Mem0[0x00123404:real32] = (real32) r2
return
// succ: test_exit
test_exit:
";
var sb = new StringWriter();
m.Procedure.Write(false, sb);
Assert.AreEqual(sExp, sb.ToString());
}
public void VpLoadDpbSmallerCast()
{
var m = new ProcedureBuilder();
var a2 = m.Reg32("a2", 10);
var d3 = m.Reg32("d3", 3);
var tmp = m.Temp(PrimitiveType.Word16, "tmp");
m.Assign(tmp, m.LoadW(a2));
m.Assign(d3, m.Dpb(d3, tmp, 0));
m.Store(m.IAdd(a2, 4), m.Cast(PrimitiveType.Byte, d3));
SsaState ssa = RunTest(m);
var sExp =
#region Expected
@"a2:a2
def: def a2
uses: tmp_2 = Mem0[a2:word16]
Mem5[a2 + 0x00000004:byte] = (byte) tmp_2
Mem0:Global memory
def: def Mem0
uses: tmp_2 = Mem0[a2:word16]
tmp_2: orig: tmp
def: tmp_2 = Mem0[a2:word16]
uses: d3_4 = DPB(d3, tmp_2, 0)
Mem5[a2 + 0x00000004:byte] = (byte) tmp_2
d3:d3
def: def d3
uses: d3_4 = DPB(d3, tmp_2, 0)
d3_4: orig: d3
def: d3_4 = DPB(d3, tmp_2, 0)
Mem5: orig: Mem0
def: Mem5[a2 + 0x00000004:byte] = (byte) tmp_2
// ProcedureBuilder
// Return size: 0
void ProcedureBuilder()
ProcedureBuilder_entry:
def a2
def Mem0
def d3
// succ: l1
l1:
tmp_2 = Mem0[a2:word16]
d3_4 = DPB(d3, tmp_2, 0)
Mem5[a2 + 0x00000004:byte] = (byte) tmp_2
ProcedureBuilder_exit:
";
#endregion
AssertStringsEqual(sExp, ssa);
}
public void BwReg_00121()
{
var d0 = m.Reg32("d0", 0);
var d3 = m.Reg32("d3", 3);
var a5 = m.Reg32("a5", 5);
var v38 = m.Temp(PrimitiveType.Word16, "v38");
var v39 = m.Temp(PrimitiveType.Byte, "v39");
var v40 = m.Temp(PrimitiveType.Word16, "v40");
var VZN = m.Flags("VZN");
var ZN = m.Flags("ZN");
var C = m.Flags("C");
var V = m.Flags("V");
var CVZN = m.Flags("CVZN");
var CVZNX = m.Flags("CVZNX");
m.Assign(d0, d3);
m.Assign(CVZN, m.Cond(d0));
m.Assign(v38, m.And(m.Cast(PrimitiveType.Word16, d0), 0xF0));
m.Assign(d0, m.Dpb(d0, v38, 0));
m.Assign(ZN, m.Cond(v38));
m.Assign(C, false);
m.Assign(V, false);
m.Assign(v39, m.Shl(m.Cast(PrimitiveType.Byte, d0), 2));
m.Assign(d0, m.Dpb(d0, v39, 0));
m.Assign(CVZNX, m.Cond(v39));
m.Assign(v40, m.ISub(m.Cast(PrimitiveType.Word16, d0), 44));
m.Assign(CVZN, m.Cond(v40));
m.BranchIf(m.Test(ConditionCode.GT, VZN), "lDefault");
m.Assign(a5, m.Mem32(m.IAdd(Address.Ptr32(0x0000C046), d0)));
var xfer = new RtlCall(a5, 4, InstrClass.Transfer);
var bw = new Backwalker <Block, Instruction>(host, xfer, expSimp);
Assert.IsTrue(bw.CanBackwalk());
Assert.AreEqual("a5", bw.Index.Name);
bw.BackWalk(m.Block);
Assert.AreEqual("v40", bw.IndexExpression.ToString());
}
