public void Transform() { var ppr = new PtrPrimitiveReplacer(factory, store, program, eventListener); ppr.ReplaceAll(); var cpa = new ConstantPointerAnalysis(factory, store, program); cpa.FollowConstantPointers(); int iteration = 0; do { if (eventListener.IsCanceled()) { return; } ++iteration; if (iteration > 50) { eventListener.Warn( string.Format("Type transformer has looped {0} times, quitting prematurely.", iteration)); return; } Changed = false; visitedTypes.Clear(); foreach (TypeVariable tv in store.TypeVariables) { if (eventListener.IsCanceled()) { return; } EquivalenceClass eq = tv.Class; if (eq.DataType != null) { DateTime start = DateTime.Now; eq.DataType = eq.DataType.Accept(this); DateTime end = DateTime.Now; if (eq.DataType is UnionType ut) { //trace.Verbose("= TT: took {2,4} msec to simplify {0} ({1})", tv.DataType, eq.DataType, (end - start).Milliseconds); } } if (tv.DataType != null) { tv.DataType = tv.DataType.Accept(this); } // Debug.Print("Transformed {0}:{1}", tv, tv.Class.DataType); } if (ppr.ReplaceAll()) { Changed = true; } if (NestedComplexTypeExtractor.ReplaceAll(factory, store)) { Changed = true; } } while (Changed); }
public void Transform() { var ppr = new PtrPrimitiveReplacer(factory, store, program); ppr.ReplaceAll(eventListener); var cpa = new ConstantPointerAnalysis(factory, store, program); cpa.FollowConstantPointers(); int iteration = 0; do { if (eventListener.IsCanceled()) { return; } ++iteration; if (iteration > 50) { eventListener.Warn(new NullCodeLocation(""), string.Format("Type transformer has looped {0} times, quitting prematurely.", iteration)); return; } Changed = false; this.visitedTypes = new HashSet <DataType>(); foreach (TypeVariable tv in store.TypeVariables) { if (eventListener.IsCanceled()) { return; } tvCur = tv; EquivalenceClass eq = tv.Class; if (eq.DataType != null) { eq.DataType = eq.DataType.Accept(this); } if (tv.DataType != null) { tv.DataType = tv.DataType.Accept(this); } // Debug.Print("Transformed {0}:{1}", tv, tv.Class.DataType); } if (ppr.ReplaceAll(eventListener)) { Changed = true; } if (NestedComplexTypeExtractor.ReplaceAll(factory, store)) { Changed = true; } } while (Changed); }
/// <summary> /// Performs type analysis and rewrites program based on the inferred /// information. /// </summary> /// <remarks> /// For instance, all MemoryAccesses will be converted to structure /// field accesses or array accesses as appropriate. /// </remarks> /// <param name="program"></param> public void RewriteProgram(Program program) { factory = program.TypeFactory; store = program.TypeStore; aen = new ExpressionNormalizer(program.Platform.PointerType); eqb = new EquivalenceClassBuilder(factory, store, eventListener); tyco = new TypeCollector( program.TypeFactory, program.TypeStore, program, eventListener); //dpa = new DerivedPointerAnalysis(factory, store, program.Architecture); tvr = new TypeVariableReplacer(store); trans = new TypeTransformer(factory, store,program, eventListener); ctn = new ComplexTypeNamer(); ter = new TypedExpressionRewriter(program, eventListener); // RestrictProcedures(program, 0, 60, true); // Re-enable this for debugging aen.Transform(program); eqb.Build(program); tyco.CollectTypes(); store.BuildEquivalenceClassDataTypes(factory); //dpa.FollowConstantPointers(prog); tvr.ReplaceTypeVariables(); eventListener.ShowStatus("Transforming datatypes."); var ppr = new PtrPrimitiveReplacer(factory, store, program); ppr.ReplaceAll(eventListener); trans.Transform(); ctn.RenameAllTypes(store); ter.RewriteProgram(program); }
/// <summary> /// Performs type analysis and rewrites program based on the inferred information. /// </summary> /// <remarks> /// For instance, all MemoryAccesses will be converted to structure field /// accesses or array accesses as appropriate. /// </remarks> /// <param name="program"></param> public void RewriteProgram(Program program) { factory = program.TypeFactory; store = program.TypeStore; aen = new ExpressionNormalizer(program.Platform.PointerType); eqb = new EquivalenceClassBuilder(factory, store); #if OLD dtb = new DataTypeBuilder(factory, store, program.Platform); trco = new TraitCollector(factory, store, dtb, program); #else tyco = new TypeCollector(program.TypeFactory, program.TypeStore, program); #endif //dpa = new DerivedPointerAnalysis(factory, store, program.Architecture); tvr = new TypeVariableReplacer(store); trans = new TypeTransformer(factory, store, program, eventListener); ctn = new ComplexTypeNamer(); ter = new TypedExpressionRewriter(program); // RestrictProcedures(program, 0, 1, true); // Re-enable this for debugging eventListener.ShowStatus("Gathering primitive datatypes from instructions."); aen.Transform(program); eqb.Build(program); #if OLD eventListener.ShowStatus("Collecting datatype usage traits."); trco.CollectProgramTraits(program); eventListener.ShowStatus("Building equivalence classes."); dtb.BuildEquivalenceClassDataTypes(); #else eventListener.ShowStatus("Collecting data types"); tyco.CollectTypes(); store.BuildEquivalenceClassDataTypes(factory); #endif //dpa.FollowConstantPointers(prog); tvr.ReplaceTypeVariables(); eventListener.ShowStatus("Transforming datatypes."); var ppr = new PtrPrimitiveReplacer(factory, store, program); ppr.ReplaceAll(); trans.Transform(); ctn.RenameAllTypes(store); store.Dump(); eventListener.ShowStatus("Rewriting expressions."); ter.RewriteProgram(program); }
private void RunTest(Program program, string outputFile) { EquivalenceClassBuilder eqb = new EquivalenceClassBuilder(factory, store); DataTypeBuilder dtb = new DataTypeBuilder(factory, store, program.Platform); eqb.Build(program); TraitCollector trco = new TraitCollector(factory, store, dtb, program); trco.CollectProgramTraits(program); dtb.BuildEquivalenceClassDataTypes(); var tv = new TypeVariableReplacer(store); tv.ReplaceTypeVariables(); store.CopyClassDataTypesToTypeVariables(); var ppr = new PtrPrimitiveReplacer(factory, store, program); ppr.ReplaceAll(new FakeDecompilerEventListener()); var cpa = new ConstantPointerAnalysis(factory, store, program); cpa.FollowConstantPointers(); Verify(null, outputFile); }
protected override void RunTest(Program prog, string outputFilename) { TypeFactory factory = new TypeFactory(); store = new TypeStore(); EquivalenceClassBuilder eqb = new EquivalenceClassBuilder(factory, store); eqb.Build(prog); DataTypeBuilder dtb = new DataTypeBuilder(factory, store, prog.Platform); TraitCollector trco = new TraitCollector(factory, store, dtb, prog); trco.CollectProgramTraits(prog); dtb.BuildEquivalenceClassDataTypes(); store.CopyClassDataTypesToTypeVariables(); TypeVariableReplacer tvr = new TypeVariableReplacer(store); tvr.ReplaceTypeVariables(); PtrPrimitiveReplacer ppr = new PtrPrimitiveReplacer(factory, store, prog); ppr.ReplaceAll(new FakeDecompilerEventListener()); Verify(prog, outputFilename); }
/// <summary> /// Performs type analysis and rewrites program based on the inferred /// information. /// </summary> /// <remarks> /// For instance, all MemoryAccesses will be converted to structure /// field accesses or array accesses as appropriate. /// </remarks> /// <param name="program"></param> public void RewriteProgram(Program program) { factory = program.TypeFactory; store = program.TypeStore; var timer = new Stopwatch(); aen = new ExpressionNormalizer(program.Platform.PointerType); eqb = new EquivalenceClassBuilder(factory, store, eventListener); tyco = new TypeCollector( program.TypeFactory, program.TypeStore, program, eventListener); //dpa = new DerivedPointerAnalysis(factory, store, program.Architecture); tvr = new TypeVariableReplacer(store); trans = new TypeTransformer(factory, store, program, eventListener); ctn = new ComplexTypeNamer(); ter = new TypedExpressionRewriter(program, eventListener); RestrictProcedures(program, 0, 0, false); Time("Normalizing expressions", () => aen.Transform(program)); Time("Building equivalence classes", () => eqb.Build(program)); Time("Collecting data types", tyco.CollectTypes); Time("Build eq. class data types", () => store.BuildEquivalenceClassDataTypes(factory)); //dpa.FollowConstantPointers(program); Time("Replacing type variables", tvr.ReplaceTypeVariables); eventListener.ShowStatus("Transforming datatypes."); Time("Replace primitive types", () => { var ppr = new PtrPrimitiveReplacer(factory, store, program, eventListener); ppr.ReplaceAll(); }); Time("Transforming data types", trans.Transform); Time("Renaming data types", () => ctn.RenameAllTypes(store)); Time("Rewriting program with type information", () => ter.RewriteProgram(program)); }
/// <summary> /// Performs type analysis and rewrites program based on the inferred information. /// </summary> /// <remarks> /// For instance, all MemoryAccesses will be converted to structure field /// accesses or array accesses as appropriate. /// </remarks> /// <param name="program"></param> public void RewriteProgram(Program program) { factory = program.TypeFactory; store = program.TypeStore; aen = new ExpressionNormalizer(program.Platform.PointerType); eqb = new EquivalenceClassBuilder(factory, store); dtb = new DataTypeBuilder(factory, store, program.Platform); trco = new TraitCollector(factory, store, dtb, program); //dpa = new DerivedPointerAnalysis(factory, store, program.Architecture); tvr = new TypeVariableReplacer(store); trans = new TypeTransformer(factory, store,program, eventListener); ctn = new ComplexTypeNamer(); ter = new TypedExpressionRewriter(program); // RestrictProcedures(program, 0, 1, true); // Re-enable this for debugging eventListener.ShowStatus("Gathering primitive datatypes from instructions."); aen.Transform(program); eqb.Build(program); eventListener.ShowStatus("Collecting datatype usage traits."); trco.CollectProgramTraits(program); eventListener.ShowStatus("Building equivalence classes."); dtb.BuildEquivalenceClassDataTypes(); //dpa.FollowConstantPointers(prog); tvr.ReplaceTypeVariables(); eventListener.ShowStatus("Transforming datatypes."); var ppr = new PtrPrimitiveReplacer(factory, store, program); ppr.ReplaceAll(); trans.Transform(); ctn.RenameAllTypes(store); store.Dump(); eventListener.ShowStatus("Rewriting expressions."); ter.RewriteProgram(program); }
public void PprReplaceInts() { var arch = new FakeArchitecture(); var program = new Program { Architecture = arch, Platform = new DefaultPlatform(null, arch) }; TypeFactory factory = new TypeFactory(); store = new TypeStore(); TypeVariable tv1 = store.CreateTypeVariable(factory); TypeVariable tv2 = store.CreateTypeVariable(factory); Assert.IsNotNull(tv1.Class, "Expected store.EnsureTypeVariable to create equivalence class"); Assert.IsNotNull(tv2.Class, "Expected store.EnsureTypeVariable to create equivalence class"); tv1.Class.DataType = PrimitiveType.Word32; tv2.Class.DataType = PrimitiveType.Word16; program.Globals.TypeVariable = store.CreateTypeVariable(factory); program.Globals.DataType = factory.CreateStructureType(); TypeVariable tv3 = store.CreateTypeVariable(factory); Assert.IsNotNull(tv3.Class, "Expected store.EnsureTypeVariable to create equivalence class"); StructureType mem = factory.CreateStructureType(null, 0); mem.Fields.Add(0, tv1); mem.Fields.Add(4, tv2); tv3.Class.DataType = factory.CreatePointer(mem, 4); store.CopyClassDataTypesToTypeVariables(); TypeVariableReplacer tvr = new TypeVariableReplacer(store); tvr.ReplaceTypeVariables(); var ppr = new PtrPrimitiveReplacer(factory, store, program); ppr.ReplaceAll(); Verify(null, "Typing/PprReplaceInts.txt"); }