public void TrcoArrayAccess() { ProcedureBuilder m = new ProcedureBuilder(); Identifier ds = m.Local(PrimitiveType.SegmentSelector, "ds"); Identifier bx = m.Local16("bx"); Expression e = m.Array(PrimitiveType.Word32, m.Seq(ds, m.Word16(0x300)), m.IMul(bx, 8)); coll = CreateCollector(); e.Accept(eqb); e.Accept(coll); StringWriter sb = new StringWriter(); handler.Traits.Write(sb); string sExp = "T_1 (in ds : selector)" + nl + "\ttrait_primitive(selector)" + nl + "\ttrait_mem_array(300, 8, 0, T_7)" + nl + "T_2 (in 0x0300 : word16)" + nl + " trait_primitive(word16)"+ nl + "T_3 (in SEQ(ds, 0x0300) : ptr32)" + nl + " trait_primitive(ptr32)"+ nl + "T_4 (in bx : word16)" + nl + " trait_primitive(word16)"+ nl + " trait_primitive(ui16)"+ nl + "T_5 (in 0x0008 : word16)" + nl + " trait_primitive(word16)"+ nl + " trait_primitive(ui16)"+ nl + "T_6 (in bx * 0x0008 : word16)" + nl + " trait_primitive(ui16)"+ nl + "T_7 (in SEQ(ds, 0x0300)[bx * 0x0008] : word32)" + nl + " trait_primitive(word32)"+ nl; Assert.AreEqual(sExp, sb.ToString()); }
public void TrcoInductionVariable() { Identifier i = new Identifier("i", PrimitiveType.Word32, null); MemoryAccess load = new MemoryAccess(MemoryIdentifier.GlobalMemory, i, PrimitiveType.Int32); Identifier i2 = new Identifier("i2", PrimitiveType.Word32, null); MemoryAccess ld2 = new MemoryAccess(MemoryIdentifier.GlobalMemory, i2, PrimitiveType.Int32); LinearInductionVariable iv = new LinearInductionVariable( Constant.Word32(0), Constant.Word32(1), Constant.Word32(10), false); LinearInductionVariable iv2 = new LinearInductionVariable( Constant.Word32(0x0010000), Constant.Word32(4), Constant.Word32(0x0010040), false); Program program = CreateProgram(); program.InductionVariables.Add(i, iv); program.InductionVariables.Add(i2, iv2); coll = CreateCollector(program); program.Globals.Accept(eqb); load.Accept(eqb); ld2.Accept(eqb); program.Globals.Accept(coll); load.Accept(coll); ld2.Accept(coll); Verify(null, "Typing/TrcoInductionVariable.txt"); }
public void TrcoUnsignedCompare() { ProcedureBuilder m = new ProcedureBuilder(); Identifier ds = m.Local16("ds"); Expression e = m.Uge(ds, m.Word16(0x0800)); coll = CreateCollector(); e.Accept(eqb); e.Accept(coll); StringWriter sb = new StringWriter(); handler.Traits.Write(sb); string exp = "T_1 (in ds : word16)" + nl + "\ttrait_primitive(word16)" + nl + "\ttrait_equal(T_2)" + nl + "\ttrait_primitive(cupos16)" + nl + "T_2 (in 0x0800 : word16)" + nl + "\ttrait_primitive(word16)" + nl + "\ttrait_primitive(cupos16)" + nl + "T_3 (in ds >=u 0x0800 : bool)" + nl + "\ttrait_primitive(bool)" + nl; Assert.AreEqual(exp, sb.ToString()); }
private void RunTest(Program program, string outputFile) { var listener = new FakeDecompilerEventListener(); EquivalenceClassBuilder eqb = new EquivalenceClassBuilder(factory, store, listener); 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(listener); var cpa = new ConstantPointerAnalysis(factory, store, program); cpa.FollowConstantPointers(); Verify(null, outputFile); }
public void TrcoDbp() { ProcedureBuilder m = new ProcedureBuilder(); Identifier a = m.Local32("a"); Identifier b = m.LocalByte("b"); var s = m.Assign(a, m.Dpb(a, b, 0)); coll = CreateCollector(); s.Accept(eqb); s.Accept(coll); StringWriter sb = new StringWriter(); handler.Traits.Write(sb); string exp = "T_1 (in a : word32)" + nl + "\ttrait_primitive(word32)" + nl + "\ttrait_primitive(word32)" + nl + "\ttrait_primitive(word32)" + nl + "\ttrait_equal(T_3)" + nl + "T_2 (in b : byte)" + nl + "\ttrait_primitive(byte)" + nl + "T_3 (in DPB(a, b, 0) : word32)" + nl + "\ttrait_primitive(word32)" + nl; Assert.AreEqual(exp, sb.ToString()); }
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(); Verify(prog, outputFilename); }
public void DtbInductionVariables() { Identifier i = new Identifier("i", PrimitiveType.Word32, null); MemoryAccess load = new MemoryAccess(MemoryIdentifier.GlobalMemory, i, PrimitiveType.Int32); Identifier i2 = new Identifier("i2", PrimitiveType.Word32, null); MemoryAccess ld2 = new MemoryAccess(MemoryIdentifier.GlobalMemory, i2, PrimitiveType.Int32); LinearInductionVariable iv = new LinearInductionVariable( Constant.Word32(0), Constant.Word32(1), Constant.Word32(10), false); LinearInductionVariable iv2 = new LinearInductionVariable( Constant.Word32(0x0010000), Constant.Word32(4), Constant.Word32(0x0010040), false); program.InductionVariables.Add(i, iv); program.InductionVariables.Add(i2, iv2); program.Platform = new DefaultPlatform(null, arch); TraitCollector trco = new TraitCollector(factory, store, dtb, program); program.Globals.Accept(eqb); load.Accept(eqb); ld2.Accept(eqb); program.Globals.Accept(trco); load.Accept(trco); ld2.Accept(trco); dtb.BuildEquivalenceClassDataTypes(); Verify("Typing/DtbInductionVariables.txt"); }
public void TvrReplaceInMem() { var id1 = new Identifier("pptr", PrimitiveType.Word32, null); var id2 = new Identifier("ptr", PrimitiveType.Word32, null); var id3 = new Identifier("v", PrimitiveType.Word32, null); var ass1 = new Assignment(id2, MemLoad(id1, 0, PrimitiveType.Word32)); var ass2 = new Assignment(id3, MemLoad(id2, 0, PrimitiveType.Word32)); eqb.VisitAssignment(ass1); eqb.VisitAssignment(ass2); var prog = new Program(); prog.Architecture = new FakeArchitecture(); prog.Platform = new DefaultPlatform(null, prog.Architecture); trco = new TraitCollector(factory, store, dtb, prog); trco.VisitAssignment(ass1); trco.VisitAssignment(ass2); dtb.BuildEquivalenceClassDataTypes(); var tvr = new TypeVariableReplacer(store); tvr.ReplaceTypeVariables(); Verify("Typing/TvrReplaceInMem.txt"); }
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 TerComplex() { Program program = new Program(); program.SegmentMap = new SegmentMap(Address.Ptr32(0x0010000)); program.Architecture = new FakeArchitecture(); program.Platform = new DefaultPlatform(null, program.Architecture); SetupPreStages(program); Identifier id = new Identifier("v0", PrimitiveType.Word32, null); Expression cmp = MemLoad(id, 4, PrimitiveType.Word32); program.Globals.Accept(eqb); cmp.Accept(aen); cmp.Accept(eqb); coll = new TraitCollector(program.TypeFactory, program.TypeStore, dtb, program); cmp.Accept(coll); dtb.BuildEquivalenceClassDataTypes(); tvr.ReplaceTypeVariables(); trans.Transform(); ctn.RenameAllTypes(program.TypeStore); ter = new TypedExpressionRewriter(program, null); cmp = cmp.Accept(ter); Assert.AreEqual("v0->dw0004", cmp.ToString()); }
public void TrcoSegMem() { ProcedureBuilder m = new ProcedureBuilder(); Identifier ds = m.Local16("ds"); Expression e = m.SegMem16(ds, m.Word16(0xC002U)); coll = CreateCollector(); e.Accept(eqb); e.Accept(coll); Verify(null, "Typing/TrcoSegMem.txt"); }
public void DtbArrayAccess2() { ProcedureBuilder m = new ProcedureBuilder(); Identifier ds = m.Local(PrimitiveType.SegmentSelector, "ds"); Identifier bx = m.Local16("bx"); Expression e = m.Array(PrimitiveType.Word32, m.Seq(ds, m.Word16(0x300)), m.IMul(bx, 8)); e.Accept(eqb); TraitCollector coll = new TraitCollector(factory, store, dtb, program); e.Accept(coll); Verify("Typing/DtbArrayAccess2.txt"); }
public void TrcoMultiplication() { var program = CreateProgram(); var m = new ProcedureBuilder(); var id = m.Local32("id"); var e = m.IMul(id, id); coll = CreateCollector(program); e = e.Accept(en); e.Accept(eqb); e.Accept(coll); Verify(null, "Typing/TrcoMultiplication.txt"); }
public void TrcoSegmentedAccess() { ProcedureBuilder m = new ProcedureBuilder(); Identifier ds = m.Local16("ds"); Identifier bx = m.Local16("bx"); Expression e = m.SegMem(PrimitiveType.Word16, ds, m.IAdd(bx, 4)); coll = CreateCollector(); e = e.Accept(en); e.Accept(eqb); e.Accept(coll); Verify(null, "Typing/TrcoSegmentedAccess.txt"); }
protected override void RunTest(Program prog, string outputFilename) { eqb.Build(prog); trco = new TraitCollector(factory, store, dtb, prog); trco.CollectProgramTraits(prog); dtb.BuildEquivalenceClassDataTypes(); store.CopyClassDataTypesToTypeVariables(); TypeVariableReplacer tvr = new TypeVariableReplacer(store); tvr.ReplaceTypeVariables(); Verify(outputFilename); }
public void TrcoCmpMock() { ProgramBuilder mock = new ProgramBuilder(); mock.Add(new CmpMock()); Program program = mock.BuildProgram(); coll = CreateCollector(program); eqb.Build(program); coll.CollectProgramTraits(program); Verify(program, "Typing/TrcoCmpMock.txt"); }
//[Ignore("FIXME")] public void TrcoGlobalArray() { Program program = CreateProgram(); ProcedureBuilder m = new ProcedureBuilder(); Identifier i = m.Local32("i"); Expression ea = m.IAdd(program.Globals, m.IAdd(m.Shl(i, 2), 0x3000)); Expression e = m.Mem(PrimitiveType.Int32, ea); coll = CreateCollector(program); e = e.Accept(en); e.Accept(eqb); e.Accept(coll); Verify(null, "Typing/TrcoGlobalArray.txt"); }
public void TrcoMemberPointer() { ProcedureBuilder m = new ProcedureBuilder(); Identifier ds = m.Local16("ds"); Identifier bx = m.Local16("bx"); MemberPointerSelector mps = m.MembPtrW(ds, m.IAdd(bx, 4)); Expression e = m.Mem(PrimitiveType.Byte, mps); coll = CreateCollector(); e = e.Accept(en); e.Accept(eqb); e.Accept(coll); Verify(null, "Typing/TrcoMemberPointer.txt"); }
protected override void RunTest(Program program, string outputFileName) { var listener = new FakeDecompilerEventListener(); ExpressionNormalizer aen = new ExpressionNormalizer(program.Architecture.PointerType); aen.Transform(program); EquivalenceClassBuilder eq = new EquivalenceClassBuilder(factory, store, listener); 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, listener); 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(); } }
public void TrcoMemberPointer() { ProcedureBuilder m = new ProcedureBuilder(); Identifier ds = m.Local16("ds"); Identifier bx = m.Local16("bx"); MemberPointerSelector mps = m.MembPtrW(ds, m.IAdd(bx, 4)); Expression e = m.Mem(PrimitiveType.Byte, mps); coll = CreateCollector(); e = e.Accept(en); e.Accept(eqb); e.Accept(coll); Assert.IsNotNull(mps.BasePointer.TypeVariable, "Base pointer should have type variable"); Verify(null, "Typing/TrcoMemberPointer.txt"); }
public void TrcoStaggeredArraysMock() { ProgramBuilder mock = new ProgramBuilder(); mock.Add(new StaggeredArraysFragment()); Program program = mock.BuildProgram(); coll = CreateCollector(program); en.Transform(program); eqb.Build(program); coll.CollectProgramTraits(program); Verify(program, "Typing/TrcoStaggeredArraysMock.txt"); }
public void TrcoSegmentedDirectAddress() { Program program = CreateProgram(); program.TypeStore.EnsureExpressionTypeVariable(program.TypeFactory, program.Globals); ProcedureBuilder m = new ProcedureBuilder(); Identifier ds = m.Local16("ds"); Expression e = m.SegMem(PrimitiveType.Byte, ds, m.Word16(0x0200)); coll = CreateCollector(program); e = e.Accept(en); e.Accept(eqb); e.Accept(coll); Verify(null, "Typing/TrcoSegmentedDirectAddress.txt"); }
protected void RunStringTest(Program program, string expectedOutput) { var sw = new StringWriter(); sw.WriteLine("// Before ///////"); DumpProgram(program, sw); var eventListener = new FakeDecompilerEventListener(); SetupPreStages(program); aen.Transform(program); eqb.Build(program); #if OLD coll = new TraitCollector(program.TypeFactory, program.TypeStore, dtb, program); coll.CollectProgramTraits(program); #else var coll = new TypeCollector(program.TypeFactory, program.TypeStore, program, eventListener); coll.CollectTypes(); #endif program.TypeStore.BuildEquivalenceClassDataTypes(program.TypeFactory); tvr.ReplaceTypeVariables(); trans.Transform(); ctn.RenameAllTypes(program.TypeStore); var ter = new TypedExpressionRewriter(program, eventListener); try { ter.RewriteProgram(program); } catch (Exception ex) { sw.WriteLine("** Exception **"); sw.WriteLine(ex); throw; } finally { sw.WriteLine("// After ///////"); DumpProgram(program, sw); } var sActual = sw.ToString(); if (expectedOutput != sActual) { Debug.Print(sActual); Assert.AreEqual(expectedOutput, sActual); } }
/// <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); }
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(); } }
public void DtbRepeatedLoads() { Identifier pfoo = new Identifier("pfoo", PrimitiveType.Word32, null); Identifier x = new Identifier("x", PrimitiveType.Word32, null); Assignment ass1 = new Assignment(x, MemLoad(pfoo, 4, PrimitiveType.Word32)); Assignment ass2 = new Assignment(x, MemLoad(pfoo, 4, PrimitiveType.Word32)); ass1.Accept(eqb); ass2.Accept(eqb); TraitCollector trco = new TraitCollector(factory, store, dtb, program); trco.VisitAssignment(ass1); trco.VisitAssignment(ass2); dtb.BuildEquivalenceClassDataTypes(); Verify("Typing/DtbRepeatedLoads.txt"); }
public void DtbSameMemFetch() { Identifier foo = new Identifier("foo", PrimitiveType.Word32, null); Identifier bar = new Identifier("bar", PrimitiveType.Word16, null); Identifier baz = new Identifier("baz", PrimitiveType.Word16, null); Assignment ass1 = new Assignment(bar, MemLoad(foo, 4, PrimitiveType.Word16)); Assignment ass2 = new Assignment(baz, MemLoad(foo, 4, PrimitiveType.Word16)); ass1.Accept(eqb); ass2.Accept(eqb); TraitCollector trco = new TraitCollector(factory, store, dtb, program); trco.VisitAssignment(ass1); trco.VisitAssignment(ass2); dtb.BuildEquivalenceClassDataTypes(); Verify("Typing/DtbSameMemFetch.txt"); }
protected override void RunTest(Program program, string outFile) { coll = CreateCollector(program); en.Transform(program); eqb.Build(program); coll.CollectProgramTraits(program); using (FileUnitTester fut = new FileUnitTester(outFile)) { foreach (Procedure proc in program.Procedures.Values) { proc.Write(false, fut.TextWriter); fut.TextWriter.WriteLine(); } handler.Traits.Write(fut.TextWriter); fut.AssertFilesEqual(); } }
public void TrcoCallFunctionWithArraySize() { var m = new ProcedureBuilder(); var sig = new ProcedureSignature(null, m.Frame.EnsureStackArgument(0, PrimitiveType.Word32)); var ex = new ExternalProcedure("malloc", sig, new ProcedureCharacteristics { Allocator = true, ArraySize = new ArraySizeCharacteristic { Argument = "r", Factors = new ArraySizeFactor[] { new ArraySizeFactor { Constant = "1" } } } }); Identifier eax = m.Local32("eax"); var call = m.Assign(eax, m.Fn(new ProcedureConstant(PrimitiveType.Word32, ex), m.Word32(3))); coll = CreateCollector(); call.Accept(eqb); call.Accept(coll); StringWriter sw = new StringWriter(); handler.Traits.Write(sw); string sExp = "T_1 (in malloc : word32)" + nl + "\ttrait_func(T_4 -> T_5)" + nl + "T_3 (in dwArg00 : word32)" + nl + "\ttrait_primitive(word32)" + nl + "T_4 (in 0x00000003 : word32)" + nl + "\ttrait_primitive(word32)" + nl + "\ttrait_equal(T_3)" + nl + "T_5 (in malloc(0x00000003) : word32)" + nl + "\ttrait_primitive(word32)"; Console.WriteLine(sw.ToString()); Assert.AreEqual(sExp, sw.ToString()); }
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); }
public void TrcoArrayExpression() { var b = new Identifier("base", PrimitiveType.Word32, null); var i = new Identifier("idx", PrimitiveType.Word32, null); var s = Constant.Word32(4); ProcedureBuilder m = new ProcedureBuilder(); // e ::= Mem[(b+0x1003000)+(i*s):word16] Expression e = m.Mem( PrimitiveType.Word16, m.IAdd(m.IAdd(b, Constant.Word32(0x10030000)), m.SMul(i, s))); coll = CreateCollector(); e = e.Accept(en); e.Accept(eqb); e.Accept(coll); Verify(null, "Typing/TrcoArrayExpression.txt"); }
public void DtbSegmentedAccess() { ProcedureBuilder m = new ProcedureBuilder(); Identifier ds = m.Local16("ds"); Identifier bx = m.Local16("bx"); Expression e = m.SegMem(bx.DataType, ds, m.IAdd(bx, 4)); var arch = new Reko.Arch.X86.X86ArchitectureReal(); Program prog = new Program { Architecture = arch, Platform = new DefaultPlatform(null, arch), }; TraitCollector trco = new TraitCollector(factory, store, dtb, prog); e = e.Accept(aen); e.Accept(eqb); e.Accept(trco); dtb.BuildEquivalenceClassDataTypes(); Verify("Typing/DtbSegmentedAccess.txt"); }
protected override void RunTest(Program program, string outputFile) { using (FileUnitTester fut = new FileUnitTester(outputFile)) { fut.TextWriter.WriteLine("// Before ///////"); DumpProgram(program, fut); SetupPreStages(program); aen.Transform(program); eqb.Build(program); #if OLD coll = new TraitCollector(factory, store, dtb, program); coll.CollectProgramTraits(program); #else var coll = new TypeCollector(program.TypeFactory, program.TypeStore, program); coll.CollectTypes(); #endif program.TypeStore.BuildEquivalenceClassDataTypes(program.TypeFactory); program.TypeStore.Dump(); tvr.ReplaceTypeVariables(); trans.Transform(); ctn.RenameAllTypes(program.TypeStore); ter = new TypedExpressionRewriter(program); try { ter.RewriteProgram(program); } catch (Exception ex) { fut.TextWriter.WriteLine("** Exception **"); fut.TextWriter.WriteLine(ex); } finally { fut.TextWriter.WriteLine("// After ///////"); DumpProgAndStore(program, fut); } } }
public void TrcoMemberPointer() { ProcedureBuilder m = new ProcedureBuilder(); Identifier ds = m.Local16("ds"); Identifier bx = m.Local16("bx"); Identifier ax = m.Local16("ax"); MemberPointerSelector mps = m.MembPtrW(ds, m.IAdd(bx, 4)); Expression e = m.Load(PrimitiveType.Byte, mps); coll = CreateCollector(); e = e.Accept(en); e.Accept(eqb); e.Accept(coll); Assert.IsNotNull(mps.BasePointer.TypeVariable, "Base pointer should have type variable"); Verify(null, "Typing/TrcoMemberPointer.txt"); }
protected override void RunTest(Program prog, string outFile) { coll = CreateCollector(prog); en.Transform(prog); eqb.Build(prog); coll.CollectProgramTraits(prog); using (FileUnitTester fut = new FileUnitTester(outFile)) { foreach (Procedure proc in prog.Procedures.Values) { proc.Write(false, fut.TextWriter); fut.TextWriter.WriteLine(); } handler.Traits.Write(fut.TextWriter); fut.AssertFilesEqual(); } }
public void TrcoGlobalArray() { Program prog = CreateProgram(); ProcedureBuilder m = new ProcedureBuilder(); Identifier i = m.Local32("i"); Expression ea = m.IAdd(prog.Globals, m.IAdd(m.Shl(i, 2), 0x3000)); Expression e = m.Load(PrimitiveType.Int32, ea); coll = CreateCollector(prog); e = e.Accept(en); e.Accept(eqb); e.Accept(coll); Verify(null, "Typing/TrcoGlobalArray.txt"); }
public void TrcoDbp() { ProcedureBuilder m = new ProcedureBuilder(); Identifier a = m.Local32("a"); Identifier b = m.LocalByte("b"); var s = m.Assign(a, m.Dpb(a, b, 0)); coll = CreateCollector(); s.Accept(eqb); s.Accept(coll); StringWriter sb = new StringWriter(); handler.Traits.Write(sb); Console.WriteLine(sb); string exp = "T_1 (in a : word32)" + nl + "\ttrait_primitive(word32)" + nl + "\ttrait_primitive(word32)" + nl + "\ttrait_primitive(word32)" + nl + "\ttrait_equal(T_3)" + nl + "T_2 (in b : byte)" + nl + "\ttrait_primitive(byte)" + nl + "T_3 (in DPB(a, b, 0) : word32)" + nl + "\ttrait_primitive(word32)" + nl; Assert.AreEqual(exp, sb.ToString()); }
public void TrcoUnsignedCompare() { ProcedureBuilder m = new ProcedureBuilder(); Identifier ds = m.Local16("ds"); Expression e = m.Uge(ds, m.Word16(0x0800)); coll = CreateCollector(); e.Accept(eqb); e.Accept(coll); StringWriter sb = new StringWriter(); handler.Traits.Write(sb); string exp = "T_1 (in ds : word16)" + nl + "\ttrait_primitive(word16)" + nl + "\ttrait_equal(T_2)" + nl + "\ttrait_primitive(cups16)" + nl + "T_2 (in 0x0800 : word16)" + nl + "\ttrait_primitive(word16)" + nl + "\ttrait_primitive(cups16)" + nl + "T_3 (in ds >=u 0x0800 : bool)" + nl + "\ttrait_primitive(bool)" + nl; Assert.AreEqual(exp, sb.ToString()); }
public void TrcoSegmentedDirectAddress() { Program prog = CreateProgram(); prog.TypeStore.EnsureExpressionTypeVariable(prog.TypeFactory, prog.Globals); ProcedureBuilder m = new ProcedureBuilder(); Identifier ds = m.Local16("ds"); Expression e = m.SegMem(PrimitiveType.Byte, ds, m.Int16(0x0200)); coll = CreateCollector(prog); e = e.Accept(en); e.Accept(eqb); e.Accept(coll); Verify(null, "Typing/TrcoSegmentedDirectAddress.txt"); }
public void DtbSegmentedDirectAddress() { ProcedureBuilder m = new ProcedureBuilder(); var arch = new Decompiler.Arch.X86.IntelArchitecture(Decompiler.Arch.X86.ProcessorMode.Real); var prog = new Program { Architecture = arch, Platform = new DefaultPlatform(null, arch) }; store.EnsureExpressionTypeVariable(factory, prog.Globals); Identifier ds = m.Local16("ds"); Expression e = m.SegMem(PrimitiveType.Byte, ds, m.Int16(0x0200)); TraitCollector coll = new TraitCollector(factory, store, dtb, prog); e = e.Accept(aen); e.Accept(eqb); e.Accept(coll); dtb.BuildEquivalenceClassDataTypes(); Verify("Typing/DtbSegmentedDirectAddress.txt"); }
public void TrcoInductionVariable() { Identifier i = new Identifier("i", PrimitiveType.Word32, null); MemoryAccess load = new MemoryAccess(MemoryIdentifier.GlobalMemory, i, PrimitiveType.Int32); Identifier i2 = new Identifier("i2", PrimitiveType.Word32, null); MemoryAccess ld2 = new MemoryAccess(MemoryIdentifier.GlobalMemory, i2, PrimitiveType.Int32); LinearInductionVariable iv = new LinearInductionVariable( Constant.Word32(0), Constant.Word32(1), Constant.Word32(10), false); LinearInductionVariable iv2 = new LinearInductionVariable( Constant.Word32(0x0010000), Constant.Word32(4), Constant.Word32(0x0010040), false); Program prog = CreateProgram(); prog.InductionVariables.Add(i, iv); prog.InductionVariables.Add(i2, iv2); coll = CreateCollector(prog); prog.Globals.Accept(eqb); load.Accept(eqb); ld2.Accept(eqb); prog.Globals.Accept(coll); load.Accept(coll); ld2.Accept(coll); Verify(null, "Typing/TrcoInductionVariable.txt"); }
public void DtbSegmentedAccess() { ProcedureBuilder m = new ProcedureBuilder(); Identifier ds = m.Local16("ds"); Identifier bx = m.Local16("bx"); Expression e = m.SegMem(bx.DataType, ds, m.IAdd(bx, 4)); var arch = new Decompiler.Arch.X86.IntelArchitecture(Decompiler.Arch.X86.ProcessorMode.Real); Program prog = new Program { Architecture = arch, Platform = new DefaultPlatform(null, arch), }; TraitCollector trco = new TraitCollector(factory, store, dtb, prog); e = e.Accept(aen); e.Accept(eqb); e.Accept(trco); dtb.BuildEquivalenceClassDataTypes(); Verify("Typing/DtbSegmentedAccess.txt"); }
public void DtbInductionVariables() { Identifier i = new Identifier("i", PrimitiveType.Word32, null); MemoryAccess load = new MemoryAccess(MemoryIdentifier.GlobalMemory, i, PrimitiveType.Int32); Identifier i2 = new Identifier("i2", PrimitiveType.Word32, null); MemoryAccess ld2 = new MemoryAccess(MemoryIdentifier.GlobalMemory, i2, PrimitiveType.Int32); LinearInductionVariable iv = new LinearInductionVariable( Constant.Word32(0), Constant.Word32(1), Constant.Word32(10), false); LinearInductionVariable iv2 = new LinearInductionVariable( Constant.Word32(0x0010000), Constant.Word32(4), Constant.Word32(0x0010040), false); prog.InductionVariables.Add(i, iv); prog.InductionVariables.Add(i2, iv2); prog.Platform = new DefaultPlatform(null, arch); TraitCollector trco = new TraitCollector(factory, store, dtb, prog); prog.Globals.Accept(eqb); load.Accept(eqb); ld2.Accept(eqb); prog.Globals.Accept(trco); load.Accept(trco); ld2.Accept(trco); dtb.BuildEquivalenceClassDataTypes(); Verify("Typing/DtbInductionVariables.txt"); }
public void TrcoArrayExpression() { var b = new Identifier("base", PrimitiveType.Word32, null); var i = new Identifier("idx", PrimitiveType.Word32, null); var s = Constant.Word32(4); ProcedureBuilder m = new ProcedureBuilder(); // e ::= Mem[(b+0x1003000)+(i*s):word16] Expression e = m.Load( PrimitiveType.Word16, m.IAdd(m.IAdd(b, Constant.Word32(0x10030000)), m.SMul(i, s))); coll = CreateCollector(); e = e.Accept(en); e.Accept(eqb); e.Accept(coll); Verify(null, "Typing/TrcoArrayExpression.txt"); }
public void TrcoSegMem() { ProcedureBuilder m = new ProcedureBuilder(); Identifier ds = m.Local16("ds"); Expression e = m.SegMemW(ds, m.Word16(0xC002U)); coll = CreateCollector(); e.Accept(eqb); e.Accept(coll); Verify(null, "Typing/TrcoSegMem.txt"); }
public void TrcoArrayAccess() { ProcedureBuilder m = new ProcedureBuilder(); Identifier ds = m.Local(PrimitiveType.SegmentSelector, "ds"); Identifier bx = m.Local16("bx"); Expression e = m.Array(PrimitiveType.Word32, m.Seq(ds, m.Word16(0x300)), m.IMul(bx, 8)); coll = CreateCollector(); e.Accept(eqb); e.Accept(coll); StringWriter sb = new StringWriter(); handler.Traits.Write(sb); string sExp = "T_1 (in ds : selector)" + nl + "\ttrait_primitive(selector)" + nl + "\ttrait_mem_array(300, 8, 0, T_7)" + nl + "T_2 (in 0x0300 : word16)" + nl + " trait_primitive(word16)" + nl + "T_3 (in SEQ(ds, 0x0300) : ptr32)" + nl + " trait_primitive(ptr32)" + nl + "T_4 (in bx : word16)" + nl + " trait_primitive(word16)" + nl + " trait_primitive(ui16)" + nl + "T_5 (in 0x0008 : word16)" + nl + " trait_primitive(word16)" + nl + " trait_primitive(ui16)" + nl + "T_6 (in bx * 0x0008 : word16)" + nl + " trait_primitive(ui16)" + nl + "T_7 (in SEQ(ds, 0x0300)[bx * 0x0008] : word32)" + nl + " trait_primitive(word32)" + nl; Assert.AreEqual(sExp, sb.ToString()); }
public void TrcoIcall() { ProcedureBuilder m = new ProcedureBuilder(); Identifier pfn = m.Local32("pfn"); Expression l = m.Load(PrimitiveType.Word32, pfn); CallInstruction icall = new CallInstruction(l, new CallSite(0, 0)); coll = CreateCollector(); icall.Accept(eqb); icall.Accept(coll); StringWriter sw = new StringWriter(); handler.Traits.Write(sw); string exp = "T_1 (in pfn : word32)" + nl + "\ttrait_primitive(word32)" + nl + "\ttrait_mem(T_2, 0)" + nl + "T_2 (in Mem0[pfn:word32] : word32)" + nl + "\ttrait_primitive((ptr code))" + nl + "\ttrait_primitive(word32)" + nl; Console.WriteLine(sw.ToString()); Assert.AreEqual(exp, sw.ToString()); }
public void TrcoMultiplication() { var prog = CreateProgram(); var m = new ProcedureBuilder(); var id = m.Local32("id"); var e = m.IMul(id, id); coll = CreateCollector(prog); e = e.Accept(en); e.Accept(eqb); e.Accept(coll); Verify(null, "Typing/TrcoMultiplication.txt"); }
public void DtbRepeatedLoads() { Identifier pfoo = new Identifier("pfoo", PrimitiveType.Word32, null); Identifier x = new Identifier("x", PrimitiveType.Word32, null); Assignment ass1 = new Assignment(x, MemLoad(pfoo, 4, PrimitiveType.Word32)); Assignment ass2 = new Assignment(x, MemLoad(pfoo, 4, PrimitiveType.Word32)); ass1.Accept(eqb); ass2.Accept(eqb); TraitCollector trco = new TraitCollector(factory, store, dtb, prog); trco.VisitAssignment(ass1); trco.VisitAssignment(ass2); dtb.BuildEquivalenceClassDataTypes(); Verify("Typing/DtbRepeatedLoads.txt"); }
public void TrcoSegmentedAccess() { ProcedureBuilder m = new ProcedureBuilder(); Identifier ds = m.Local16("ds"); Identifier bx = m.Local16("bx"); Identifier ax = m.Local16("ax"); Expression e = m.SegMem(PrimitiveType.Word16, ds, m.IAdd(bx, 4)); coll = CreateCollector(); e = e.Accept(en); e.Accept(eqb); e.Accept(coll); Verify(null, "Typing/TrcoSegmentedAccess.txt"); }
public void DtbSameMemFetch() { Identifier foo = new Identifier("foo", PrimitiveType.Word32, null); Identifier bar = new Identifier("bar", PrimitiveType.Word16, null); Identifier baz = new Identifier("baz", PrimitiveType.Word16, null); Assignment ass1 = new Assignment(bar, MemLoad(foo, 4, PrimitiveType.Word16)); Assignment ass2 = new Assignment(baz, MemLoad(foo, 4, PrimitiveType.Word16)); ass1.Accept(eqb); ass2.Accept(eqb); TraitCollector trco = new TraitCollector(factory, store, dtb, prog); trco.VisitAssignment(ass1); trco.VisitAssignment(ass2); dtb.BuildEquivalenceClassDataTypes(); Verify("Typing/DtbSameMemFetch.txt"); }