/// <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); } }