/// <summary>
/// Constructs an SsaTransform, and in the process generates the SsaState for the procedure <paramref>proc</paramref>.
/// </summary>
/// <param name="proc"></param>
/// <param name="gr"></param>
public SsaTransform(ProgramDataFlow programFlow, Procedure proc, DominatorGraph<Block> gr)
{
this.programFlow = programFlow;
this.proc = proc;
this.SsaState = new SsaState(proc, gr);
this.AOrig = CreateA();
Transform();
}
public void Setup()
{
exit = new ExternalProcedure("exit",
new ProcedureSignature(null, new Identifier("retCode", PrimitiveType.Int32, new StackArgumentStorage(0, PrimitiveType.Int32))));
exit.Characteristics = new ProcedureCharacteristics();
exit.Characteristics.Terminates = true;
progMock = new ProgramBuilder();
flow = new ProgramDataFlow();
}
public void Setup()
{
arch = new IntelArchitecture(ProcessorMode.Protected32);
m = new ProcedureBuilder(arch);
prog = new Program();
prog.Architecture = arch;
exit = new Procedure("exit", new Frame(PrimitiveType.Word32));
flow = new ProgramDataFlow();
p = new ProgramBuilder();
}
public TrashedRegisterFinder2(
IProcessorArchitecture arch,
ProgramDataFlow flow,
Procedure proc,
SsaIdentifierCollection ssa,
DecompilerEventListener listener)
{
this.arch = arch;
this.progFlow = flow;
this.proc = proc;
this.ssa = ssa;
this.decompilerEventListener = listener;
this.flow = new ProcedureFlow2();
}
public void Setup()
{
prog = new Program();
prog.Architecture = new IntelArchitecture(ProcessorMode.Protected32);
prog.Platform = new DefaultPlatform(null, prog.Architecture);
m = new ProcedureBuilder();
proc = m.Procedure;
f = proc.Frame;
mpprocflow = new ProgramDataFlow();
terminates = new HashSet<Procedure>();
rl = new RegisterLiveness(prog, mpprocflow, null);
rl.Procedure = proc;
rl.IdentifierLiveness.BitSet = prog.Architecture.CreateRegisterBitset();
}
private void RunTest(Program prog, TextWriter writer)
{
flow = new ProgramDataFlow(prog);
trf = new TrashedRegisterFinder(prog, prog.Procedures.Values, this.flow, new FakeDecompilerEventListener());
trf.Compute();
trf.RewriteBasicBlocks();
foreach (var proc in prog.Procedures.Values)
{
flow[proc].EmitRegisters(arch, "// Trashed", flow[proc].TrashedRegisters);
proc.Write(false, writer);
writer.WriteLine();
}
}
protected override void RunTest(Program prog, TextWriter writer)
{
var progFlow = new ProgramDataFlow();
foreach (Procedure proc in prog.Procedures.Values)
{
var gr = proc.CreateBlockDominatorGraph();
Aliases alias = new Aliases(proc, prog.Architecture);
alias.Transform();
SsaTransform sst = new SsaTransform(progFlow, proc, gr);
SsaState ssa = sst.SsaState;
DumpProc(proc, ssa, writer);
ValueNumbering vn = new ValueNumbering(ssa.Identifiers);
vn.Write(writer);
writer.WriteLine();
}
}
protected override void RunTest(Program prog, TextWriter writer)
{
var flow = new ProgramDataFlow(prog);
var eventListener = new FakeDecompilerEventListener();
var trf = new TrashedRegisterFinder(prog, prog.Procedures.Values, flow, eventListener);
trf.Compute();
trf.RewriteBasicBlocks();
Dump(prog.CallGraph);
var rl = RegisterLiveness.Compute(prog, flow, eventListener);
GlobalCallRewriter.Rewrite(prog, flow);
foreach (Procedure proc in prog.Procedures.Values)
{
Aliases alias = new Aliases(proc, prog.Architecture);
alias.Transform();
var gr = proc.CreateBlockDominatorGraph();
SsaTransform sst = new SsaTransform(flow, proc, gr);
ssa = sst.SsaState;
ssa.Write(writer);
proc.Write(false, true, writer);
writer.WriteLine();
}
}
public GlobalCallRewriter(Program prog, ProgramDataFlow mpprocflow) : base(prog)
{
this.mpprocflow = mpprocflow;
}
public void TerminatingSubProcedure()
{
var sub = CompileProcedure("sub", m =>
{
m.Call(exit, 4);
m.FinishProcedure();
});
Procedure caller = CompileProcedure("caller", m =>
{
m.Call(sub, 4);
m.Return();
});
var prog = progMock.BuildProgram();
flow = new ProgramDataFlow(prog);
var a = new TerminationAnalysis(flow);
a.Analyze(prog);
Assert.IsTrue(flow[sub].TerminatesProcess);
Assert.IsTrue(flow[caller].TerminatesProcess);
}
public void TrfPreserveEbp()
{
Identifier esp = m.Frame.EnsureRegister(Registers.esp);
Identifier ebp = m.Frame.EnsureRegister(Registers.ebp);
m.Store(esp, ebp);
m.Assign(ebp, m.LoadDw(m.Int32(0x12345678)));
m.Assign(ebp, m.LoadDw(esp));
m.Return();
Procedure proc = m.Procedure;
prog.Procedures.Add(Address.Ptr32(0x10000), proc);
prog.CallGraph.AddProcedure(proc);
flow = new ProgramDataFlow(prog);
trf = CreateTrashedRegisterFinder(prog);
trf.Compute();
ProcedureFlow pf = flow[proc];
Assert.AreEqual(" esp ebp", pf.EmitRegisters(prog.Architecture, "", pf.PreservedRegisters), "ebp should have been preserved");
}
protected override void RunTest(Program prog, TextWriter writer)
{
this.prog = prog;
flow = new ProgramDataFlow(prog);
trf = CreateTrashedRegisterFinder();
trf.Compute();
DumpProcedureSummaries(writer);
}
private void RunTest(ProgramBuilder p, string sExp)
{
prog = p.BuildProgram(arch);
flow = new ProgramDataFlow(prog);
trf = CreateTrashedRegisterFinder();
trf.Compute();
var summary = DumpProcedureSummaries().Trim();
if (sExp == summary)
return;
Console.WriteLine(summary);
Assert.AreEqual(sExp, summary);
}
public TerminationAnalysis(ProgramDataFlow flow)
{
this.flow = flow;
}
public void ProcedureDoesntTerminatesIfOneBranchDoesnt()
{
var proc = CompileProcedure("proc", delegate(ProcedureBuilder m)
{
m.BranchIf(m.Eq(m.Local32("foo"), m.Word32(0)), "bye");
m.Call(exit, 4);
m.Label("bye");
m.Return();
});
var prog = progMock.BuildProgram();
flow = new ProgramDataFlow(prog);
var a = new TerminationAnalysis(flow);
a.Analyze(proc);
Assert.IsFalse(flow[proc].TerminatesProcess);
}
public void ProcedureTerminatesIfAllBranchesDo()
{
var proc = CompileProcedure("proc", m =>
{
m.BranchIf(m.Eq(m.Local32("foo"), m.Word32(0)), "whee");
m.Call(exit, 4);
m.FinishProcedure();
m.Label("whee");
m.Call(exit, 4);
m.FinishProcedure();
});
var prog = progMock.BuildProgram();
flow = new ProgramDataFlow(prog);
var a = new TerminationAnalysis(flow);
a.Analyze(proc);
Assert.IsTrue(flow[proc].TerminatesProcess);
}
public void Setup()
{
this.pf = new ProgramDataFlow();
this.progBuilder = new ProgramBuilder();
}
public void TerminatingApplication()
{
var test= CompileProcedure("test", m =>
{
m.SideEffect(m.Fn(new ProcedureConstant(PrimitiveType.Pointer32, exit)));
m.FinishProcedure();
});
var prog = progMock.BuildProgram();
flow = new ProgramDataFlow(prog);
var a = new TerminationAnalysis(flow);
a.Analyze(test);
Assert.IsTrue(flow[test].TerminatesProcess);
}
public LocateDefinedVariables(SsaTransform ssaXform, Dictionary<Expression, byte>[] defOrig)
{
this.programFlow = ssaXform.programFlow;
this.proc = ssaXform.proc;
this.ssa = ssaXform.SsaState;
this.frameVariables = ssaXform.RenameFrameAccesses;
this.defVars = defOrig;
this.definitions = new List<Identifier>();
this.inDefinitions = new HashSet<Identifier>();
}
public void ProcedureTerminatesIfBlockTerminates()
{
var proc = CompileProcedure("proc", delegate(ProcedureBuilder m)
{
m.Call(exit, 4);
m.Return();
});
var prog = progMock.BuildProgram();
flow = new ProgramDataFlow(prog);
var a = new TerminationAnalysis(flow);
a.Analyze(proc);
Assert.IsTrue(flow[proc].TerminatesProcess);
}
/// <summary>
/// Walks the dominator tree, renaming the different definitions of variables
/// (including phi-functions).
/// </summary>
/// <param name="ssa">SSA identifiers</param>
/// <param name="p">procedure to rename</param>
public VariableRenamer(SsaTransform ssaXform)
{
this.programFlow = ssaXform.programFlow;
this.ssa = ssaXform.SsaState;
this.renameFrameAccess = ssaXform.RenameFrameAccesses;
this.addUseInstructions = ssaXform.AddUseInstructions;
this.proc = ssaXform.proc;
this.rename = new Dictionary<Identifier, Identifier>();
this.stmCur = null;
this.existingDefs = proc.EntryBlock.Statements
.Select(s => s.Instruction as DefInstruction)
.Where(d => d != null)
.Select(d => d.Expression)
.ToHashSet();
}
public DataFlowAnalysis(Program prog, DecompilerEventListener eventListener)
{
this.program = prog;
this.eventListener = eventListener;
this.flow = new ProgramDataFlow(prog);
}
public static void Rewrite(Program prog, ProgramDataFlow summaries)
{
GlobalCallRewriter crw = new GlobalCallRewriter(prog, summaries);
foreach (Procedure proc in prog.Procedures.Values)
{
ProcedureFlow flow = (ProcedureFlow) crw.mpprocflow[proc];
flow.Dump(prog.Architecture);
crw.AdjustLiveOut(flow);
crw.EnsureSignature(proc, flow);
crw.AddUseInstructionsForOutArguments(proc);
}
foreach (Procedure proc in prog.Procedures.Values)
{
crw.RewriteCalls(proc, prog.Architecture);
crw.RewriteReturns(proc);
}
}
