public void Generates_Declare_Variables_Statements()
{
var name = new SchemaObjectName();
name.Identifiers.Add("dbo".ToIdentifier());
name.Identifiers.Add("procedureName".ToIdentifier());
var builder = new ProcedureBuilder("[procedureName]", "[test blah bloo blah]", name);
builder.AddParameter("@p1", SqlDataType.Date);
builder.AddTable(name);
var script = builder.GetScript();
const string expectedP1 = "DECLARE @p1 AS DATE";
Assert.True(script.IndexOf(expectedP1) > -1, "Did not find declare statement for p1: \"{0}\"", script);
}
public void Generates_FakeTake_Statements()
{
var name = new SchemaObjectName();
name.Identifiers.Add("dbo".ToIdentifier());
name.Identifiers.Add("procedureName".ToIdentifier());
var builder = new ProcedureBuilder("[procedureName]", "[test blah bloo blah]", name);
var tableName = new SchemaObjectName();
tableName.Identifiers.Add("someschema".ToIdentifier());
tableName.Identifiers.Add("table_thingy".ToIdentifier());
builder.AddTable(tableName);
var script = builder.GetScript();
const string expected = "EXECUTE tSQLt.FakeTable 'table_thingy', 'someschema'";
Assert.True(script.IndexOf(expected) > -1, "Did not find faketable statement: \"{0}\"", script);
}
public void SsaSwitchWithSharedBranches()
{
var m = new ProcedureBuilder("SsaSwitchWithSharedBranches");
var sp = m.Frame.EnsureRegister(m.Architecture.StackRegister);
var r1 = m.Reg32("r1", 1);
var r2 = m.Reg32("r2", 2);
var foo = new ExternalProcedure("foo", new FunctionType(
new Identifier("", VoidType.Instance, null),
new Identifier("arg1", PrimitiveType.Int32, new StackArgumentStorage(4, PrimitiveType.Int32))));
m.Assign(sp, m.Frame.FramePointer);
m.Assign(r1, m.Mem32(m.IAdd(sp, 4)));
m.BranchIf(m.Ugt(r1, m.Word32(0x5)), "m4_default");
m.Label("m1");
m.Switch(r1,
"m2", "m2", "m3", "m3", "m2", "m3");
m.Label("m2");
m.Assign(sp, m.ISub(sp, 4));
m.MStore(sp, m.Word32(0x42));
m.Call(foo, 4);
m.Assign(sp, m.IAdd(sp, 4));
// fall through
m.Label("m3");
m.Assign(sp, m.ISub(sp, 4));
m.MStore(sp, m.Word32(42));
m.Call(foo, 4);
m.Assign(sp, m.IAdd(sp, 4));
// fall through
m.Label("m4_default");
m.Assign(sp, m.ISub(sp, 4));
m.MStore(sp, m.Word32(0));
m.Call(foo, 4);
m.Assign(sp, m.IAdd(sp, 4));
m.Return();
RunUnitTest(m, "Analysis/SsaSwitchWithSharedBranches.txt");
}
public void DtbSegmentedAccess()
{
ProcedureBuilder m = new ProcedureBuilder();
Identifier ds = m.Local16("ds");
Identifier bx = m.Local16("bx");
Expression e = m.SegMem(bx.DataType, ds, m.IAdd(bx, 4));
var sc = new ServiceContainer();
var arch = new Reko.Arch.X86.X86ArchitectureReal(sc, "x86-real-16", new Dictionary <string, object>());
Program program = new Program
{
Architecture = arch,
Platform = new DefaultPlatform(null, arch),
};
TraitCollector trco = new TraitCollector(factory, store, dtb, program);
e = e.Accept(aen);
e.Accept(eqb);
e.Accept(trco);
dtb.BuildEquivalenceClassDataTypes();
Verify("Typing/DtbSegmentedAccess.txt");
}
public void Test_Proc_Body_Is_Indented()
{
var name = new SchemaObjectName();
name.Identifiers.Add("dbo".ToIdentifier());
name.Identifiers.Add("procedureName".ToIdentifier());
var builder = new ProcedureBuilder("[procedureName]", "[test blah bloo blah]", name);
builder.AddParameter("@p1", SqlDataType.Date);
builder.AddParameter("@p2222222222222222222]", SqlDataType.VarChar);
builder.AddTable(name);
var script = builder.GetScript();
var lines = script.Replace("\r\n", "~").Split('~');
for (var i = 2; i < lines.Length; i++)
{
if (!(Char.IsWhiteSpace(lines[i][0])))
{
Assert.Fail("Line does not start with whitespace: \"{0}\"", lines[i]);
}
}
}
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.Store(m.Word32(0x123400), m.Cast(PrimitiveType.Byte, r1));
m.Store(m.Word32(0x123404), m.Cast(PrimitiveType.Real32, r2));
m.Return();
var usb = new UserSignatureBuilder(program);
usb.ApplySignatureToProcedure(
Address.Create(PrimitiveType.Pointer32, 0x1000),
new ProcedureSignature(
null,
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());
}
private void RunTest(string sExp, Action <ProcedureBuilder> builder)
{
var pb = new ProcedureBuilder(this.pb.Program.Architecture);
builder(pb);
var proc = pb.Procedure;
var dg = new DominatorGraph <Block>(proc.ControlGraph, proc.EntryBlock);
// Perform the initial transformation
var ssa = new SsaTransform(programFlow, proc, dg);
// Propagate values and simplify the results.
// We hope the the sequence
// esp = fp - 4
// mov [esp-4],eax
// will become
// esp_2 = fp - 4
// mov [fp - 8],eax
var vp = new ValuePropagator(ssa.SsaState.Identifiers, proc);
vp.Transform();
ssa.RenameFrameAccesses = true;
ssa.AddUseInstructions = true;
ssa.Transform();
var writer = new StringWriter();
proc.Write(false, writer);
var sActual = writer.ToString();
if (sActual != sExp)
{
Debug.Print(sActual);
}
Assert.AreEqual(sExp, sActual);
}
public void StrAnls_Issue_529()
{
var m = new ProcedureBuilder();
var fp = m.Frame.FramePointer;
var sp = m.Frame.EnsureRegister(m.Architecture.StackRegister);
var puts = new ExternalProcedure("puts", new FunctionType());
m.Label("m4E2");
m.Goto("m4F7");
m.Label("m4E4");
m.SideEffect(m.Fn(puts, Constant.String("Hello", StringType.NullTerminated(PrimitiveType.Byte))));
m.Return();
m.Label("m4F7");
m.BranchIf(m.Eq0(m.Mem32(m.Word32(0x0808A0A4))), "m502");
m.Label("m500");
m.Goto("m50D");
m.Label("m502");
m.BranchIf(m.Eq0(m.Mem32(m.Word32(0x0808A0A8))), "m4E4");
m.Goto("m50D");
m.Label("m50D");
m.SideEffect(m.Fn(puts, Constant.String("Goodbye", StringType.NullTerminated(PrimitiveType.Byte))));
m.Goto("m4E4");
var sExp =
#region Expected
@" if (Mem0[0x0808A0A4:word32] != 0x00 || Mem0[0x0808A0A8:word32] != 0x00)
puts(""Goodbye"");
puts(""Hello"");
return;
";
#endregion
Given_CompoundConditionCoalescer(m.Procedure);
RunTest(sExp, m.Procedure);
}
public void TrcoIcall()
{
ProcedureBuilder m = new ProcedureBuilder();
Identifier pfn = m.Local32("pfn");
Expression l = m.Mem(PrimitiveType.Word32, pfn);
CallInstruction icall = new CallInstruction(l, new CallSite(0, 0));
coll = CreateCollector();
icall.Accept(eqb);
icall.Accept(coll);
StringWriter sw = new StringWriter();
handler.Traits.Write(sw);
string exp =
"T_1 (in pfn : word32)" + nl +
"\ttrait_primitive(word32)" + nl +
"\ttrait_mem(T_2, 0)" + nl +
"T_2 (in Mem0[pfn:word32] : word32)" + nl +
"\ttrait_primitive((ptr32 code))" + nl +
"\ttrait_primitive(word32)" + nl;
Assert.AreEqual(exp, sw.ToString());
}
public void DtbSegmentedDirectAddress()
{
ProcedureBuilder m = new ProcedureBuilder();
var arch = new Reko.Arch.X86.X86ArchitectureReal();
var prog = new Program
{
Architecture = arch,
Platform = new DefaultPlatform(null, arch)
};
store.EnsureExpressionTypeVariable(factory, prog.Globals);
Identifier ds = m.Local16("ds");
Expression e = m.SegMem(PrimitiveType.Byte, ds, m.Int16(0x0200));
TraitCollector coll = new TraitCollector(factory, store, dtb, prog);
e = e.Accept(aen);
e.Accept(eqb);
e.Accept(coll);
dtb.BuildEquivalenceClassDataTypes();
Verify("Typing/DtbSegmentedDirectAddress.txt");
}
public void CceEqId()
{
Identifier r = Reg32("r");
Identifier z = FlagGroup("z"); // is a condition code.
Identifier y = FlagGroup("y"); // is a condition code.
ProcedureBuilder m = new ProcedureBuilder();
m.Assign(z, new ConditionOf(r));
ssaIds[z].DefStatement = m.Block.Statements.Last;
m.Assign(y, z);
ssaIds[y].DefStatement = m.Block.Statements.Last;
ssaIds[z].Uses.Add(m.Block.Statements.Last);
var stmBr = m.BranchIf(m.Test(ConditionCode.EQ, y), "foo");
ssaIds[y].Uses.Add(stmBr);
var arch = new FakeArchitecture();
var cce = new ConditionCodeEliminator(ssaIds, new DefaultPlatform(null, arch));
cce.Transform();
Assert.AreEqual("branch r == 0x00000000 foo", stmBr.Instruction.ToString());
}
public void BlockCloner_CloneBlock_Temporaries()
{
var m = new ProcedureBuilder(arch, "fn1000");
var tmp = m.Frame.CreateTemporary(PrimitiveType.Word32);
var r2 = m.Register("r2");
var ass = m.Assign(tmp, r2);
var sto = (Store)m.MStore(m.Word32(0x00123400), tmp).Instruction;
m.Return();
var block = m.Procedure.ControlGraph.Blocks[2];
m = new ProcedureBuilder(arch, "procCalling");
var blockCloner = new BlockCloner(block, m.Procedure, callgraph);
var blockNew = blockCloner.Execute();
var assNew = (Assignment)blockNew.Statements[0].Instruction;
var stoNew = (Store)blockNew.Statements[1].Instruction;
Assert.AreNotSame(ass.Dst, assNew.Dst);
Assert.AreNotSame(sto.Src, stoNew.Src);
Assert.AreSame(assNew.Dst, stoNew.Src);
}
private void RunUnitTest(ProcedureBuilder m, string outfile)
{
var flow = new ProgramDataFlow();
var dynamicLinker = new Mock <IDynamicLinker>();
var proc = m.Procedure;
var platform = new FakePlatform(null, m.Architecture)
{
Test_CreateTrashedRegisters = () =>
new HashSet <RegisterStorage>()
{
(RegisterStorage)r1.Storage,
(RegisterStorage)r2.Storage,
}
};
var program = new Program()
{
Architecture = m.Architecture,
Platform = platform,
};
var sst = new SsaTransform(
program,
proc,
new HashSet <Procedure>(),
dynamicLinker.Object,
flow);
sst.Transform();
ssa = sst.SsaState;
using (var fut = new FileUnitTester(outfile))
{
ssa.Write(fut.TextWriter);
proc.Write(false, fut.TextWriter);
fut.AssertFilesEqual();
ssa.Validate(s => Assert.Fail(s));
}
}
public void DtbSegmentedDirectAddress()
{
ProcedureBuilder m = new ProcedureBuilder();
var sc = new ServiceContainer();
var arch = new Reko.Arch.X86.X86ArchitectureReal(sc, "x86-real-16", new Dictionary <string, object>());
var program = new Program
{
Architecture = arch,
Platform = new DefaultPlatform(sc, arch)
};
store.EnsureExpressionTypeVariable(factory, 0, program.Globals);
Identifier ds = m.Local16("ds");
Expression e = m.SegMem(PrimitiveType.Byte, ds, m.Word16(0x0200));
TraitCollector coll = new TraitCollector(factory, store, dtb, program);
e = e.Accept(aen);
e.Accept(eqb);
e.Accept(coll);
dtb.BuildEquivalenceClassDataTypes();
Verify("Typing/DtbSegmentedDirectAddress.txt");
}
public void Pdg_InfiniteLoop()
{
ProcedureBuilder m = new ProcedureBuilder();
m.Label("Infinity");
m.BranchIf(m.Eq(m.LoadW(m.Word16(0x1234)), 0), "hop");
m.SideEffect(m.Fn("foo"));
m.Label("hop");
m.BranchIf(m.Eq(m.LoadW(m.Word16(0x5123)), 1), "Infinity");
m.SideEffect(m.Fn("bar"));
m.Jump("Infinity");
m.Return();
FindPostDominators(m);
string sExp =
"hop (4): idom ProcedureBuilder_exit (6)" + nl +
"Infinity (2): idom hop (4)" + nl +
"l1 (3): idom hop (4)" + nl +
"l2 (5): idom ProcedureBuilder_exit (6)" + nl +
"ProcedureBuilder_entry (1): idom Infinity (2)" + nl +
"ProcedureBuilder_exit (6): idom " + nl;
Assert.AreEqual(sExp, sw.ToString());
}
public void CreateNoincInitialValue()
{
ProcedureBuilder m = new ProcedureBuilder();
ssa = new SsaState(m.Procedure);
SsaId(new Identifier("id0", PrimitiveType.Word32, new TemporaryStorage("id0", 0, PrimitiveType.Word32)), null, null, false);
SsaId(new Identifier("id1", PrimitiveType.Word32, new TemporaryStorage("id1", 1, PrimitiveType.Word32)), null, null, false);
LinearInductionVariableFinder liv = new LinearInductionVariableFinder(ssa, null);
liv.Context.InitialValue = Constant.Word32(0);
Identifier id2 = m.Local32("id_2");
SsaId(id2, new Statement(0, null, null), null, false);
Assert.AreEqual(3, ssa.Identifiers.Count);
Identifier id3 = m.Local32("id_3");
Identifier id4 = m.Local32("id_4");
liv.Context.PhiStatement = m.Phi(id3, (id2, "block2"), (id4, "block4"));
liv.Context.PhiIdentifier = id3;
SsaId(id3, liv.Context.PhiStatement, ((PhiAssignment)liv.Context.PhiStatement.Instruction).Src, false);
Assert.AreEqual(4, ssa.Identifiers.Count);
Statement use = new Statement(0, null, null);
ssa.Identifiers[id3].Uses.Add(use);
liv.Context.DeltaValue = m.Word32(1);
m.Assign(id4, m.IAdd(id3, liv.Context.DeltaValue));
liv.Context.DeltaStatement = m.Block.Statements.Last;
ssa.Identifiers[id3].Uses.Add(liv.Context.DeltaStatement);
LinearInductionVariable iv = liv.CreateInductionVariable();
Assert.AreEqual("(0<32> 1<32> ?)", iv.ToString());
}
public void WriteProcedure_Max()
{
var m = new ProcedureBuilder("proc");
var r1 = m.Register("r1");
var r2 = m.Register("r2");
var r3 = m.Register("r3");
m.BranchIf(m.Gt(r1, r2), "greaterthan");
m.Assign(r3, r2);
m.Assign(r2, r1);
m.Assign(r1, r3);
m.Label("greaterthan");
m.Return(r1);
hcf.Write(m.Procedure);
var sExp = @"void proc()<br />
{<br />
proc_entry:<br />
<span class=""kw"">goto</span> l1<br />
greaterthan:<br />
<span class=""kw"">return</span> r1<br />
l1:<br />
<span class=""kw"">branch</span> r1 > r2 greaterthan<br />
l2:<br />
r3 = r2<br />
r2 = r1<br />
r1 = r3<br />
<span class=""kw"">goto</span> greaterthan<br />
proc_exit:<br />
}<br />
";
Debug.Write(sb.ToString());
Assert.AreEqual(sExp, sb.ToString());
}
public void Setup()
{
m = new ProcedureBuilder();
this.rolc_8 = new PseudoProcedure(PseudoProcedure.RolC, PrimitiveType.Byte, 3);
}
protected void RunFileTest(ProcedureBuilder mock, string outputFile)
{
Program prog = BuildProgramMock(mock);
SaveRunOutput(prog, RunTest, outputFile);
}
public void Setup()
{
repository = new MockRepository();
m = new ProcedureBuilder();
ctx = repository.Stub <EvaluationContext>();
}
public void Setup()
{
m = new ProcedureBuilder();
ssa = new SsaIdentifierCollection();
listener = new FakeDecompilerEventListener();
}
public void Setup()
{
m = new ProcedureBuilder();
stms = new List <AbsynStatement>();
emitter = new AbsynStatementEmitter(stms);
}
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(PrimitiveType.Word32, es.Storage, bx.Storage);
m.Assign(es_bx, m.SegMem(PrimitiveType.Word32, es, bx));
m.Assign(es, m.Slice(PrimitiveType.Word16, es_bx, 16));
m.Assign(bx, m.Slice(PrimitiveType.Word16, es_bx, 0));
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_4 = Mem0[es:bx:word32]
bx:bx
def: def bx
uses: es_bx_4 = Mem0[es:bx:word32]
Mem0:Mem
def: def Mem0
uses: es_bx_4 = Mem0[es:bx:word32]
es_bx_4: orig: es_bx
def: es_bx_4 = Mem0[es:bx:word32]
uses: es_5 = SLICE(es_bx_4, word16, 16) (alias)
bx_6 = SLICE(es_bx_4, word16, 0) (alias)
es_7 = SLICE(es_bx_4, word16, 16)
bx_8 = SLICE(es_bx_4, word16, 0)
Mem9[es_bx_4 + 4<16>:byte] = 3<8>
es_5: orig: es
def: es_5 = SLICE(es_bx_4, word16, 16) (alias)
bx_6: orig: bx
def: bx_6 = SLICE(es_bx_4, word16, 0) (alias)
es_7: orig: es
def: es_7 = SLICE(es_bx_4, word16, 16)
bx_8: orig: bx
def: bx_8 = SLICE(es_bx_4, word16, 0)
Mem9: orig: Mem0
def: Mem9[es_bx_4 + 4<16>:byte] = 3<8>
// ProcedureBuilder
// Return size: 0
define ProcedureBuilder
ProcedureBuilder_entry:
def es
def bx
def Mem0
// succ: l1
l1:
es_bx_4 = Mem0[es:bx:word32]
es_5 = SLICE(es_bx_4, word16, 16) (alias)
bx_6 = SLICE(es_bx_4, word16, 0) (alias)
es_7 = SLICE(es_bx_4, word16, 16)
bx_8 = SLICE(es_bx_4, word16, 0)
Mem9[es_bx_4 + 4<16>:byte] = 3<8>
ProcedureBuilder_exit:
";
#endregion
AssertStringsEqual(sExp, ssa);
}
public void VpIndirectCall()
{
var callee = CreateExternalProcedure(
"foo",
12,
RegArg(1, "r1"),
StackArg(4),
StackArg(8));
var pc = new ProcedureConstant(PrimitiveType.Ptr32, callee);
var m = new ProcedureBuilder();
var r1 = m.Reg32("r1", 1);
var sp = m.Frame.EnsureRegister(m.Architecture.StackRegister);
m.Assign(sp, m.Frame.FramePointer);
m.Assign(r1, pc);
m.Assign(sp, m.ISub(sp, 4));
m.MStore(sp, m.Word32(3));
m.Assign(sp, m.ISub(sp, 4));
m.MStore(sp, m.Mem16(m.Word32(0x1231230)));
m.Call(r1, 4);
m.Return();
arch.Setup(a => a.CreateStackAccess(
It.IsAny <IStorageBinder>(),
It.IsAny <int>(),
It.IsAny <DataType>()))
.Returns((IStorageBinder f, int off, DataType dt) =>
m.Mem(dt, m.IAdd(f.EnsureRegister((RegisterStorage)sp.Storage), off)));
arch.Setup(s => s.CreateFrameApplicationBuilder(
It.IsAny <IStorageBinder>(),
It.IsAny <CallSite>(),
It.IsAny <Expression>()))
.Returns((IStorageBinder binder, CallSite site, Expression c) =>
new FrameApplicationBuilder(arch.Object, binder, site, c, false));
var ssa = RunTest(m);
var sExp =
#region Expected
@"fp:fp
def: def fp
uses: r63_2 = fp
r63_4 = fp - 4<32>
Mem5[fp - 4<32>:word32] = 3<32>
r63_6 = fp - 8<32>
Mem7[fp - 8<32>:word16] = Mem5[0x1231230<32>:word16]
r1_8 = foo(Mem7[fp - 8<32>:word32], Mem7[fp - 4<32>:word32])
r1_8 = foo(Mem7[fp - 8<32>:word32], Mem7[fp - 4<32>:word32])
r63_2: orig: r63
def: r63_2 = fp
r1_3: orig: r1
def: r1_3 = foo
r63_4: orig: r63
def: r63_4 = fp - 4<32>
Mem5: orig: Mem0
def: Mem5[fp - 4<32>:word32] = 3<32>
uses: Mem7[fp - 8<32>:word16] = Mem5[0x1231230<32>:word16]
r63_6: orig: r63
def: r63_6 = fp - 8<32>
Mem7: orig: Mem0
def: Mem7[fp - 8<32>:word16] = Mem5[0x1231230<32>:word16]
uses: r1_8 = foo(Mem7[fp - 8<32>:word32], Mem7[fp - 4<32>:word32])
r1_8 = foo(Mem7[fp - 8<32>:word32], Mem7[fp - 4<32>:word32])
r1_8: orig: r1
def: r1_8 = foo(Mem7[fp - 8<32>:word32], Mem7[fp - 4<32>:word32])
// ProcedureBuilder
// Return size: 0
define ProcedureBuilder
ProcedureBuilder_entry:
def fp
// succ: l1
l1:
r63_2 = fp
r1_3 = foo
r63_4 = fp - 4<32>
Mem5[fp - 4<32>:word32] = 3<32>
r63_6 = fp - 8<32>
Mem7[fp - 8<32>:word16] = Mem5[0x1231230<32>:word16]
r1_8 = foo(Mem7[fp - 8<32>:word32], Mem7[fp - 4<32>:word32])
return
// succ: ProcedureBuilder_exit
ProcedureBuilder_exit:
";
#endregion
AssertStringsEqual(sExp, ssa);
}
protected void RunStringTest(string sExp, ProcedureBuilder pb)
{
var program = BuildProgram(pb);
AssertRunOutput(program, RunTest, sExp);
}
public void Setup()
{
m = new ProcedureBuilder();
ctx = new Mock <EvaluationContext>();
}
public void Setup()
{
m = new ProcedureBuilder();
aen = new ExpressionNormalizer(PrimitiveType.Pointer32);
}
public void VpIndirectCall()
{
var callee = CreateExternalProcedure("foo", RegArg(1, "r1"), StackArg(4), StackArg(8));
var pc = new ProcedureConstant(PrimitiveType.Ptr32, callee);
var m = new ProcedureBuilder();
var r1 = m.Reg32("r1", 1);
var sp = m.Frame.EnsureRegister(m.Architecture.StackRegister);
m.Assign(r1, pc);
m.Assign(sp, m.ISub(sp, 4));
m.MStore(sp, m.Word32(3));
m.Assign(sp, m.ISub(sp, 4));
m.MStore(sp, m.Mem16(m.Word32(0x1231230)));
m.Call(r1, 4);
m.Return();
arch.Stub(a => a.CreateStackAccess(null, 0, null))
.IgnoreArguments()
.Do(new Func <IStorageBinder, int, DataType, Expression>((f, off, dt) => m.Mem(dt, m.IAdd(sp, off))));
mr.ReplayAll();
var ssa = RunTest(m);
var sExp =
#region Expected
@"r1_0: orig: r1
def: r1_0 = foo
r63:r63
def: def r63
uses: r63_2 = r63 - 0x00000004
Mem3[r63 - 0x00000004:word32] = 0x00000003
r63_4 = r63 - 0x00000008
Mem5[r63 - 0x00000008:word16] = Mem3[0x01231230:word16]
r1_6 = foo(Mem8[r63 - 0x00000008:word32], Mem9[r63 - 0x00000004:word32])
r1_6 = foo(Mem8[r63 - 0x00000008:word32], Mem9[r63 - 0x00000004:word32])
r63_2: orig: r63
def: r63_2 = r63 - 0x00000004
Mem3: orig: Mem0
def: Mem3[r63 - 0x00000004:word32] = 0x00000003
uses: Mem5[r63 - 0x00000008:word16] = Mem3[0x01231230:word16]
r63_4: orig: r63
def: r63_4 = r63 - 0x00000008
Mem5: orig: Mem0
def: Mem5[r63 - 0x00000008:word16] = Mem3[0x01231230:word16]
r1_6: orig: r1
def: r1_6 = foo(Mem8[r63 - 0x00000008:word32], Mem9[r63 - 0x00000004:word32])
r63_7: orig: r63
Mem8: orig: Mem0
uses: r1_6 = foo(Mem8[r63 - 0x00000008:word32], Mem9[r63 - 0x00000004:word32])
Mem9: orig: Mem0
uses: r1_6 = foo(Mem8[r63 - 0x00000008:word32], Mem9[r63 - 0x00000004:word32])
// ProcedureBuilder
// Return size: 0
void ProcedureBuilder()
ProcedureBuilder_entry:
def r63
// succ: l1
l1:
r1_0 = foo
r63_2 = r63 - 0x00000004
Mem3[r63 - 0x00000004:word32] = 0x00000003
r63_4 = r63 - 0x00000008
Mem5[r63 - 0x00000008:word16] = Mem3[0x01231230:word16]
r1_6 = foo(Mem8[r63 - 0x00000008:word32], Mem9[r63 - 0x00000004:word32])
return
// succ: ProcedureBuilder_exit
ProcedureBuilder_exit:
";
#endregion
AssertStringsEqual(sExp, ssa);
}
/// <summary>
/// Creates an instance of a procedure plan using the specified procedure as a prototype.
/// </summary>
/// <param name="procedure"></param>
/// <returns></returns>
public static ProcedurePlan CreateFromProcedure(Procedure procedure)
{
var builder = new ProcedureBuilder();
var xmldoc = builder.CreatePlanFromProcedure(procedure);
return new ProcedurePlan(xmldoc);
}
/// <summary>
/// Creates the procedure steps specified in the procedure plan of the associated
/// <see cref="ProcedureType"/>.
/// </summary>
public virtual void CreateProcedureSteps()
{
// TODO: is this the right way to check this condition? do we need a dedicated flag?
if (_procedureSteps.Count > 0)
throw new WorkflowException("Procedure steps have already been created for this Procedure.");
var builder = new ProcedureBuilder();
builder.BuildProcedureFromPlan(this);
}
private void RunTest(string sExp, Action <ProcedureBuilder> builder)
{
var pb = new ProcedureBuilder(this.pb.Program.Architecture);
builder(pb);
var proc = pb.Procedure;
var dg = new DominatorGraph <Block>(proc.ControlGraph, proc.EntryBlock);
var project = new Project
{
Programs = { this.pb.Program }
};
var listener = new FakeDecompilerEventListener();
var importResolver = new ImportResolver(
project,
this.pb.Program,
listener);
var arch = new FakeArchitecture();
var platform = new FakePlatform(null, arch);
// Register r1 is assumed to always be implicit when calling
// another procedure.
var implicitRegs = new HashSet <RegisterStorage>
{
arch.GetRegister(1)
};
Debug.Print("GetRegister(1) {0}", arch.GetRegister(1));
this.pb.Program.Platform = platform;
this.pb.Program.Platform = new FakePlatform(null, new FakeArchitecture());
this.pb.Program.SegmentMap = new SegmentMap(
Address.Ptr32(0x0000),
new ImageSegment(
".text",
Address.Ptr32(0),
0x40000,
AccessMode.ReadWriteExecute));
// Perform the initial transformation
var ssa = new SsaTransform(programFlow, proc, importResolver, dg, implicitRegs);
// Propagate values and simplify the results.
// We hope the the sequence
// esp = fp - 4
// mov [esp-4],eax
// will become
// esp_2 = fp - 4
// mov [fp - 8],eax
var vp = new ValuePropagator(this.pb.Program.Architecture, ssa.SsaState, listener);
vp.Transform();
ssa.RenameFrameAccesses = true;
ssa.AddUseInstructions = true;
ssa.Transform();
var writer = new StringWriter();
proc.Write(false, writer);
var sActual = writer.ToString();
if (sActual != sExp)
{
Debug.Print(sActual);
}
Assert.AreEqual(sExp, sActual);
ssa.SsaState.CheckUses(s => Assert.Fail(s));
}
private Identifier MockReg(ProcedureBuilder m, int i)
{
return(m.Frame.EnsureRegister(FakeArchitecture.GetMachineRegister(i)));
}
/// <summary>
/// Builds a strongly connected component corresponding to:
/// a1 = 0
/// a2 = phi(a1, a3)
/// while (a2 != 10)
/// {
/// a3 = a2 + 4
/// }
/// </summary>
private List <SsaIdentifier> BuildScc()
{
var m = new ProcedureBuilder("test");
Identifier a = new Identifier("a", PrimitiveType.Word32, new RegisterStorage("a", 1, 0, PrimitiveType.Word32));
m.Label("b1");
m.Assign(a, Constant.Word32(0));
m.Label("b2");
m.Assign(a, m.IAdd(a, 4));
m.BranchIf(m.Ne(a, 10), "b2");
m.Label("b3");
m.Return();
this.dom = m.Procedure.CreateBlockDominatorGraph();
var program = new Program()
{
Architecture = m.Architecture,
};
var sst = new SsaTransform(
program,
m.Procedure,
new HashSet <Procedure>(),
null,
new ProgramDataFlow());
sst.Transform();
/*
*
* proc = new Procedure("test", new Frame(PrimitiveType.Word32));
* Block b1 = proc.AddBlock("b1");
* Block b2 = proc.AddBlock("b2");
*
* Identifier a2 = new Identifier("a2", PrimitiveType.Word32, null);
* Identifier a3 = new Identifier("a3", PrimitiveType.Word32, null);
* PhiFunction phi = new PhiFunction(a1.DataType, new Expression [] { a1, a3 });
*
* Statement stm_a1 = new Statement(0, new Assignment(a1, Constant.Word32(0)), null);
* Statement stm_a2 = new Statement(0, new PhiAssignment(a2, new PhiFunction(a1.DataType, a1, a3 )), null);
* Statement stm_ex = new Statement(0, new Branch(new BinaryExpression(Operator.Ne, PrimitiveType.Bool, a2, Constant.Word32(10)), b2), null);
* Statement stm_a3 = new Statement(0, new Assignment(a3, new BinaryExpression(Operator.IAdd, a3.DataType, a2, Constant.Word32(4))), null);
* b1.Statements.Add(stm_a1);
*
* b2.Statements.Add(stm_a2);
* b2.Statements.Add(stm_a3);
*
* SsaIdentifier sid_a1 = new SsaIdentifier(a1, a1, stm_a1, ((Assignment)stm_a1.Instruction).Src, false);
* SsaIdentifier sid_a2 = new SsaIdentifier(a2, a2, stm_a2, ((PhiAssignment) stm_a2.Instruction).Src, false);
* SsaIdentifier sid_a3 = new SsaIdentifier(a3, a3, stm_a3, ((Assignment) stm_a3.Instruction).Src, false);
* sid_a1.Uses.Add(stm_a2);
* ssaIds = new SsaIdentifierCollection();
* ssaIds.Add(a1, sid_a1);
* ssaIds.Add(a2, sid_a2);
* ssaIds.Add(a3, sid_a3);
*/
ssa = sst.SsaState;
List <SsaIdentifier> list = new List <SsaIdentifier> {
ssa.Identifiers.Where(i => i.Identifier.Name == "a_1").Single(),
ssa.Identifiers.Where(i => i.Identifier.Name == "a_2").Single(),
ssa.Identifiers.Where(i => i.Identifier.Name == "a_3").Single(),
};
return(list);
}
public void Setup()
{
m = new ProcedureBuilder();
}
protected virtual void RunTest(ProcedureBuilder m)
{
RunTest(m.Procedure);
}
