protected override void RunTest(Program program, string outputFile) { FileUnitTester fut = null; try { fut = new FileUnitTester(outputFile); var factory = program.TypeFactory; var store = program.TypeStore; var aen = new ExpressionNormalizer(program.Platform.PointerType); var eqb = new EquivalenceClassBuilder(factory, store); var tyco = new TypeCollector(factory, store, program); aen.Transform(program); eqb.Build(program); tyco.CollectTypes(); } catch(Exception ex) { fut.TextWriter.WriteLine(ex.Message); fut.TextWriter.WriteLine(ex.StackTrace); throw; } finally { DumpProgAndStore(program, fut); fut.Dispose(); } }
protected override void RunTest(Program program, string outputFileName) { ExpressionNormalizer aen = new ExpressionNormalizer(program.Architecture.PointerType); aen.Transform(program); EquivalenceClassBuilder eq = new EquivalenceClassBuilder(factory, store); eq.Build(program); #if OLD DataTypeBuilder dtb = new DataTypeBuilder(factory, store, program.Architecture); TraitCollector coll = new TraitCollector(factory, store, dtb, program); coll.CollectProgramTraits(program); dtb.BuildEquivalenceClassDataTypes(); #else TypeCollector coll = new TypeCollector(factory, store, program); coll.CollectTypes(); store.BuildEquivalenceClassDataTypes(factory); #endif TypeVariableReplacer tvr = new TypeVariableReplacer(store); tvr.ReplaceTypeVariables(); TypeTransformer trans = new TypeTransformer(factory, store, program); trans.Transform(); using (FileUnitTester fut = new FileUnitTester(outputFileName)) { foreach (Procedure proc in program.Procedures.Values) { proc.Write(false, fut.TextWriter); fut.TextWriter.WriteLine(); } store.Write(fut.TextWriter); fut.AssertFilesEqual(); } }
public void Setup() { factory = new TypeFactory(); store = new TypeStore(); eqb = new EquivalenceClassBuilder(factory, store); var platform = new DefaultPlatform(null, new FakeArchitecture()); dtb = new DataTypeBuilder(factory, store, platform); }
public void TvrReplaceInStruct() { TypeFactory factory = new TypeFactory(); TypeStore store = new TypeStore(); EquivalenceClassBuilder eqb = new EquivalenceClassBuilder(factory, store); Identifier pptr = new Identifier("pptr", PrimitiveType.Word32, null); Identifier ptr = new Identifier("ptr", PrimitiveType.Word32, null); }
public void SetUp() { store = new TypeStore(); factory = new TypeFactory(); aen = new ExpressionNormalizer(PrimitiveType.Pointer32); eqb = new EquivalenceClassBuilder(factory, store); arch = new FakeArchitecture(); prog = new Program(); prog.Architecture = arch; prog.Platform = new DefaultPlatform(null, arch); dtb = new DataTypeBuilder(factory, store, prog.Platform); }
private void RunTest(Expression e) { var globals = new Identifier("globals", PrimitiveType.Pointer32, RegisterStorage.None); store.EnsureExpressionTypeVariable(factory, globals, "globals_t"); var eq = new EquivalenceClassBuilder(factory, store); e.Accept(eq); e.Accept(exa); var outputFileName = string.Format("Typing/{0}.txt", new StackTrace().GetFrame(1).GetMethod().Name); Verify(outputFileName); }
private void RunTest(Expression e, DataType dt) { var eq = new EquivalenceClassBuilder(factory, store); e.Accept(eq); e.Accept(exa); exd.MeetDataType(e, dt); e.Accept(exd, e.TypeVariable); var outputFileName = string.Format("Typing/{0}.txt", new StackTrace().GetFrame(1).GetMethod().Name); Verify(outputFileName); }
public void EqbSimpleEquivalence() { TypeFactory factory = new TypeFactory(); TypeStore store = new TypeStore(); EquivalenceClassBuilder eqb = new EquivalenceClassBuilder(factory, store); Identifier id1 = new Identifier("id2", PrimitiveType.Word32, null); Identifier id2 = new Identifier("id2", PrimitiveType.Word32, null); Assignment ass = new Assignment(id1, id2); ass.Accept(eqb); Assert.IsNotNull(id1); Assert.IsNotNull(id2); Assert.AreEqual(2, id1.TypeVariable.Number, "id1 type number"); Assert.AreEqual(2, id1.TypeVariable.Number, "id2 type number"); Assert.AreEqual(id1.TypeVariable.Class, id2.TypeVariable.Class); }
protected override void RunTest(Program program, string outputFileName) { ExpressionNormalizer aen = new ExpressionNormalizer(program.Architecture.PointerType); aen.Transform(program); EquivalenceClassBuilder eq = new EquivalenceClassBuilder(factory, store); eq.Build(program); #if OLD DataTypeBuilder dtb = new DataTypeBuilder(factory, store, program.Architecture); TraitCollector coll = new TraitCollector(factory, store, dtb, program); coll.CollectProgramTraits(program); sktore.BuildEquivalenceClassDataTypes(factory); #else TypeCollector coll = new TypeCollector(factory, store, program, new FakeDecompilerEventListener()); coll.CollectTypes(); store.BuildEquivalenceClassDataTypes(factory); #endif TypeVariableReplacer tvr = new TypeVariableReplacer(store); tvr.ReplaceTypeVariables(); Exception theEx = null; try { TypeTransformer trans = new TypeTransformer(factory, store, program); trans.Transform(); } catch (Exception ex) { theEx = ex; } using (FileUnitTester fut = new FileUnitTester(outputFileName)) { if (theEx != null) { fut.TextWriter.WriteLine(theEx.Message); fut.TextWriter.WriteLine(theEx.StackTrace); } foreach (Procedure proc in program.Procedures.Values) { proc.Write(false, fut.TextWriter); fut.TextWriter.WriteLine(); } store.Write(fut.TextWriter); fut.AssertFilesEqual(); } }
/// <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; aen = new ExpressionNormalizer(program.Platform.PointerType); eqb = new EquivalenceClassBuilder(factory, store); 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 eventListener.ShowStatus("Gathering primitive datatypes from instructions."); aen.Transform(program); eqb.Build(program); eventListener.ShowStatus("Collecting data types"); tyco.CollectTypes(); store.BuildEquivalenceClassDataTypes(factory); //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); }
/// <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, 60, true); // Re-enable this for debugging 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); ppr.ReplaceAll(eventListener); }); Time("Transforming data types", trans.Transform); Time("Renaming data types", () => ctn.RenameAllTypes(store)); Time("Rewriting program with type information", () => ter.RewriteProgram(program)); }
public void SetupPreStages(Program program) { foreach (var f in userDefinedGlobals) { program.GlobalFields.Fields.Add(f); } foreach (var s in imageSegments.Values) { program.SegmentMap.Segments.Add(s.Address, s); } aen = new ExpressionNormalizer(program.Platform.PointerType); eqb = new EquivalenceClassBuilder(program.TypeFactory, program.TypeStore); dtb = new DataTypeBuilder(program.TypeFactory, program.TypeStore, program.Platform); tvr = new TypeVariableReplacer(program.TypeStore); trans = new TypeTransformer(program.TypeFactory, program.TypeStore, program); ctn = new ComplexTypeNamer(); }
public void SetupPreStages(Program prog) { aen = new ExpressionNormalizer(prog.Platform.PointerType); eqb = new EquivalenceClassBuilder(prog.TypeFactory, prog.TypeStore); dtb = new DataTypeBuilder(prog.TypeFactory, prog.TypeStore, prog.Platform); tvr = new TypeVariableReplacer(prog.TypeStore); trans = new TypeTransformer(prog.TypeFactory, prog.TypeStore, prog); ctn = new ComplexTypeNamer(); }
private TraitCollector CreateCollector(Program prog) { en = new ExpressionNormalizer(prog.Architecture.PointerType); eqb = new EquivalenceClassBuilder(prog.TypeFactory, prog.TypeStore); handler = new TestTraitHandler(prog.TypeStore); return new TraitCollector(prog.TypeFactory, prog.TypeStore, handler, prog); }
public void Setup() { factory = new TypeFactory(); store = new TypeStore(); eqb = new EquivalenceClassBuilder(factory, store); }
private void RunTest(params Tuple<Expression, DataType>[] tests) { foreach (var t in tests) { var eq = new EquivalenceClassBuilder(factory, store); t.Item1.Accept(eq); } foreach (var t in tests) { var result = t.Item1.Accept(exa); exd.MeetDataType(t.Item1, t.Item2); t.Item1.Accept(exd, t.Item1.TypeVariable); } var outputFileName = string.Format("Typing/{0}.txt", new StackTrace().GetFrame(1).GetMethod().Name); Verify(outputFileName); }
public void Setup() { prog = new Program(); prog.Architecture = new FakeArchitecture(); prog.Platform = new DefaultPlatform(null, prog.Architecture); factory = prog.TypeFactory; store = prog.TypeStore; handler = new TestTraitHandler(store); eqb = new EquivalenceClassBuilder(factory, store); store.EnsureExpressionTypeVariable(factory, prog.Globals); atrco = new AddressTraitCollector(factory, store, handler, prog); m = new ProcedureBuilder(); }