private void RunValuePropagator() { var vp = new ValuePropagator(segmentMap, m.Ssa, new CallGraph(), importResolver.Object, listener); vp.Transform(); m.Ssa.Validate(s => Assert.Fail(s)); }
public void VpDbpDbp() { var m = new ProcedureBuilder(); var d1 = m.Reg32("d32", 0); var a1 = m.Reg32("a32", 1); m.Assign(d1, m.Dpb(d1, m.Mem16(a1), 0)); m.Assign(d1, m.Dpb(d1, m.Mem16(m.IAdd(a1, 4)), 0)); Procedure proc = m.Procedure; var gr = proc.CreateBlockDominatorGraph(); var importResolver = new Mock <IImportResolver>().Object; var sst = new SsaTransform(new ProgramDataFlow(), proc, importResolver, gr, new HashSet <RegisterStorage>()); var ssa = sst.SsaState; var vp = new ValuePropagator(segmentMap, ssa, new CallGraph(), importResolver, listener); vp.Transform(); using (FileUnitTester fut = new FileUnitTester("Analysis/VpDpbDpb.txt")) { proc.Write(false, fut.TextWriter); fut.TextWriter.WriteLine(); fut.AssertFilesEqual(); } }
private void ProcessScc(IList <Procedure> scc) { var procSet = scc.ToSet(); var sstSet = new HashSet <SsaTransform>(); foreach (var proc in scc) { var sst = new SsaTransform( program, proc, procSet, dynamicLinker.Object, dataFlow); sst.Transform(); sst.AddUsesToExitBlock(); var vp = new ValuePropagator( program.SegmentMap, sst.SsaState, program.CallGraph, dynamicLinker.Object, NullDecompilerEventListener.Instance); vp.Transform(); sstSet.Add(sst); } var trf = new TrashedRegisterFinder( program, dataFlow, sstSet, NullDecompilerEventListener.Instance); trf.Compute(); }
private void Prepare(Procedure proc) { var listener = new FakeDecompilerEventListener(); var dynamicLinker = new Mock <IDynamicLinker>().Object; doms = proc.CreateBlockDominatorGraph(); SsaTransform sst = new SsaTransform( new Program(), proc, new HashSet <Procedure>(), dynamicLinker, new ProgramDataFlow()); sst.Transform(); this.ssa = sst.SsaState; var arch = new FakeArchitecture(); var cce = new ConditionCodeEliminator(ssa, new DefaultPlatform(null, arch)); cce.Transform(); DeadCode.Eliminate(ssa); var segmentMap = new SegmentMap(Address.Ptr32(0x00123400)); var vp = new ValuePropagator(segmentMap, ssa, new CallGraph(), dynamicLinker, listener); vp.Transform(); DeadCode.Eliminate(ssa); }
protected override void RunTest(Program program, TextWriter fut) { IImportResolver importResolver = null; var listener = new FakeDecompilerEventListener(); DataFlowAnalysis dfa = new DataFlowAnalysis(program, importResolver, listener); dfa.UntangleProcedures(); foreach (Procedure proc in program.Procedures.Values) { Aliases alias = new Aliases(proc); alias.Transform(); SsaTransform sst = new SsaTransform(dfa.ProgramDataFlow, proc, importResolver, proc.CreateBlockDominatorGraph(), new HashSet <RegisterStorage>()); SsaState ssa = sst.SsaState; ConditionCodeEliminator cce = new ConditionCodeEliminator(ssa, program.Platform); cce.Transform(); DeadCode.Eliminate(proc, ssa); ValuePropagator vp = new ValuePropagator(program.SegmentMap, ssa, listener); vp.Transform(); DeadCode.Eliminate(proc, ssa); Coalescer co = new Coalescer(proc, ssa); co.Transform(); ssa.Write(fut); proc.Write(false, fut); fut.WriteLine(); ssa.Validate(s => Assert.Fail(s)); } }
protected override void RunTest(Program program, TextWriter writer) { var dfa = new DataFlowAnalysis(program, importResolver.Object, new FakeDecompilerEventListener()); dfa.UntangleProcedures(); foreach (Procedure proc in program.Procedures.Values) { writer.WriteLine("= {0} ========================", proc.Name); var gr = proc.CreateBlockDominatorGraph(); Aliases alias = new Aliases(proc); alias.Transform(); SsaTransform sst = new SsaTransform(dfa.ProgramDataFlow, proc, importResolver.Object, gr, new HashSet <RegisterStorage>()); SsaState ssa = sst.SsaState; var cce = new ConditionCodeEliminator(ssa, program.Platform); cce.Transform(); ssa.Write(writer); proc.Write(false, writer); writer.WriteLine(); ValuePropagator vp = new ValuePropagator(program.SegmentMap, ssa, program.CallGraph, importResolver.Object, listener); vp.Transform(); ssa.Write(writer); proc.Write(false, writer); } }
protected override void RunTest(Program program, TextWriter writer) { var eventListener = new FakeDecompilerEventListener(); foreach (var proc in program.Procedures.Values) { var sst = new SsaTransform( program, proc, new HashSet <Procedure>(), null, new ProgramDataFlow()); sst.Transform(); var vp = new ValuePropagator( program.SegmentMap, sst.SsaState, program.CallGraph, null, eventListener); vp.Transform(); sst.RenameFrameAccesses = true; sst.Transform(); sst.AddUsesToExitBlock(); sst.RemoveDeadSsaIdentifiers(); var larw = new LongAddRewriter(sst.SsaState, eventListener); larw.Transform(); proc.Write(false, writer); writer.WriteLine(); } }
private void Build(Procedure proc, IProcessorArchitecture arch) { var platform = new DefaultPlatform(null, arch); this.proc = proc; Aliases alias = new Aliases(proc); alias.Transform(); var importResolver = new Mock <IImportResolver>().Object; SsaTransform sst = new SsaTransform( new ProgramDataFlow(), proc, importResolver, proc.CreateBlockDominatorGraph(), new HashSet <RegisterStorage>()); ssa = sst.SsaState; ConditionCodeEliminator cce = new ConditionCodeEliminator(ssa, platform); cce.Transform(); var segmentMap = new SegmentMap(Address.Ptr32(0x00123400)); ValuePropagator vp = new ValuePropagator(segmentMap, ssa, new CallGraph(), importResolver, new FakeDecompilerEventListener()); vp.Transform(); DeadCode.Eliminate(proc, ssa); Coalescer coa = new Coalescer(proc, ssa); coa.Transform(); DeadCode.Eliminate(proc, ssa); sla = new SsaLivenessAnalysis(proc, ssa.Identifiers); sla2 = new SsaLivenessAnalysis2(proc, ssa.Identifiers); sla2.Analyze(); }
protected override void RunTest(Program prog, TextWriter fut) { DataFlowAnalysis dfa = new DataFlowAnalysis(prog, new FakeDecompilerEventListener()); dfa.UntangleProcedures(); foreach (Procedure proc in prog.Procedures.Values) { Aliases alias = new Aliases(proc, prog.Architecture); alias.Transform(); SsaTransform sst = new SsaTransform(dfa.ProgramDataFlow, proc, proc.CreateBlockDominatorGraph()); SsaState ssa = sst.SsaState; ConditionCodeEliminator cce = new ConditionCodeEliminator(ssa.Identifiers, prog.Platform); cce.Transform(); DeadCode.Eliminate(proc, ssa); ValuePropagator vp = new ValuePropagator(prog.Architecture, ssa.Identifiers, proc); vp.Transform(); DeadCode.Eliminate(proc, ssa); Coalescer co = new Coalescer(proc, ssa); co.Transform(); ssa.Write(fut); proc.Write(false, fut); fut.WriteLine(); } }
private void Build(Procedure proc, IProcessorArchitecture arch) { var platform = new DefaultPlatform(null, arch); this.proc = proc; Aliases alias = new Aliases(proc, arch); alias.Transform(); SsaTransform sst = new SsaTransform( new ProgramDataFlow(), proc, null, proc.CreateBlockDominatorGraph(), new HashSet <RegisterStorage>()); ssa = sst.SsaState; ConditionCodeEliminator cce = new ConditionCodeEliminator(ssa, platform); cce.Transform(); ValuePropagator vp = new ValuePropagator(arch, ssa, new FakeDecompilerEventListener()); vp.Transform(); DeadCode.Eliminate(proc, ssa); Coalescer coa = new Coalescer(proc, ssa); coa.Transform(); DeadCode.Eliminate(proc, ssa); sla = new SsaLivenessAnalysis(proc, ssa.Identifiers); sla2 = new SsaLivenessAnalysis2(proc, ssa.Identifiers); sla2.Analyze(); }
protected override void RunTest(Program program, TextWriter writer) { var importResolver = new Mock <IImportResolver>().Object; var listener = new FakeDecompilerEventListener(); var dfa = new DataFlowAnalysis(program, importResolver, listener); dfa.UntangleProcedures(); foreach (Procedure proc in program.Procedures.Values) { var larw = new LongAddRewriter(proc); larw.Transform(); Aliases alias = new Aliases(proc, dfa.ProgramDataFlow); alias.Transform(); var sst = new SsaTransform(dfa.ProgramDataFlow, proc, importResolver, proc.CreateBlockDominatorGraph(), new HashSet <RegisterStorage>()); SsaState ssa = sst.SsaState; var cce = new ConditionCodeEliminator(ssa, program.Platform); cce.Transform(); var vp = new ValuePropagator(program.SegmentMap, ssa, program.CallGraph, importResolver, listener); vp.Transform(); DeadCode.Eliminate(proc, ssa); ssa.Write(writer); proc.Write(false, writer); writer.WriteLine(); ssa.Validate(s => Assert.Fail(s)); } }
private void Prepare(Procedure proc) { var listener = new FakeDecompilerEventListener(); var importResolver = new Mock <IImportResolver>().Object; this.proc = proc; doms = proc.CreateBlockDominatorGraph(); SsaTransform sst = new SsaTransform( new ProgramDataFlow(), proc, importResolver, doms, new HashSet <RegisterStorage>()); SsaState ssa = sst.SsaState; ssaIds = ssa.Identifiers; var arch = new FakeArchitecture(); var cce = new ConditionCodeEliminator(ssa, new DefaultPlatform(null, arch)); cce.Transform(); DeadCode.Eliminate(proc, ssa); var segmentMap = new SegmentMap(Address.Ptr32(0x00123400)); var vp = new ValuePropagator(segmentMap, ssa, importResolver, listener); vp.Transform(); DeadCode.Eliminate(proc, ssa); }
protected override void RunTest(Program program, TextWriter fut) { IDynamicLinker dynamicLinker = null; var listener = new FakeDecompilerEventListener(); DataFlowAnalysis dfa = new DataFlowAnalysis(program, dynamicLinker, listener); var ssts = dfa.UntangleProcedures(); foreach (Procedure proc in program.Procedures.Values) { var sst = ssts.Single(s => s.SsaState.Procedure == proc); SsaState ssa = sst.SsaState; ConditionCodeEliminator cce = new ConditionCodeEliminator(ssa, program.Platform, listener); cce.Transform(); DeadCode.Eliminate(ssa); ValuePropagator vp = new ValuePropagator(program.SegmentMap, ssa, program.CallGraph, dynamicLinker, listener); vp.Transform(); DeadCode.Eliminate(ssa); Coalescer co = new Coalescer(ssa); co.Transform(); ssa.Write(fut); proc.Write(false, fut); fut.WriteLine(); ssa.Validate(s => { ssa.Dump(true); Assert.Fail(s); }); } }
protected override void RunTest(Program program, TextWriter writer) { var importResolver = MockRepository.GenerateStub <IImportResolver>(); DataFlowAnalysis dfa = new DataFlowAnalysis(program, importResolver, new FakeDecompilerEventListener()); dfa.UntangleProcedures(); foreach (Procedure proc in program.Procedures.Values) { var larw = new LongAddRewriter(proc, program.Architecture); larw.Transform(); Aliases alias = new Aliases(proc, program.Architecture, dfa.ProgramDataFlow); alias.Transform(); var sst = new SsaTransform(dfa.ProgramDataFlow, proc, importResolver, proc.CreateBlockDominatorGraph(), new HashSet <RegisterStorage>()); SsaState ssa = sst.SsaState; var cce = new ConditionCodeEliminator(ssa, program.Platform); cce.Transform(); var vp = new ValuePropagator(program.Architecture, ssa.Identifiers, proc); vp.Transform(); DeadCode.Eliminate(proc, ssa); ssa.Write(writer); proc.Write(false, writer); writer.WriteLine(); } }
private void RunTest(string sExp, Action <ProcedureBuilder> bld) { var m = new ProcedureBuilder(); bld(m); var proc = m.Procedure; var alias = new Aliases(proc, m.Architecture); alias.Transform(); var ssa = new SsaTransform( null, proc, null, proc.CreateBlockDominatorGraph(), new HashSet <RegisterStorage>()).Transform(); var vp = new ValuePropagator(m.Architecture, ssa, null); vp.Transform(); var rule = new ConstDivisionImplementedByMultiplication(ssa); rule.Transform(); var sw = new StringWriter(); proc.Write(false, sw); if (sExp != sw.ToString()) { Debug.Print("{0}", sw); Assert.AreEqual(sExp, sw.ToString()); } }
private void RunTest(string sExp, Action <ProcedureBuilder> bld) { var m = new ProcedureBuilder(); bld(m); var proc = m.Procedure; var ssa = new SsaTransform( new Program { Architecture = m.Architecture }, proc, null, null, null).Transform(); var segmentMap = new SegmentMap(Address.Ptr32(0)); var vp = new ValuePropagator(segmentMap, ssa, new CallGraph(), null, null); vp.Transform(); var rule = new ConstDivisionImplementedByMultiplication(ssa); rule.Transform(); var sw = new StringWriter(); proc.Write(false, sw); if (sExp != sw.ToString()) { Debug.Print("{0}", sw); Assert.AreEqual(sExp, sw.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); }
private Procedure RunTest(string sExp, IProcessorArchitecture arch, Func<Procedure> mkProc) { var proc = mkProc(); progBuilder.ResolveUnresolved(); var ssa = new SsaTransform(pf, proc, proc.CreateBlockDominatorGraph()); var vp = new ValuePropagator(arch, ssa.SsaState.Identifiers, proc); vp.Transform(); ssa.RenameFrameAccesses = true; ssa.AddUseInstructions = true; ssa.Transform(); vp.Transform(); var trf = new TrashedRegisterFinder2( arch, pf, proc, ssa.SsaState.Identifiers, NullDecompilerEventListener.Instance); var flow = trf.Compute(); var sw = new StringWriter(); sw.Write("Preserved: "); sw.WriteLine(string.Join(",", flow.Preserved.OrderBy(p => p.ToString()))); sw.Write("Trashed: "); sw.WriteLine(string.Join(",", flow.Trashed.OrderBy(p => p.ToString()))); if (flow.Constants.Count > 0) { sw.Write("Constants: "); sw.WriteLine(string.Join( ",", flow.Constants .OrderBy(kv => kv.Key.ToString()) .Select(kv => string.Format( "{0}:{1}", kv.Key, kv.Value)))); } var sActual = sw.ToString(); if (sActual != sExp) { proc.Dump(true); Debug.WriteLine(sActual); Assert.AreEqual(sExp, sActual); } pf.ProcedureFlows2.Add(proc, flow); return proc; }
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 importResolver = new ImportResolver( project, this.pb.Program, new FakeDecompilerEventListener()); this.pb.Program.Platform = new FakePlatform(null, new FakeArchitecture()); this.pb.Program.ImageMap = new ImageMap( Address.Ptr32(0x0000), new ImageSegment( ".text", Address.Ptr32(0), 0x40000, AccessMode.ReadWriteExecute)); // Perform the initial transformation var ssa = new SsaTransform(programFlow, proc, importResolver, 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(this.pb.Program.Architecture, 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); }
private Procedure RunTest(string sExp, IProcessorArchitecture arch, Func <Procedure> mkProc) { var proc = mkProc(); progBuilder.ResolveUnresolved(); var project = new Project { Programs = { this.progBuilder.Program } }; var dynamicLinker = new Mock <IDynamicLinker>(); var platform = new Mock <IPlatform>(); platform.Setup(p => p.CreateTrashedRegisters()).Returns(new HashSet <RegisterStorage>()); progBuilder.Program.Platform = platform.Object; var sst = new SsaTransform( progBuilder.Program, proc, new HashSet <Procedure>(), dynamicLinker.Object, new ProgramDataFlow()); sst.Transform(); var vp = new ValuePropagator( segmentMap, sst.SsaState, new CallGraph(), dynamicLinker.Object, NullDecompilerEventListener.Instance); vp.Transform(); sst.RenameFrameAccesses = true; sst.Transform(); sst.AddUsesToExitBlock(); sst.RemoveDeadSsaIdentifiers(); vp.Transform(); return(RunTest(sExp, sst.SsaState)); }
private SsaState RunTest(ProcedureBuilder m) { var proc = m.Procedure; var gr = proc.CreateBlockDominatorGraph(); var sst = new SsaTransform(new ProgramDataFlow(), proc, null, gr); var ssa = sst.SsaState; var vp = new ValuePropagator(arch, ssa.Identifiers, proc); vp.Transform(); return(ssa); }
private SsaState RunTest(ProcedureBuilder m) { var proc = m.Procedure; var gr = proc.CreateBlockDominatorGraph(); var sst = new SsaTransform(new ProgramDataFlow(), proc, importResolver, gr, new HashSet <RegisterStorage>()); var ssa = sst.SsaState; var vp = new ValuePropagator(arch, ssa, listener); vp.Transform(); return(ssa); }
public void VpCopyPropagate() { var ssa = new SsaState(new Procedure("foo", new Frame(PrimitiveType.Pointer32)), null); ssaIds = ssa.Identifiers; Identifier x = Reg32("x"); Identifier y = Reg32("y"); Identifier z = Reg32("z"); Identifier w = Reg32("w"); Statement stmX = new Statement(0, new Assignment(x, new MemoryAccess(MemoryIdentifier.GlobalMemory, Constant.Word32(0x10004000), PrimitiveType.Word32)), null); Statement stmY = new Statement(1, new Assignment(y, x), null); Statement stmZ = new Statement(2, new Assignment(z, new BinaryExpression(Operator.IAdd, PrimitiveType.Word32, y, Constant.Word32(2))), null); Statement stmW = new Statement(3, new Assignment(w, y), null); ssaIds[x].DefStatement = stmX; ssaIds[y].DefStatement = stmY; ssaIds[z].DefStatement = stmZ; ssaIds[w].DefStatement = stmW; ssaIds[x].Uses.Add(stmY); ssaIds[y].Uses.Add(stmZ); ssaIds[y].Uses.Add(stmW); Assert.AreEqual("x = Mem0[0x10004000:word32]", stmX.Instruction.ToString()); Assert.AreEqual("y = x", stmY.Instruction.ToString()); Assert.AreEqual("z = y + 0x00000002", stmZ.Instruction.ToString()); Assert.AreEqual("w = y", stmW.Instruction.ToString()); ValuePropagator vp = new ValuePropagator(arch, ssa, listener); vp.Transform(stmX); vp.Transform(stmY); vp.Transform(stmZ); vp.Transform(stmW); Assert.AreEqual("x = Mem0[0x10004000:word32]", stmX.Instruction.ToString()); Assert.AreEqual("y = x", stmY.Instruction.ToString()); Assert.AreEqual("z = x + 0x00000002", stmZ.Instruction.ToString()); Assert.AreEqual("w = x", stmW.Instruction.ToString()); Assert.AreEqual(3, ssaIds[x].Uses.Count); Assert.AreEqual(0, ssaIds[y].Uses.Count); }
private SsaState RunTest(ProcedureBuilder m) { var proc = m.Procedure; var gr = proc.CreateBlockDominatorGraph(); var sst = new SsaTransform(new ProgramDataFlow(), proc, importResolver.Object, gr, new HashSet <RegisterStorage>()); var ssa = sst.SsaState; var segmentMap = new SegmentMap(Address.Ptr32(0)); var vp = new ValuePropagator(segmentMap, ssa, new CallGraph(), importResolver.Object, listener); vp.Transform(); return(ssa); }
public void VpCopyPropagate() { var x = m.Reg32("x"); var y = m.Reg32("y"); var z = m.Reg32("z"); var w = m.Reg32("w"); m.Assign(x, m.Mem32(Constant.Word32(0x10004000))); var stmX = m.Block.Statements.Last(); m.Assign(y, x); var stmY = m.Block.Statements.Last(); m.Assign(z, m.IAdd(y, Constant.Word32(2))); var stmZ = m.Block.Statements.Last(); m.Assign(w, y); var stmW = m.Block.Statements.Last(); Assert.AreEqual("x = Mem4[0x10004000:word32]", stmX.Instruction.ToString()); Assert.AreEqual("y = x", stmY.Instruction.ToString()); Assert.AreEqual("z = y + 0x00000002", stmZ.Instruction.ToString()); Assert.AreEqual("w = y", stmW.Instruction.ToString()); var vp = new ValuePropagator(segmentMap, m.Ssa, listener); vp.Transform(stmX); vp.Transform(stmY); vp.Transform(stmZ); vp.Transform(stmW); Assert.AreEqual("x = Mem4[0x10004000:word32]", stmX.Instruction.ToString()); Assert.AreEqual("y = x", stmY.Instruction.ToString()); Assert.AreEqual("z = x + 0x00000002", stmZ.Instruction.ToString()); Assert.AreEqual("w = x", stmW.Instruction.ToString()); Assert.AreEqual(3, m.Ssa.Identifiers[x].Uses.Count); Assert.AreEqual(0, m.Ssa.Identifiers[y].Uses.Count); }
protected override void RunTest(Program program, TextWriter writer) { var dynamicLinker = new Mock <IDynamicLinker>().Object; var listener = new FakeDecompilerEventListener(); var sc = new ServiceContainer(); sc.AddService <DecompilerEventListener>(listener); var dfa = new DataFlowAnalysis(program, dynamicLinker, sc); foreach (var proc in program.Procedures.Values) { var sst = new SsaTransform( program, proc, new HashSet <Procedure>(), dynamicLinker, new ProgramDataFlow()); var ssa = sst.Transform(); var larw = new LongAddRewriter(ssa, listener); larw.Transform(); var cce = new ConditionCodeEliminator(program, ssa, listener); cce.Transform(); ssa.Validate(s => { ssa.Dump(true); Assert.Fail(s); }); var vp = new ValuePropagator(program.SegmentMap, ssa, program.CallGraph, dynamicLinker, listener); vp.Transform(); ssa.Validate(s => { ssa.Dump(true); Assert.Fail(s); }); sst.RenameFrameAccesses = true; sst.Transform(); ssa.Validate(s => { ssa.Dump(true); Assert.Fail(s); }); // We don't add uses to exit block on purpose. We // are not testing interprocedural effects here. DeadCode.Eliminate(ssa); ssa.Procedure.Write(false, writer); writer.WriteLine(); ssa.Validate(s => { ssa.Dump(true); Assert.Fail(s); }); } }
private void Build(Procedure proc, IProcessorArchitecture arch) { var platform = new DefaultPlatform(null, arch); var program = new Program() { Architecture = arch, Platform = platform, }; this.proc = proc; var dynamicLinker = new Mock <IDynamicLinker>().Object; var gr = proc.CreateBlockDominatorGraph(); SsaTransform sst = new SsaTransform( program, proc, new HashSet <Procedure>(), null, new ProgramDataFlow()); sst.Transform(); this.ssa = sst.SsaState; this.ssaIds = ssa.Identifiers; var listener = new FakeDecompilerEventListener(); ConditionCodeEliminator cce = new ConditionCodeEliminator(ssa, platform, listener); cce.Transform(); DeadCode.Eliminate(ssa); var segmentMap = new SegmentMap(Address.Ptr32(0x00400000)); ValuePropagator vp = new ValuePropagator( segmentMap, ssa, program.CallGraph, null, listener); vp.Transform(); Coalescer coa = new Coalescer(ssa); coa.Transform(); DeadCode.Eliminate(ssa); }
private SsaState RunTest(ProcedureBuilder m) { var proc = m.Procedure; var sst = new SsaTransform( program, proc, new HashSet <Procedure>(), dynamicLinker.Object, new ProgramDataFlow()); var ssa = sst.SsaState; sst.Transform(); var vp = new ValuePropagator(segmentMap, ssa, program.CallGraph, dynamicLinker.Object, listener); vp.Transform(); return(ssa); }
public void VpDbp() { Procedure proc = new DpbMock().Procedure; var gr = proc.CreateBlockDominatorGraph(); SsaTransform sst = new SsaTransform(new ProgramDataFlow(), proc, null, gr, new HashSet <RegisterStorage>()); SsaState ssa = sst.SsaState; ValuePropagator vp = new ValuePropagator(segmentMap, ssa, listener); vp.Transform(); using (FileUnitTester fut = new FileUnitTester("Analysis/VpDbp.txt")) { proc.Write(false, fut.TextWriter); fut.TextWriter.WriteLine(); fut.AssertFilesEqual(); } }
public void VpPhiLoops() { var m = new ProcedureBuilder(); var ssa = new SsaState(m.Procedure, null); ssaIds = ssa.Identifiers; var fp = Reg16("fp"); var a = Reg16("a"); var b = Reg16("b"); var c = Reg16("c"); var d = Reg16("d"); var x = Reg16("x"); var y = Reg16("y"); var z = Reg16("z"); m.Emit(m.Assign(y, m.IAdd(x, 4))); m.Emit(m.Assign(z, m.ISub(x, 8))); m.Emit(m.Assign(a, m.ISub(fp, 12))); m.Emit(m.Assign(b, m.ISub(fp, 12))); m.Emit(m.Assign(c, m.ISub(y, 4))); m.Emit(m.Assign(d, m.IAdd(z, 8))); var phiStm = m.Phi(x, a, b, c, d); var stms = m.Procedure.EntryBlock.Succ[0].Statements; stms.ForEach(stm => { var ass = stm.Instruction as Assignment; if (ass != null) { ssaIds[ass.Dst].DefStatement = stm; } var phiAss = stm.Instruction as PhiAssignment; if (phiAss != null) { ssaIds[phiAss.Dst].DefStatement = stm; } }); var vp = new ValuePropagator(arch, ssa, listener); vp.Transform(); Assert.AreEqual("x = fp - 0x000C", phiStm.Instruction.ToString()); }
public void VpDbp() { Procedure proc = new DpbMock().Procedure; var gr = proc.CreateBlockDominatorGraph(); SsaTransform sst = new SsaTransform(new ProgramDataFlow(), proc, null, gr); SsaState ssa = sst.SsaState; ssa.DebugDump(true); ValuePropagator vp = new ValuePropagator(arch, ssa.Identifiers, proc); vp.Transform(); using (FileUnitTester fut = new FileUnitTester("Analysis/VpDbp.txt")) { proc.Write(false, fut.TextWriter); fut.TextWriter.WriteLine(); fut.AssertFilesEqual(); } }
private void Prepare(Procedure proc) { this.proc = proc; doms = proc.CreateBlockDominatorGraph(); SsaTransform sst = new SsaTransform(new ProgramDataFlow(), proc, doms); SsaState ssa = sst.SsaState; ssaIds = ssa.Identifiers; var arch = new FakeArchitecture(); var cce = new ConditionCodeEliminator(ssaIds, new DefaultPlatform(null, arch)); cce.Transform(); DeadCode.Eliminate(proc, ssa); var vp = new ValuePropagator(arch, ssa.Identifiers, proc); vp.Transform(); DeadCode.Eliminate(proc, ssa); }
/// <summary> /// Processes procedures individually, building complex expression trees out /// of the simple, close-to-the-machine code generated by the disassembly. /// </summary> /// <param name="rl"></param> public void BuildExpressionTrees() { int i = 0; foreach (Procedure proc in program.Procedures.Values) { eventListener.ShowProgress("Building complex expressions.", i, program.Procedures.Values.Count); ++i; try { var larw = new LongAddRewriter(proc, program.Architecture); larw.Transform(); Aliases alias = new Aliases(proc, program.Architecture, flow); alias.Transform(); var doms = new DominatorGraph<Block>(proc.ControlGraph, proc.EntryBlock); var sst = new SsaTransform(flow, proc, doms); var ssa = sst.SsaState; var cce = new ConditionCodeEliminator(ssa.Identifiers, program.Platform); cce.Transform(); DeadCode.Eliminate(proc, ssa); var vp = new ValuePropagator(program.Architecture, ssa.Identifiers, proc); vp.Transform(); DeadCode.Eliminate(proc, ssa); // Build expressions. A definition with a single use can be subsumed // into the using expression. var coa = new Coalescer(proc, ssa); coa.Transform(); DeadCode.Eliminate(proc, ssa); var liv = new LinearInductionVariableFinder( proc, ssa.Identifiers, new BlockDominatorGraph(proc.ControlGraph, proc.EntryBlock)); liv.Find(); foreach (KeyValuePair<LinearInductionVariable, LinearInductionVariableContext> de in liv.Contexts) { var str = new StrengthReduction(ssa, de.Key, de.Value); str.ClassifyUses(); str.ModifyUses(); } var opt = new OutParameterTransformer(proc, ssa.Identifiers); opt.Transform(); DeadCode.Eliminate(proc, ssa); // Definitions with multiple uses and variables joined by PHI functions become webs. var web = new WebBuilder(proc, ssa.Identifiers, program.InductionVariables); web.Transform(); ssa.ConvertBack(false); } catch (Exception ex) { eventListener.Error(new NullCodeLocation(proc.Name), ex, "An error occurred during data flow analysis."); } } }
private void UntangleProcedureScc(IList<Procedure> procs) { if (procs.Count == 1) { var proc = procs[0]; Aliases alias = new Aliases(proc, program.Architecture, flow); alias.Transform(); // Transform the procedure to SSA state. When encountering 'call' instructions, // they can be to functions already visited. If so, they have a "ProcedureFlow" // associated with them. If they have not been visited, or are computed destinations // (e.g. vtables) they will have no "ProcedureFlow" associated with them yet, in // which case the the SSA treats the call as a "hell node". var doms = proc.CreateBlockDominatorGraph(); var sst = new SsaTransform(flow, proc, doms); var ssa = sst.SsaState; // Propagate condition codes and registers. At the end, the hope is that // all statements like (x86) mem[esp_42+4] will have been converted to // mem[fp - 30]. We also hope that procedure constants kept in registers // are propagated to the corresponding call sites. var cce = new ConditionCodeEliminator(ssa.Identifiers, program.Platform); cce.Transform(); var vp = new ValuePropagator(program.Architecture, ssa.Identifiers, proc); vp.Transform(); // Now compute SSA for the stack-based variables as well. That is: // mem[fp - 30] becomes wLoc30, while // mem[fp + 30] becomes wArg30. // This allows us to compute the dataflow of this procedure. sst.RenameFrameAccesses = true; sst.AddUseInstructions = true; sst.Transform(); // Propagate those newly discovered identifiers. vp.Transform(); // At this point, the computation of _actual_ ProcedureFlow should be possible. var tid = new TrashedRegisterFinder2(program.Architecture, flow, proc, ssa.Identifiers, this.eventListener); tid.Compute(); DeadCode.Eliminate(proc, ssa); // Build expressions. A definition with a single use can be subsumed // into the using expression. var coa = new Coalescer(proc, ssa); coa.Transform(); DeadCode.Eliminate(proc, ssa); var liv = new LinearInductionVariableFinder( proc, ssa.Identifiers, new BlockDominatorGraph(proc.ControlGraph, proc.EntryBlock)); liv.Find(); foreach (var de in liv.Contexts) { var str = new StrengthReduction(ssa, de.Key, de.Value); str.ClassifyUses(); str.ModifyUses(); } //var opt = new OutParameterTransformer(proc, ssa.Identifiers); //opt.Transform(); DeadCode.Eliminate(proc, ssa); // Definitions with multiple uses and variables joined by PHI functions become webs. var web = new WebBuilder(proc, ssa.Identifiers, program.InductionVariables); web.Transform(); ssa.ConvertBack(false); } else { throw new NotImplementedException(); } }
private SsaState RunTest(ProcedureBuilder m) { var proc = m.Procedure; var gr = proc.CreateBlockDominatorGraph(); var sst = new SsaTransform(new ProgramDataFlow(), proc, importResolver, gr, new HashSet<RegisterStorage>()); var ssa = sst.SsaState; var vp = new ValuePropagator(arch, ssa); vp.Transform(); return ssa; }
public void VpDbpDbp() { var m = new ProcedureBuilder(); var d1 = m.Reg32("d32",0); var a1 = m.Reg32("a32",1); m.Assign(d1, m.Dpb(d1, m.LoadW(a1), 0)); m.Assign(d1, m.Dpb(d1, m.LoadW(m.IAdd(a1, 4)), 0)); Procedure proc = m.Procedure; var gr = proc.CreateBlockDominatorGraph(); var importResolver = MockRepository.GenerateStub<IImportResolver>(); importResolver.Replay(); var sst = new SsaTransform(new ProgramDataFlow(), proc, importResolver, gr, new HashSet<RegisterStorage>()); var ssa = sst.SsaState; var vp = new ValuePropagator(arch, ssa); vp.Transform(); using (FileUnitTester fut = new FileUnitTester("Analysis/VpDpbDpb.txt")) { proc.Write(false, fut.TextWriter); fut.TextWriter.WriteLine(); fut.AssertFilesEqual(); } }
protected override void RunTest(Program program, TextWriter writer) { var importResolver = MockRepository.GenerateStub<IImportResolver>(); DataFlowAnalysis dfa = new DataFlowAnalysis(program, importResolver, new FakeDecompilerEventListener()); dfa.UntangleProcedures(); foreach (Procedure proc in program.Procedures.Values) { var larw = new LongAddRewriter(proc, program.Architecture); larw.Transform(); Aliases alias = new Aliases(proc, program.Architecture, dfa.ProgramDataFlow); alias.Transform(); var sst = new SsaTransform(dfa.ProgramDataFlow, proc, importResolver, proc.CreateBlockDominatorGraph(), new HashSet<RegisterStorage>()); SsaState ssa = sst.SsaState; var cce = new ConditionCodeEliminator(ssa, program.Platform); cce.Transform(); var vp = new ValuePropagator(program.Architecture, ssa); vp.Transform(); DeadCode.Eliminate(proc, ssa); ssa.Write(writer); proc.Write(false, writer); writer.WriteLine(); } }
private void Build(Procedure proc, IProcessorArchitecture arch) { var platform = new DefaultPlatform(null, arch); this.proc = proc; Aliases alias = new Aliases(proc, arch); alias.Transform(); SsaTransform sst = new SsaTransform(new ProgramDataFlow(), proc, proc.CreateBlockDominatorGraph()); ssa = sst.SsaState; ConditionCodeEliminator cce = new ConditionCodeEliminator(ssa.Identifiers, platform); cce.Transform(); ValuePropagator vp = new ValuePropagator(arch, ssa.Identifiers, proc); vp.Transform(); DeadCode.Eliminate(proc, ssa); Coalescer coa = new Coalescer(proc, ssa); coa.Transform(); DeadCode.Eliminate(proc, ssa); sla = new SsaLivenessAnalysis(proc, ssa.Identifiers); sla2 = new SsaLivenessAnalysis2(proc, ssa.Identifiers); sla2.Analyze(); }
public void VpDbpDbp() { var m = new ProcedureBuilder(); var d1 = m.Reg32("d32"); var a1 = m.Reg32("a32"); var tmp = m.Frame.CreateTemporary(PrimitiveType.Word16); m.Assign(d1, m.Dpb(d1, m.LoadW(a1), 0, 16)); m.Assign(d1, m.Dpb(d1, m.LoadW(m.IAdd(a1, 4)), 0, 16)); Procedure proc = m.Procedure; var gr = proc.CreateBlockDominatorGraph(); SsaTransform sst = new SsaTransform(new ProgramDataFlow(), proc, gr); SsaState ssa = sst.SsaState; ssa.DebugDump(true); var vp = new ValuePropagator(arch, ssa.Identifiers, proc); vp.Transform(); using (FileUnitTester fut = new FileUnitTester("Analysis/VpDpbDpb.txt")) { proc.Write(false, fut.TextWriter); fut.TextWriter.WriteLine(); fut.AssertFilesEqual(); } }
public void VpDbp() { Procedure proc = new DpbMock().Procedure; var gr = proc.CreateBlockDominatorGraph(); SsaTransform sst = new SsaTransform(new ProgramDataFlow(), proc, null, gr, new HashSet<RegisterStorage>()); SsaState ssa = sst.SsaState; ValuePropagator vp = new ValuePropagator(arch, ssa); vp.Transform(); using (FileUnitTester fut = new FileUnitTester("Analysis/VpDbp.txt")) { proc.Write(false, fut.TextWriter); fut.TextWriter.WriteLine(); fut.AssertFilesEqual(); } }
protected override void RunTest(Program prog, TextWriter writer) { var dfa = new DataFlowAnalysis(prog, importResolver, new FakeDecompilerEventListener()); dfa.UntangleProcedures(); foreach (Procedure proc in prog.Procedures.Values) { writer.WriteLine("= {0} ========================", proc.Name); var gr = proc.CreateBlockDominatorGraph(); Aliases alias = new Aliases(proc, prog.Architecture); alias.Transform(); SsaTransform sst = new SsaTransform(dfa.ProgramDataFlow, proc, importResolver, gr, new HashSet<RegisterStorage>()); SsaState ssa = sst.SsaState; var cce = new ConditionCodeEliminator(ssa, prog.Platform); cce.Transform(); ssa.Write(writer); proc.Write(false, writer); writer.WriteLine(); ValuePropagator vp = new ValuePropagator(prog.Architecture, ssa); vp.Transform(); ssa.Write(writer); proc.Write(false, writer); } }
private void Build(Procedure proc, IProcessorArchitecture arch) { var platform = new DefaultPlatform(null, arch); this.proc = proc; Aliases alias = new Aliases(proc, arch); alias.Transform(); var gr = proc.CreateBlockDominatorGraph(); SsaTransform sst = new SsaTransform(new ProgramDataFlow(), proc, gr); SsaState ssa = sst.SsaState; this.ssaIds = ssa.Identifiers; ConditionCodeEliminator cce = new ConditionCodeEliminator(ssa.Identifiers, platform); cce.Transform(); DeadCode.Eliminate(proc, ssa); ValuePropagator vp = new ValuePropagator(ssa.Identifiers, proc); vp.Transform(); Coalescer coa = new Coalescer(proc, ssa); coa.Transform(); DeadCode.Eliminate(proc, ssa); proc.Dump(true, false); //$DEBUG }
protected override void RunTest(Program prog, TextWriter fut) { DataFlowAnalysis dfa = new DataFlowAnalysis(prog, new FakeDecompilerEventListener()); dfa.UntangleProcedures(); foreach (Procedure proc in prog.Procedures.Values) { Aliases alias = new Aliases(proc, prog.Architecture); alias.Transform(); SsaTransform sst = new SsaTransform(dfa.ProgramDataFlow, proc, proc.CreateBlockDominatorGraph()); SsaState ssa = sst.SsaState; ConditionCodeEliminator cce = new ConditionCodeEliminator(ssa.Identifiers, prog.Platform); cce.Transform(); DeadCode.Eliminate(proc, ssa); ValuePropagator vp = new ValuePropagator(ssa.Identifiers, proc); vp.Transform(); DeadCode.Eliminate(proc, ssa); Coalescer co = new Coalescer(proc, ssa); co.Transform(); ssa.Write(fut); proc.Write(false, fut); fut.WriteLine(); } }
private void Build(Program prog) { DataFlowAnalysis dfa = new DataFlowAnalysis(prog, new FakeDecompilerEventListener()); dfa.UntangleProcedures(); foreach (Procedure proc in prog.Procedures.Values) { Aliases alias = new Aliases(proc, prog.Architecture); alias.Transform(); var gr = proc.CreateBlockDominatorGraph(); SsaTransform sst = new SsaTransform(dfa.ProgramDataFlow, proc, gr); SsaState ssa = sst.SsaState; ConditionCodeEliminator cce = new ConditionCodeEliminator(ssa.Identifiers, prog.Platform); cce.Transform(); DeadCode.Eliminate(proc, ssa); var vp = new ValuePropagator(ssa.Identifiers, proc); vp.Transform(); DeadCode.Eliminate(proc, ssa); Coalescer coa = new Coalescer(proc, ssa); coa.Transform(); DeadCode.Eliminate(proc, ssa); LiveCopyInserter lci = new LiveCopyInserter(proc, ssa.Identifiers); lci.Transform(); WebBuilder web = new WebBuilder(proc, ssa.Identifiers, new Dictionary<Identifier,LinearInductionVariable>()); web.Transform(); ssa.ConvertBack(false); } }
public void VpCopyPropagate() { var ssa = new SsaState(new Procedure("foo", new Frame(PrimitiveType.Pointer32)), null); ssaIds = ssa.Identifiers; Identifier x = Reg32("x"); Identifier y = Reg32("y"); Identifier z = Reg32("z"); Identifier w = Reg32("w"); Statement stmX = new Statement(0, new Assignment(x, new MemoryAccess(MemoryIdentifier.GlobalMemory, Constant.Word32(0x10004000), PrimitiveType.Word32)), null); Statement stmY = new Statement(1, new Assignment(y, x), null); Statement stmZ = new Statement(2, new Assignment(z, new BinaryExpression(Operator.IAdd, PrimitiveType.Word32, y, Constant.Word32(2))), null); Statement stmW = new Statement(3, new Assignment(w, y), null); ssaIds[x].DefStatement = stmX; ssaIds[y].DefStatement = stmY; ssaIds[z].DefStatement = stmZ; ssaIds[w].DefStatement = stmW; ssaIds[x].Uses.Add(stmY); ssaIds[y].Uses.Add(stmZ); ssaIds[y].Uses.Add(stmW); Assert.AreEqual("x = Mem0[0x10004000:word32]", stmX.Instruction.ToString()); Assert.AreEqual("y = x", stmY.Instruction.ToString()); Assert.AreEqual("z = y + 0x00000002", stmZ.Instruction.ToString()); Assert.AreEqual("w = y", stmW.Instruction.ToString()); ValuePropagator vp = new ValuePropagator(arch, ssa); vp.Transform(stmX); vp.Transform(stmY); vp.Transform(stmZ); vp.Transform(stmW); Assert.AreEqual("x = Mem0[0x10004000:word32]", stmX.Instruction.ToString()); Assert.AreEqual("y = x", stmY.Instruction.ToString()); Assert.AreEqual("z = x + 0x00000002", stmZ.Instruction.ToString()); Assert.AreEqual("w = x", stmW.Instruction.ToString()); Assert.AreEqual(3, ssaIds[x].Uses.Count); Assert.AreEqual(0, ssaIds[y].Uses.Count); }
private void Build(Procedure proc, IProcessorArchitecture arch) { var platform = new DefaultPlatform(null, arch); this.proc = proc; var importResolver = MockRepository.GenerateStub<IImportResolver>(); importResolver.Replay(); Aliases alias = new Aliases(proc, arch); alias.Transform(); var gr = proc.CreateBlockDominatorGraph(); SsaTransform sst = new SsaTransform( new ProgramDataFlow(), proc, null, gr, new HashSet<RegisterStorage>()); SsaState ssa = sst.SsaState; this.ssaIds = ssa.Identifiers; ConditionCodeEliminator cce = new ConditionCodeEliminator(ssa, platform); cce.Transform(); DeadCode.Eliminate(proc, ssa); ValuePropagator vp = new ValuePropagator(arch, ssa); vp.Transform(); Coalescer coa = new Coalescer(proc, ssa); coa.Transform(); DeadCode.Eliminate(proc, ssa); }
public void VpPhiLoops() { var m = new ProcedureBuilder(); var ssa = new SsaState(m.Procedure, null); ssaIds = ssa.Identifiers; var fp = Reg16("fp"); var a = Reg16("a"); var b = Reg16("b"); var c = Reg16("c"); var d = Reg16("d"); var x = Reg16("x"); var y = Reg16("y"); var z = Reg16("z"); m.Emit(m.Assign(y, m.IAdd(x, 4))); m.Emit(m.Assign(z, m.ISub(x, 8))); m.Emit(m.Assign(a, m.ISub(fp, 12))); m.Emit(m.Assign(b, m.ISub(fp, 12))); m.Emit(m.Assign(c, m.ISub(y, 4))); m.Emit(m.Assign(d, m.IAdd(z, 8))); var phiStm = m.Phi(x, a, b, c, d); var stms = m.Procedure.EntryBlock.Succ[0].Statements; stms.ForEach(stm => { var ass = stm.Instruction as Assignment; if (ass != null) ssaIds[ass.Dst].DefStatement = stm; var phiAss = stm.Instruction as PhiAssignment; if (phiAss != null) ssaIds[phiAss.Dst].DefStatement = stm; }); var vp = new ValuePropagator(arch, ssa); vp.Transform(); Assert.AreEqual("x = fp - 0x000C", phiStm.Instruction.ToString()); }
public void VpEquality2() { // Makes sure that // y = x - 2 // if (y == 0) ... // doesn't get munged into // y = x - 2 // if (x == 2) ProcedureBuilder m = new ProcedureBuilder(); var ssa = new SsaState(m.Procedure, null); this.ssaIds = ssa.Identifiers; Identifier x = Reg32("x"); Identifier y = Reg32("y"); var stmX = m.Assign(x, m.LoadDw(Constant.Word32(0x1000300))); ssaIds[x].DefStatement = m.Block.Statements.Last; var stmY = m.Assign(y, m.ISub(x, 2)); ssaIds[y].DefStatement = m.Block.Statements.Last; var stm = m.BranchIf(m.Eq(y, 0), "test"); Assert.AreEqual("x = Mem0[0x01000300:word32]", stmX.ToString()); Assert.AreEqual("y = x - 0x00000002", stmY.ToString()); Assert.AreEqual("branch y == 0x00000000 test", stm.ToString()); var vp = new ValuePropagator(arch, ssa); vp.Transform(stm); Assert.AreEqual("branch x == 0x00000002 test", stm.Instruction.ToString()); }
protected override void RunTest(Program prog, TextWriter writer) { DataFlowAnalysis dfa = new DataFlowAnalysis(prog, new FakeDecompilerEventListener()); dfa.UntangleProcedures(); foreach (Procedure proc in prog.Procedures.Values) { var larw = new LongAddRewriter(proc, prog.Architecture); larw.Transform(); Aliases alias = new Aliases(proc, prog.Architecture, dfa.ProgramDataFlow); alias.Transform(); var sst = new SsaTransform(dfa.ProgramDataFlow, proc, proc.CreateBlockDominatorGraph()); SsaState ssa = sst.SsaState; proc.Dump(true); var vp = new ValuePropagator(ssa.Identifiers, proc); vp.Transform(); var cce = new ConditionCodeEliminator(ssa.Identifiers, prog.Platform); cce.Transform(); DeadCode.Eliminate(proc, ssa); ssa.Write(writer); proc.Write(false, writer); writer.WriteLine(); } }
public void VpDbp() { Procedure proc = new DpbMock().Procedure; var gr = proc.CreateBlockDominatorGraph(); SsaTransform sst = new SsaTransform(new ProgramDataFlow(), proc, gr); SsaState ssa = sst.SsaState; ssa.DebugDump(true); ValuePropagator vp = new ValuePropagator(arch, ssa.Identifiers, proc); vp.Transform(); using (FileUnitTester fut = new FileUnitTester("Analysis/VpDbp.txt")) { proc.Write(false, fut.TextWriter); fut.TextWriter.WriteLine(); fut.AssertFilesEqual(); } }
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 importResolver = new ImportResolver( project, this.pb.Program, new FakeDecompilerEventListener()); 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); 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); }