public void TtranArrayAssignment()
{
var pp = new ProgramBuilder();
pp.Add("Fn", m =>
{
Identifier rbx_18 = m.Local(PrimitiveType.Create(Domain.Integer | Domain.Real | Domain.Pointer, 64), "rbx_18");
Identifier rdx = m.Local(PrimitiveType.Create(Domain.Integer | Domain.Real | Domain.Pointer, 64), "rdx");
Identifier rax_22 = m.Local(PrimitiveType.Create(Domain.Integer | Domain.Real | Domain.Pointer, 64), "rax_22");
Identifier rsi = m.Local(PrimitiveType.Create(Domain.Integer | Domain.Real | Domain.Pointer, 64), "rsi");
Identifier rdi = m.Local(PrimitiveType.Create(Domain.Integer | Domain.Real | Domain.Pointer, 64), "rdi");
m.Label("l000000000040EC30");
m.Declare(rbx_18, m.ISub(rdx, Constant.Create(PrimitiveType.Create(Domain.Integer | Domain.Real | Domain.Pointer, 64), 0x1)));
m.BranchIf(m.Eq(rdx, Constant.Create(PrimitiveType.Create(Domain.Integer | Domain.Real | Domain.Pointer, 64), 0x0)), "l000000000040EC69");
m.Label("l000000000040EC40");
m.Declare(rax_22, m.Word64(0x10000040));
m.Label("l000000000040EC50");
m.MStore(m.IAdd(rdi, rbx_18), m.Convert(m.Mem32(
m.IAdd(m.Mem64(rax_22), m.IMul(
m.Convert(
m.Convert(
m.Mem8(m.IAdd(rsi, rbx_18)),
PrimitiveType.Byte,
PrimitiveType.Word32),
PrimitiveType.Word32,
PrimitiveType.Word64),
Constant.Create(PrimitiveType.Word64, 0x4)))),
PrimitiveType.Word32,
PrimitiveType.Byte));
m.Assign(rbx_18, m.ISub(rbx_18, Constant.Create(PrimitiveType.Word64, 0x1)));
m.BranchIf(m.Ne(rbx_18, Constant.Create(PrimitiveType.Word64, 0xFFFFFFFFFFFFFFFF)), "l000000000040EC50");
m.Label("l000000000040EC69");
m.Return();
});
RunTest(pp.BuildProgram(), $"Typing/{nameof(TtranArrayAssignment)}.txt");
}
public void TerDereferenceSignedCompare()
{
ProgramBuilder prog = CreateProgramBuilder(0x5000, 0x1000);
prog.Add("proc1", m =>
{
Identifier p = m.Local32("p");
Identifier ds = m.Local16("ds");
ds.DataType = PrimitiveType.SegmentSelector;
Identifier ds2 = m.Local16("ds2");
ds2.DataType = PrimitiveType.SegmentSelector;
m.Assign(ds2, ds);
m.Store(
m.SegMem(PrimitiveType.Bool, ds, m.Word16(0x5400)),
m.Lt(
m.SegMemW(ds, m.IAdd(m.SegMemW(ds, m.Word16(0x5404)), 4)),
m.Word16(20)));
m.Store(m.SegMemW(ds2, m.IAdd(m.SegMemW(ds2, m.Word16(0x5404)), 4)), m.Word16(0));
m.Return();
});
RunTest(prog.BuildProgram(), "Typing/TerDereferenceSignedCompare.txt");
}
public void CceShrRcrPattern()
{
var p = new ProgramBuilder(new FakeArchitecture(new ServiceContainer()));
p.Add("main", (m) =>
{
var C = m.Flags("C");
var r1 = MockReg(m, 1);
var r2 = MockReg(m, 2);
m.Assign(r1, m.Shr(r1, 1));
m.Assign(C, m.Cond(r1));
m.Assign(r2, m.Fn(
new IntrinsicProcedure(IntrinsicProcedure.RorC, true, r2.DataType, 2),
r2, Constant.Byte(1), C));
m.Assign(C, m.Cond(r2));
m.MStore(m.Word32(0x3000), r2);
m.MStore(m.Word32(0x3004), r1);
m.Return();
});
RunTest(p, "Analysis/CceShrRcrPattern.txt");
}
public void CceAddAdcPattern()
{
var p = new ProgramBuilder(new FakeArchitecture());
p.Add("main", (m) =>
{
var r1 = MockReg(m, 1);
var r2 = MockReg(m, 2);
var r3 = MockReg(m, 3);
var r4 = MockReg(m, 4);
var SCZ = m.Frame.EnsureFlagGroup(0x7, "SZC", PrimitiveType.Byte);
var C = m.Frame.EnsureFlagGroup(0x4, "C", PrimitiveType.Byte);
m.Assign(r1, m.IAdd(r1, r2));
m.Assign(SCZ, m.Cond(r1));
m.Assign(r3, m.IAdd(m.IAdd(r3, r4), C));
m.Store(m.Word32(0x0444400), r1);
m.Store(m.Word32(0x0444404), r3);
m.Return();
});
RunTest(p, "Analysis/CceAddAdcPattern.txt");
}
public void TerPassARefToFunction()
{
var sExp =
@"// Before ///////
// main
// Return size: 0
define main
main_entry:
// succ: l1
l1:
r1 = Mem0[r0 + 0<32>:word32]
r1 = Mem0[r0 + r1 * 4<32>:word32]
main_exit:
// After ///////
// main
// Return size: 0
define main
main_entry:
// succ: l1
l1:
r1 = r0[0<i32>]
r1 = r0[r1]
main_exit:
";
var pb = new ProgramBuilder();
pb.Add("main", m =>
{
var r0 = m.Register("r0");
var r1 = m.Register("r1");
var r2 = m.Register("r2");
var r3 = m.Register("r3");
m.Assign(r1, m.Mem32(m.IAdd(r0, 0)));
m.Assign(r1, m.Mem32(m.IAdd(r0, m.IMul(r1, 4))));
});
RunStringTest(pb.BuildProgram(), sExp);
}
public void CceShlRclPattern()
{
var p = new ProgramBuilder();
p.Add("main", (m) =>
{
var C = m.Flags("C");
var r1 = MockReg(m, 1);
var r2 = MockReg(m, 2);
m.Assign(r1, m.Shl(r1, 1));
m.Assign(C, m.Cond(r1));
m.Assign(r2, m.Fn(
new PseudoProcedure(PseudoProcedure.RolC, r2.DataType, 2),
r2, Constant.Byte(1), C));
m.Assign(C, m.Cond(r2));
m.MStore(m.Word32(0x3000), r1);
m.MStore(m.Word32(0x3004), r2);
m.Return();
});
RunTest(p, "Analysis/CceShlRclPattern.txt");
}
public void TerArray()
{
var pm = new ProgramBuilder();
pm.Add("proc1", m =>
{
var eax = m.Reg32("eax");
var ecx = m.Reg32("ecx");
var eax_2 = m.Reg32("eax_2");
m.Assign(
eax_2,
m.Cast(PrimitiveType.Int32,
m.Load(PrimitiveType.Int16,
m.IAdd(
ecx,
m.IAdd(
m.IMul(eax, 2),
100)))));
m.Store(m.Word32(0x010000), eax_2);
});
RunTest(pm, "Typing/TerArray.txt");
}
public void CceAddAdcPattern()
{
var p = new ProgramBuilder(new FakeArchitecture());
p.Add("main", (m) =>
{
var r1 = m.Reg32("r1", 1);
var r2 = m.Reg32("r2", 2);
var r3 = m.Reg32("r3", 3);
var r4 = m.Reg32("r4", 4);
var flags = new RegisterStorage("flags", 0x0A, 0, PrimitiveType.Word32);
var SCZ = m.Frame.EnsureFlagGroup(flags, 0x7, "SZC", PrimitiveType.Byte);
var C = m.Frame.EnsureFlagGroup(flags, 0x4, "C", PrimitiveType.Byte);
m.Assign(r1, m.IAdd(r1, r2));
m.Assign(SCZ, m.Cond(r1));
m.Assign(r3, m.IAdd(m.IAdd(r3, r4), C));
m.MStore(m.Word32(0x0444400), r1);
m.MStore(m.Word32(0x0444404), r3);
m.Return();
});
RunTest(p, "Analysis/CceAddAdcPattern.txt");
}
public void TerTypedAddressOf()
{
var pb = new ProgramBuilder();
pb.Add("TypedAddressOf", m =>
{
var str = new TypeReference("foo", new StructureType("foo", 0)
{
Fields =
{
{ 0, PrimitiveType.Int16, "word00" },
{ 4, PrimitiveType.Byte, "byte004" }
}
});
var foo = new Identifier("foo", str, new MemoryStorage());
var r1 = m.Reg32("r1", 1);
m.Declare(r1, m.AddrOf(foo));
m.MStore(r1, m.Word16(0x1234));
m.MStore(m.IAdd(r1, 4), m.Byte(0x0A));
m.Return();
});
RunTest(pb.BuildProgram());
}
public void EP_ConditionOf()
{
var p = new ProgramBuilder();
var proc = p.Add("main", (m) =>
{
var szo = m.Frame.EnsureFlagGroup(0x7, "SZO", PrimitiveType.Byte);
var ebx = m.Frame.EnsureRegister(new RegisterStorage("ebx", 0, PrimitiveType.Word32));
var v4 = m.Frame.CreateTemporary(PrimitiveType.Word16);
m.Assign(v4, m.IAdd(m.LoadW(ebx), 1));
m.Store(ebx, v4);
m.Assign(szo, m.Cond(v4));
m.Return();
});
var ctx = new SymbolicEvaluationContext(new IntelArchitecture(ProcessorMode.Protected32), proc.Frame);
var simplifier = new ExpressionSimplifier(ctx);
var ep = new ExpressionPropagator(null, simplifier, ctx, new ProgramDataFlow());
var newInstr = proc.EntryBlock.Succ[0].Statements[2].Instruction.Accept(ep);
Assert.AreEqual("SZO = cond(v4)", newInstr.ToString());
}
public void EP_Application()
{
var p = new ProgramBuilder();
var proc = p.Add("main", (m) =>
{
var r1 = m.Frame.EnsureRegister(new RegisterStorage("r1", 1, PrimitiveType.Word32));
m.Assign(r1, m.Word32(0x42));
m.SideEffect(m.Fn("foo", r1));
m.Return();
});
var ctx = new SymbolicEvaluationContext(new FakeArchitecture(), proc.Frame);
var simplifier = new ExpressionSimplifier(ctx);
var ep = new ExpressionPropagator(null, simplifier, ctx, new ProgramDataFlow());
var stms = proc.EntryBlock.Succ[0].Statements;
stms[0].Instruction.Accept(ep);
var newInstr = stms[1].Instruction.Accept(ep);
Assert.AreEqual("foo(0x00000042)", newInstr.ToString());
}
public void TtranTypedAddressOf()
{
var pb = new ProgramBuilder();
pb.Add("TypedAddressOf", m =>
{
var str = new TypeReference("foo", new StructureType("foo", 0)
{
Fields =
{
{ 0, PrimitiveType.Int16, "word00" },
{ 4, PrimitiveType.Byte, "byte004" }
}
});
var foo = Identifier.Global("foo", str);
var r1 = m.Reg32("r1", 1);
m.Declare(r1, m.AddrOf(PrimitiveType.Ptr32, foo));
m.MStore(r1, m.Word16(0x1234));
m.MStore(m.IAdd(r1, 4), m.Byte(0x0A));
m.Return();
});
RunTest(pb.BuildProgram(), "Typing/TtranTypedAddressOf.txt");
}
public void Regp_Preserve()
{
var pb = new ProgramBuilder(new FakeArchitecture());
pb.Add("test", m =>
{
var r1 = m.Register(1);
m.Assign(r1, m.Mem32(m.Word32(0x3000)));
m.Return();
});
program = pb.BuildProgram();
RunTest(program.Procedures.Values);
var sExp =
#region Expected
@"// test
// Return size: 0
void test()
test_entry:
def Mem0
// succ: l1
l1:
r1_1 = Mem0[0x00003000:word32]
return
// succ: test_exit
test_exit:
use Mem0
use r1_1
test:
Preserved: Global memory
Trashed: r1
";
#endregion
AssertProgram(sExp, program.Procedures.Values);
}
public void Dfa2_FactorialReg()
{
pb = new ProgramBuilder();
pb.Add("fact", m =>
{
var sp = m.Register(m.Architecture.StackRegister);
var r1 = m.Register(1);
var r2 = m.Register(2);
var r3 = m.Register(3);
var cc = m.Flags(0xF, "cc");
m.Assign(sp, m.Frame.FramePointer);
m.Assign(r2, r1);
m.Assign(r1, 1);
m.Assign(cc, m.Cond(m.ISub(r2, r1)));
m.BranchIf(m.Test(ConditionCode.LE, cc), "done");
m.Assign(sp, m.ISub(sp, 4));
m.Store(sp, r2);
m.Assign(r1, m.ISub(r2, r1));
m.Call("fact", 0);
m.Assign(r2, m.LoadDw(sp));
m.Assign(sp, m.IAdd(sp, 4));
m.Assign(r1, m.IMul(r1, r2));
m.Label("done");
m.Return();
});
var dfa = new DataFlowAnalysis(pb.BuildProgram(), new FakeDecompilerEventListener());
dfa.UntangleProcedures2();
var sExp =
@"@@@";
AssertProgram(sExp, pb);
}
public void Uvr_Forks()
{
var arch = new FakeArchitecture();
var pb = new ProgramBuilder(arch);
var _r1 = arch.GetRegister("r1");
var _r2 = arch.GetRegister("r2");
pb.Add("main", m =>
{
var r1 = m.Frame.EnsureRegister(_r1);
m.Assign(m.Frame.EnsureRegister(m.Architecture.StackRegister), m.Frame.FramePointer);
m.Call("foo", 0);
m.MStore(m.Ptr32(0x123420), r1);
});
pb.Add("foo", m =>
{
var r1 = m.Frame.EnsureRegister(_r1);
var r2 = m.Frame.EnsureRegister(_r2);
m.Assign(m.Frame.EnsureRegister(m.Architecture.StackRegister), m.Frame.FramePointer);
m.Assign(r1, m.Mem32(m.Ptr32(0x123400)));
m.MStore(m.Ptr32(0x123408), r1);
m.Assign(r2, m.Mem32(m.Ptr32(0x123410)));
m.MStore(m.Ptr32(0x123418), r2);
m.Return();
});
pb.BuildProgram();
var sExp =
#region Expected
@"// main
// Return size: 0
define main
main_entry:
// succ: l1
l1:
call foo (retsize: 0;)
defs: r1:r1_3
Mem5[0x00123420<p32>:word32] = r1_3
main_exit:
===
// foo
// Return size: 0
define foo
foo_entry:
def Mem0
// succ: l1
l1:
r1_4 = Mem0[0x00123400<p32>:word32]
Mem5[0x00123408<p32>:word32] = r1_4
r2_6 = Mem5[0x00123410<p32>:word32]
Mem7[0x00123418<p32>:word32] = r2_6
return
// succ: foo_exit
foo_exit:
use r1_4
===
";
#endregion
RunTest(sExp, pb.Program);
}
public void CrwOutParameter()
{
var pb = new ProgramBuilder();
pb.Add("main", m =>
{
var r1 = m.Reg32("r1");
var r2 = m.Reg32("r2");
m.Assign(m.Frame.EnsureRegister(m.Architecture.StackRegister), m.Frame.FramePointer);
m.Call("fnOutParam", 0);
m.MStore(m.Ptr32(0x00123400), r1);
m.MStore(m.Ptr32(0x00123404), r2);
m.Return();
});
pb.Add("fnOutParam", m =>
{
var r1 = m.Reg32("r1");
var r2 = m.Reg32("r2");
m.Label("m0");
m.Assign(m.Frame.EnsureRegister(m.Architecture.StackRegister), m.Frame.FramePointer);
m.BranchIf(m.Eq0(r1), "m2");
m.Label("m1");
m.Assign(r1, m.IAdd(r1, 3));
m.Assign(r2, m.ISub(r2, 3));
m.Return();
m.Label("m2");
m.Assign(r1, 0);
m.Assign(r2, 0);
m.Return();
});
var sExp =
#region Expected
@"void main(Register word32 r1, Register word32 r2)
// MayUse: r1:[0..31] r2:[0..31]
// LiveOut:
// Trashed: r1 r2
// Preserved: r63
// main
// Return size: 0
// Mem0:Mem
// fp:fp
// r1:r1
// r2:r2
// r63:r63
// return address size: 0
void main(word32 r1, word32 r2)
main_entry:
def r1
def r2
// succ: l1
l1:
r1_5 = fnOutParam(r1, r2, out r2_6)
Mem7[0x00123400<p32>:word32] = r1_5
Mem8[0x00123404<p32>:word32] = r2_6
return
// succ: main_exit
main_exit:
Register word32 fnOutParam(Register word32 r1, Register word32 r2, Register out ptr32 r2Out)
// MayUse: r1:[0..31] r2:[0..31]
// LiveOut: r1 r2
// Trashed: r1 r2
// Preserved: r63
// fnOutParam
// Return size: 0
// Mem0:Mem
// fp:fp
// r1:r1
// r2:r2
// r63:r63
// r2Out:Out:r2
// return address size: 0
word32 fnOutParam(word32 r1, word32 r2, ptr32 & r2Out)
fnOutParam_entry:
def r1
def r2
// succ: m0
m0:
branch r1 == 0<32> m2
// succ: m1 m2
m1:
r1_6 = r1 + 3<32>
r2_8 = r2 - 3<32>
r2Out = r2_8
return r1_6
// succ: fnOutParam_exit
m2:
r1_4 = 0<32>
r2_5 = 0<32>
r2Out = r2_5
return r1_4
// succ: fnOutParam_exit
fnOutParam_exit:
";
#endregion
RunStringTest(sExp, pb.BuildProgram());
}
public void CrwFpuMultiplyAdd()
{
var dt = PrimitiveType.Real64;
var arch = new FakeArchitecture(new ServiceContainer());
var ST = arch.FpuStackBase;
var _top = arch.FpuStackRegister;
var pb = new ProgramBuilder(arch);
pb.Add("main", m =>
{
var Top = m.Frame.EnsureRegister(arch.FpuStackRegister);
m.Assign(m.Frame.EnsureRegister(m.Architecture.StackRegister), m.Frame.FramePointer);
m.Assign(Top, 0);
m.Assign(Top, m.ISub(Top, 1));
m.MStore(ST, Top, Constant.Real64(3.0));
m.Assign(Top, m.ISub(Top, 1));
m.MStore(ST, Top, Constant.Real64(4.0));
m.Assign(Top, m.ISub(Top, 1));
m.MStore(ST, Top, Constant.Real64(5.0));
// At this point there are 3 values on the FPU stack
m.Call("FpuMultiplyAdd", 0);
m.MStore(m.Ptr32(0x00123400), m.Mem(ST, dt, Top));
m.Assign(Top, m.IAdd(Top, 1));
m.Return();
});
pb.Add("FpuMultiplyAdd", m =>
{
var Top = m.Frame.EnsureRegister(_top);
m.Assign(m.Frame.EnsureRegister(m.Architecture.StackRegister), m.Frame.FramePointer);
m.Assign(Top, 0);
m.MStore(ST, m.IAdd(Top, 1), m.FMul(
m.Mem(ST, dt, m.IAdd(Top, 1)),
m.Mem(ST, dt, Top)));
m.Assign(Top, m.IAdd(Top, 1));
m.MStore(ST, m.IAdd(Top, 1), m.FAdd(
m.Mem(ST, dt, m.IAdd(Top, 1)),
m.Mem(ST, dt, Top)));
m.Assign(Top, m.IAdd(Top, 1));
// At this point two values have been popped from the
// FPU stack, leaving one.
m.Return();
});
var sExp =
#region Expected
@"void main()
// MayUse:
// LiveOut:
// Trashed: FPU -1 FPU -2 FPU -3 Top
// Preserved: r63
// main
// Return size: 0
// Mem0:Mem
// fp:fp
// Top:Top
// r63:r63
// rRet0:rRet0
// rLoc1:FPU -1
// rLoc2:FPU -2
// rLoc3:FPU -3
// return address size: 0
void main()
main_entry:
// succ: l1
l1:
rRet0_10 = FpuMultiplyAdd(5.0, 4.0, 3.0)
Mem13[0x00123400<p32>:real64] = rRet0_10
return
// succ: main_exit
main_exit:
FpuStack real64 FpuMultiplyAdd(FpuStack real64 rArg0, FpuStack real64 rArg1, FpuStack real64 rArg2)
// MayUse: FPU +0:[0..63] FPU +1:[0..63] FPU +2:[0..63]
// LiveOut: FPU +2
// Trashed: FPU +1 FPU +2 Top
// Preserved: r63
// FpuMultiplyAdd
// Return size: 0
// Mem0:Mem
// fp:fp
// Top:Top
// r63:r63
// rArg1:FPU +1
// rArg0:FPU +0
// rArg2:FPU +2
// return address size: 0
real64 FpuMultiplyAdd(real64 rArg0, real64 rArg1, real64 rArg2)
FpuMultiplyAdd_entry:
def rArg1
def rArg0
def rArg2
// succ: l1
l1:
rArg1_11 = rArg1 * rArg0
rArg2_13 = rArg2 + rArg1_11
return rArg2_13
// succ: FpuMultiplyAdd_exit
FpuMultiplyAdd_exit:
";
#endregion
RunStringTest(sExp, pb.BuildProgram());
}
public void TtranCallTable()
{
var pb = new ProgramBuilder();
pb.Add(new IndirectCallFragment());
RunTest(pb.BuildProgram(), "Typing/TtranCallTable.txt");
}
public void TtranArrayExpression()
{
var m = new ProgramBuilder();
m.Add(new ArrayExpressionFragment());
RunTest(m.BuildProgram(), "Typing/TtranArrayExpression.txt");
}
public void TtranTreeFind()
{
ProgramBuilder m = new ProgramBuilder();
m.Add(new TreeFindMock());
RunTest(m.BuildProgram(), "Typing/TtranTreeFind.txt");
}
public void Dfa2_StackArgs_Nested()
{
pb = new ProgramBuilder();
pb.Add("main", m =>
{
var r1 = m.Register("r1");
var sp = m.Frame.EnsureRegister(m.Architecture.StackRegister);
m.Assign(sp, m.Frame.FramePointer);
m.Assign(sp, m.ISub(sp, 4));
m.MStore(sp, m.Mem32(m.Ptr32(0x123400)));
m.Call("level1", 4);
m.Assign(sp, m.IAdd(sp, 4));
m.MStore(m.Ptr32(0x123404), r1);
m.Return();
});
pb.Add("level1", m =>
{
var r1 = m.Register("r1");
var sp = m.Frame.EnsureRegister(m.Architecture.StackRegister);
m.Assign(sp, m.Frame.FramePointer);
m.Assign(r1, m.Mem32(m.IAdd(sp, 4)));
m.Assign(sp, m.ISub(sp, 4));
m.MStore(sp, r1);
m.Call("level2", 4);
m.Assign(sp, m.IAdd(sp, 4));
m.Return();
});
pb.Add("level2", m =>
{
var r1 = m.Register("r1");
var r2 = m.Register("r2");
var sp = m.Frame.EnsureRegister(m.Architecture.StackRegister);
m.Assign(sp, m.Frame.FramePointer);
m.Assign(r1, m.Mem32(m.IAdd(sp, 4)));
m.Assign(r1, m.IAdd(r1, 1));
m.Return();
});
var program = pb.BuildProgram();
var dfa = new DataFlowAnalysis(program, dynamicLinker.Object, sc);
dfa.AnalyzeProgram();
var sExp =
#region Expected
@"// main
// Return size: 0
void main()
main_entry:
// succ: l1
l1:
Mem8[0x00123404<p32>:word32] = level1(Mem0[0x00123400<p32>:word32])
return
// succ: main_exit
main_exit:
===
// level1
// Return size: 0
word32 level1(word32 dwArg04)
level1_entry:
// succ: l1
l1:
return level2(dwArg04)
// succ: level1_exit
level1_exit:
===
// level2
// Return size: 0
word32 level2(word32 dwArg04)
level2_entry:
// succ: l1
l1:
return dwArg04 + 1<32>
// succ: level2_exit
level2_exit:
";
#endregion
AssertProgram(sExp, pb.Program);
}
public void TtranStaggeredArrays()
{
ProgramBuilder prog = new ProgramBuilder();
prog.Add(new StaggeredArraysFragment());
RunTest(prog.BuildProgram(), "Typing/TtranStaggeredArrays.txt");
}
public void TtranRepeatedLoads()
{
ProgramBuilder prog = new ProgramBuilder();
prog.Add(new RepeatedLoadsFragment());
RunTest(prog.BuildProgram(), "Typing/TtranRepeatedLoads.txt");
}
public void Uvr_Signature()
{
var arch = new FakeArchitecture();
var pb = new ProgramBuilder(arch);
var _r1 = arch.GetRegister("r1");
var _r2 = arch.GetRegister("r2");
pb.Add("main", m =>
{
var r1 = m.Frame.EnsureRegister(_r1);
m.Assign(m.Frame.EnsureRegister(m.Architecture.StackRegister), m.Frame.FramePointer);
m.Call("foo", 0);
m.MStore(m.Ptr32(0x123420), r1);
});
pb.Add("foo", m =>
{
var r1 = m.Frame.EnsureRegister(_r1);
var r2 = m.Frame.EnsureRegister(_r2);
m.Assign(m.Frame.EnsureRegister(m.Architecture.StackRegister), m.Frame.FramePointer);
m.Assign(r1, m.Mem32(m.Ptr32(0x123400)));
m.MStore(m.Ptr32(0x123408), r1);
m.Assign(r2, m.Mem32(m.Ptr32(0x123410)));
m.MStore(m.Ptr32(0x123418), r2);
m.Return();
m.Procedure.Signature = FunctionType.Func(
new Identifier(null, PrimitiveType.Word32, _r1),
new Identifier("arg1", PrimitiveType.Word32, _r2));
});
pb.BuildProgram();
var sExp =
#region Expected
@"// main
// Return size: 0
define main
main_entry:
def r2
// succ: l1
l1:
r1_4 = foo(r2)
Mem5[0x00123420<p32>:word32] = r1_4
main_exit:
===
// foo
// Return size: 0
word32 foo(word32 arg1)
foo_entry:
def fp
def Mem0
// succ: l1
l1:
r63_2 = fp
r1_4 = Mem0[0x00123400<p32>:word32]
Mem5[0x00123408<p32>:word32] = r1_4
r2_6 = Mem5[0x00123410<p32>:word32]
Mem7[0x00123418<p32>:word32] = r2_6
return
// succ: foo_exit
foo_exit:
use r1_4
===
";
#endregion
RunTest(sExp, pb.Program);
}
public void Uvr_Chain()
{
var arch = new FakeArchitecture();
var _r1 = arch.GetRegister("r1");
var _r2 = arch.GetRegister("r2");
var _r3 = arch.GetRegister("r3");
var pb = new ProgramBuilder();
pb.Add("main", m =>
{
var r1 = m.Frame.EnsureRegister(_r1);
m.Assign(m.Frame.EnsureRegister(m.Architecture.StackRegister), m.Frame.FramePointer);
m.Call("level1", 0);
m.MStore(m.Ptr32(0x00123400), m.Cast(PrimitiveType.Byte, r1)); // forces r1 to be liveout on level1
m.Return();
});
pb.Add("level1", m =>
{
// We expect r2 to be live-in, as level2 uses it, and r1 to be leve
m.Assign(m.Frame.EnsureRegister(m.Architecture.StackRegister), m.Frame.FramePointer);
m.Call("level2", 0);
m.Return();
});
pb.Add("level2", m =>
{
var r1 = m.Frame.EnsureRegister(_r1);
var r2 = m.Frame.EnsureRegister(_r2);
m.Assign(m.Frame.EnsureRegister(m.Architecture.StackRegister), m.Frame.FramePointer);
m.Assign(r1, m.Mem32(r2));
m.Return();
});
pb.BuildProgram();
var sExp =
#region
@"// main
// Return size: 0
define main
main_entry:
def r2
// succ: l1
l1:
call level1 (retsize: 0;)
uses: r2:r2
defs: r1:r1_4
Mem5[0x00123400<p32>:byte] = (byte) r1_4
return
// succ: main_exit
main_exit:
===
// level1
// Return size: 0
define level1
level1_entry:
def r2
// succ: l1
l1:
call level2 (retsize: 0;)
uses: r2:r2
defs: r1:r1_4
return
// succ: level1_exit
level1_exit:
use r1_4
===
// level2
// Return size: 0
define level2
level2_entry:
def r2
def Mem0
// succ: l1
l1:
r1_5 = Mem0[r2:word32]
return
// succ: level2_exit
level2_exit:
use r1_5
===
";
#endregion
RunTest(sExp, pb.Program);
}
public void TtranSegmentedPointer()
{
var m = new ProgramBuilder();
m.Add(new SegmentedPointerProc());
RunTest(m.BuildProgram(), "Typing/TtranSegmentedPointer.txt");
}
public void TtranFnPointerMock()
{
ProgramBuilder prog = new ProgramBuilder();
prog.Add(new FnPointerFragment());
RunTest(prog.BuildProgram(), "Typing/TtranFnPointerMock.txt");
}
public void TtranSegmentedCall()
{
var m = new ProgramBuilder();
m.Add(new SegmentedCallFragment());
RunTest(m.BuildProgram(), "Typing/TtranSegmentedCall.txt");
}
public void Jps_CallsApplications()
{
var sExpMain =
"{" +
"'name':'main','signature':''," +
"'ids':[{'name':'f1','type':'w64','stg':{'kind':'reg','name':'f1'}}]," +
"'blocks':[" +
"{'name':'main_entry'," +
"'succ':['l0010']}," +
"{'name':'main_exit','exit':true}," +
"{'name':'l0010','linaddr':4096,'stms':[" +
"[0,'call','sub',0,0,['r1','r2']['f1']],[1,'ret','f1']]," +
"'succ':['main_exit']}]}";
var sExpSub =
"{" +
"'name':'sub','signature':'','ids':[" +
"{'name':'f1','type':'w64','stg':{'kind':'reg','name':'f1'}}," +
"{'name':'Mem0','stg':{'kind':'mem'}}," +
"{'name':'r1','type':'w32','stg':{'kind':'reg','name':'r1'}}," +
"{'name':'r2','type':'w32','stg':{'kind':'reg','name':'r2'}}]," +
"'blocks':[" +
"{'name':'sub_entry','succ':['l1000']}," +
"{'name':'sub_exit','exit':true}," +
"{'name':'l1000','linaddr':8192,'stms':[" +
"[0,'=','f1',['cos',['m','Mem0','r1','r64']]," +
"[1,'=','f1',['sin',['m','Mem0','r2','r64']]," +
"[2,'=','f1',['-f','f1','f1']],[3,'ret','f1']]," +
"'succ':['sub_exit']}]}";
var sin = new ExternalProcedure("sin", new FunctionType(
new Identifier("", PrimitiveType.Real64, null),
new Identifier("arg", PrimitiveType.Real64, null)));
var cos = new ExternalProcedure("cos", new FunctionType(
new Identifier("", PrimitiveType.Real64, null),
new Identifier("arg", PrimitiveType.Real64, null)));
pb.Add("main", m =>
{
var r1 = m.Reg32("r1", 1);
var r2 = m.Reg32("r2", 2);
var f1 = m.Reg64("f1", 2);
var f3 = m.Reg64("f3", 3);
var SZ = m.Flags("SZ");
m.Label("l0010");
m.Call("sub", 0, new[] { r1, r2 }, new[] { f1 });
m.Return(f1);
});
pb.Add("sub", m =>
{
var r1 = m.Reg32("r1", 1);
var r2 = m.Reg32("r2", 2);
var f1 = m.Reg64("f1", 2);
var f2 = m.Reg64("f1", 2);
m.Label("l1000");
m.Assign(f1, m.Fn(cos, m.Load(PrimitiveType.Real64, r1)));
m.Assign(f2, m.Fn(sin, m.Load(PrimitiveType.Real64, r2)));
m.Assign(f1, m.FSub(f1, f2));
m.Return(f1);
});
pb.BuildProgram();
RunTest(sExpMain, pb.Program.Procedures.Values[0]);
RunTest(sExpSub, pb.Program.Procedures.Values[1]);
}
public void TtranIntelIndexedAddressingMode()
{
ProgramBuilder m = new ProgramBuilder();
m.Add(new IntelIndexedAddressingMode());
RunTest(m.BuildProgram(), "Typing/TtranIntelIndexedAddressingMode.txt");
}
