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 DeadFnReturn()
{
ProcedureBuilder m = new ProcedureBuilder("foo");
Identifier unused = m.Local32("unused");
m.Assign(unused, m.Fn("foo", Constant.Word32(1)));
m.Return();
RunTest(m, "Analysis/DeadFnReturn.txt");
}
public void BlockTerminates()
{
var m = new ProcedureBuilder();
m.Call(exit, 4);
var b = m.CurrentBlock;
m.Return();
var a = new TerminationAnalysis(flow);
flow[b] = CreateBlockFlow(b, m.Frame);
a.Analyze(b);
Assert.IsTrue(flow[b].TerminatesProcess);
}
public void FindNoLoopInInterval()
{
ProcedureBuilder m = new ProcedureBuilder();
m.Return();
StructureNode node = new StructureNode(m.Procedure.ControlGraph.Blocks[1], 3);
node.Order = 0;
Interval interval = new Interval(1, node);
var nodesInInterval = interval.FindIntervalNodes(0);
SccLoopFinder finder = new SccLoopFinder(interval, nodesInInterval);
var loopNodes = finder.FindLoop();
Assert.AreEqual(0, loopNodes.Count);
}
/// <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, null);
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 ssa = new SsaTransform(new ProgramDataFlow(), m.Procedure, dom);
/*
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);
*/
ssaIds = ssa.SsaState.Identifiers;
List<SsaIdentifier> list = new List<SsaIdentifier> {
ssaIds.Where(i => i.Identifier.Name == "a_0").Single(),
ssaIds.Where(i => i.Identifier.Name == "a_1").Single(),
ssaIds.Where(i => i.Identifier.Name == "a_2").Single(),
};
return list;
}
public void BlockDoesntTerminate()
{
var m = new ProcedureBuilder();
m.Store(m.Word32(0x1231), m.Byte(0));
var b = m.Block;
m.Return();
var a = new TerminationAnalysis(flow);
prog = new Program
{
Architecture = new FakeArchitecture()
};
flow[b] = CreateBlockFlow(b, m.Frame);
a.Analyze(b);
Assert.IsFalse(flow[b].TerminatesProcess);
}
private Procedure BuildSimpleLoop()
{
ProcedureBuilder m = new ProcedureBuilder();
Identifier p = m.Local32("p");
m.Assign(p, 0);
m.Label("loop");
m.BranchIf(m.Eq(p, 0x4000), "done");
m.Store(m.IAdd(p, 0x3000), m.Int32(0));
m.Assign(p, m.IAdd(p, 4));
m.Jump("loop");
m.Label("done");
m.Return();
return m.Procedure;
}
public void BlockCloner_CloneBlock()
{
var m = new ProcedureBuilder(arch, "fn1000");
var r1 = m.Register("r1");
var r2 = m.Register("r2");
var ass = m.Assign(r1, r2);
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;
Assert.AreNotSame(ass.Dst, assNew.Dst);
Assert.AreNotSame(ass.Src, assNew.Src);
}
public void SsaCallIndirect()
{
var m = new ProcedureBuilder("SsaCallIndirect");
var r1 = m.Reg32("r1");
var r2 = m.Reg32("r2");
m.Assign(r1, m.LoadDw(r2));
m.Call(r1, 4);
m.Return();
RunUnitTest(m, "Analysis/SsaCallIndirect.txt");
}
public void SsaStackReference_Load()
{
var m = new ProcedureBuilder("SsaStackReference");
var wRef = m.Frame.EnsureStackArgument(4, PrimitiveType.Word16);
var ax = EnsureRegister16(m, "ax");
m.Assign(ax, wRef);
m.Return();
RunUnitTest(m, "Analysis/SsaStackReference.txt");
}
public void SsaPushAndPop()
{
// Mirrors the pattern of stack accesses used by x86 compilers.
var m = new ProcedureBuilder("SsaPushAndPop");
var esp = EnsureRegister32(m, "esp");
var ebp = EnsureRegister32(m, "ebp");
var eax = EnsureRegister32(m, "eax");
m.Assign(esp, m.ISub(esp, 4));
m.Store(esp, ebp);
m.Assign(ebp, esp);
m.Assign(eax, m.LoadDw(m.IAdd(ebp, 8))); // dwArg04
m.Assign(ebp, m.LoadDw(esp));
m.Assign(esp, m.IAdd(esp,4));
m.Return();
RunUnitTest(m, "Analysis/SsaPushAndPop.txt");
}
public void SsaOutParamters()
{
ProcedureBuilder m = new ProcedureBuilder("foo");
Identifier r4 = m.Register(4);
m.Store(m.Int32(0x400), m.Fn("foo", m.Out(PrimitiveType.Pointer32, r4)));
m.Return();
RunTest(m, "Analysis/SsaOutParameters.txt");
}
public void Cvp_SetProcedure()
{
codeViewer.CreateControl();
var m = new ProcedureBuilder();
m.Return();
using (mr.Record())
{
var project = new Project { Programs = { new Program() } };
decompiler.Stub(d => d.Project).Return(project);
uiPreferencesSvc.SourceCodeFont = font;
}
codeViewer.DisplayProcedure(m.Procedure);
string sExp =
"void ProcedureBuilder()" + nl +
"{" + nl +
"ProcedureBuilder_entry:" + nl +
"l1:" + nl +
" 'return'" + nl +
"ProcedureBuilder_exit:" + nl +
"}" + nl;
Assert.AreEqual(sExp, Flatten(codeViewer.TextView.Model));
}
public void Scanner_IsLinearReturn_EndsWithReturn()
{
var scanner = CreateScanner(0x1000, 0x1000);
var m = new ProcedureBuilder(arch, "fn1000");
m.Return();
var block = m.Procedure.ControlGraph.Blocks[2];
Assert.IsTrue(scanner.IsLinearReturning(block));
}