public void Setup() { f = new Frame(PrimitiveType.Word16); argOff = f.EnsureStackArgument(4, PrimitiveType.Word16); argSeg = f.EnsureStackArgument(6, PrimitiveType.SegmentSelector); arg_alias = f.EnsureStackArgument(4, PrimitiveType.Pointer32); }
public void W32Mips_Trampoline() { var instrs = new List<RtlInstructionCluster>(); var frame = new Frame(PrimitiveType.Pointer32); var r9 = frame.EnsureRegister(new RegisterStorage("r9", 9, PrimitiveType.Word32)); var rtl = new RtlTrace(0x123460) { m => m.Assign(r9, 0x00030000), m => m.Assign(r9, m.LoadDw(m.IAdd(r9, 0x1234))), m => m.Goto(r9) }; var host = mr.Stub<IRewriterHost>(); var services = mr.Stub<IServiceProvider>(); var arch = mr.Stub<IProcessorArchitecture>(); var state = mr.Stub<ProcessorState>(); var addr = Address.Ptr32(0x00031234); arch.Stub(a => a.CreateFrame()).Return(frame); arch.Stub(a => a.CreateProcessorState()).Return(state); arch.Stub(a => a.CreateRewriter(null, null, null, null)).IgnoreArguments().Return(rtl); arch.Stub(a => a.MakeAddressFromConstant(Arg<Constant>.Is.NotNull)).Return(addr); host.Stub(h => h.GetImportedProcedure( Arg<Address>.Is.Equal(addr), Arg<Address>.Is.NotNull)).Return(new ExternalProcedure("foo", new ProcedureSignature())); mr.ReplayAll(); var platform = new Win32MipsPlatform(services, arch); var result = platform.GetTrampolineDestination(new LeImageReader(new byte[0]), host); Assert.IsNotNull(result); }
public void Setup() { var arch = new IntelArchitecture(ProcessorMode.Protected32); f = arch.CreateFrame(); liveness = new IdentifierLiveness(arch); isLiveHelper = new RegisterLiveness.IsLiveHelper(arch); }
public void Setup() { var arch = new X86ArchitectureFlat32(); f = arch.CreateFrame(); liveness = new IdentifierLiveness(arch); isLiveHelper = new RegisterLiveness.IsLiveHelper(arch); }
private BlockFlow CreateBlockFlow(Block block, Frame frame) { return new BlockFlow( block, prog.Architecture.CreateRegisterBitset(), new SymbolicEvaluationContext(prog.Architecture, frame)); }
public override FunctionType Deserialize(SerializedSignature ss, Frame frame) { if (ss == null) return new FunctionType(); if (ss == null) return null; var argser = new ArgumentDeserializer(this, Architecture, frame, 0, Architecture.WordWidth.Size); Identifier ret = null; if (ss.ReturnValue != null) { ret = argser.DeserializeReturnValue(ss.ReturnValue); } var args = new List<Identifier>(); this.gr = 0; if (ss.Arguments != null) { for (int iArg = 0; iArg < ss.Arguments.Length; ++iArg) { var sArg = ss.Arguments[iArg]; Identifier arg = DeserializeArgument(argser, sArg); args.Add(arg); } } var sig = new FunctionType(ret, args.ToArray()); return sig; }
private BlockFlow CreateBlockFlow(Block block, Frame frame) { return new BlockFlow( block, new HashSet<RegisterStorage>(), new SymbolicEvaluationContext(program.Architecture, frame)); }
public RtlStatementStream(uint address, Frame frame) { this.linAddress = address; this.arch = new FakeArchitecture(); this.frame = frame; this.stms = new List<RtlInstructionCluster>(); }
public void Setup() { this.mr = new MockRepository(); this.fsSvc = mr.StrictMock<IFileSystemService>(); this.tllSvc = mr.Stub<ITypeLibraryLoaderService>(); this.services = mr.StrictMock<IServiceProvider>(); var cfgSvc = mr.Stub<IConfigurationService>(); var env = mr.Stub<OperatingEnvironment>(); this.arch = new M68kArchitecture(); this.rtls = new List<RtlInstruction>(); this.m = new RtlEmitter(rtls); cfgSvc.Stub(c => c.GetEnvironment("amigaOS")).Return(env); env.Stub(e => e.TypeLibraries).Return(new List<ITypeLibraryElement>()); env.Stub(e => e.CharacteristicsLibraries).Return(new List<ITypeLibraryElement>()); env.Stub(e => e.Options).Return(new Dictionary<string, object> { { "versionDependentLibraries", new Dictionary<string,object> { { "33", new List<object> { "exec_v33", "dos_v33" } }, { "34", new List<object> { "exec_v34", "dos_v34" } }, } } }); this.services.Stub(s => s.GetService(typeof(IConfigurationService))).Return(cfgSvc); this.services.Stub(s => s.GetService(typeof(IFileSystemService))).Return(fsSvc); this.services.Stub(s => s.GetService(typeof(ITypeLibraryLoaderService))).Return(tllSvc); this.frame = new Frame(arch.FramePointerType); }
public override ProcedureSignature Deserialize(SerializedSignature ss, Frame frame) { if (ss == null) return null; this.argser = new ArgumentSerializer(this, Architecture, frame, ss.Convention); Identifier ret = null; int fpuDelta = FpuStackOffset; FpuStackOffset = 0; if (ss.ReturnValue != null) { ret = argser.DeserializeReturnValue(ss.ReturnValue); fpuDelta += FpuStackOffset; } FpuStackOffset = 0; var args = new List<Identifier>(); if (ss.Arguments != null) { for (int iArg = 0; iArg < ss.Arguments.Length; ++iArg) { var sArg = ss.Arguments[iArg]; var arg = DeserializeArgument(sArg, iArg, ss.Convention); args.Add(arg); } fpuDelta -= FpuStackOffset; } FpuStackOffset = fpuDelta; var sig = new ProcedureSignature(ret, args.ToArray()); ApplyConvention(ss, sig); return sig; }
public override ProcedureSignature Deserialize(SerializedSignature ss, Frame frame) { if (ss == null) return null; var argser = new ArgumentSerializer(this, Architecture, frame, ss.Convention); Identifier ret = null; if (ss.ReturnValue != null) { ret = argser.DeserializeReturnValue(ss.ReturnValue); } var args = new List<Identifier>(); if (ss.Arguments != null) { for (int iArg = 0; iArg < ss.Arguments.Length; ++iArg) { var sArg = ss.Arguments[iArg]; Identifier arg = argser.Deserialize(sArg); args.Add(arg); } } var sig = new ProcedureSignature(ret, args.ToArray()); return sig; }
public OperandRewriter(IntelArchitecture arch, ExpressionEmitter emitter, Frame frame, IRewriterHost host) { this.arch = arch; this.m = emitter; this.frame = frame; this.host = host; }
public OperandRewriter(M68kArchitecture arch, RtlEmitter emitter, Frame frame, PrimitiveType dataWidth) { this.arch = arch; this.m = emitter; this.frame = frame; this.DataWidth = dataWidth; }
protected override IEnumerable<RtlInstructionCluster> GetInstructionStream(Frame frame, IRewriterHost host) { return arch.CreateRewriter( new LeImageReader(image, 0), arch.CreateProcessorState(), frame, this.host); }
public void Setup() { arch = new IntelArchitecture(ProcessorMode.Real); f = new Frame(PrimitiveType.Word16); argOff = f.EnsureStackArgument(4, PrimitiveType.Word16); argSeg = f.EnsureStackArgument(6, PrimitiveType.SegmentSelector); arg_alias = f.EnsureStackArgument(4, PrimitiveType.Pointer32); }
public void EnsureOutRegister() { Frame f = new Frame(PrimitiveType.Word32); Identifier r = f.EnsureRegister(new Mocks.MockMachineRegister("r1", 1, PrimitiveType.Word32)); Identifier arg = f.EnsureOutArgument(r, PrimitiveType.Pointer32); Assert.AreEqual("r1Out", arg.Name); Assert.AreSame(PrimitiveType.Pointer32, arg.DataType); }
public void RegisterTest() { Frame f = new Frame(PrimitiveType.Word16); Identifier id0 = f.EnsureRegister(Registers.ax); Identifier id1 = f.EnsureRegister(Registers.bx); Identifier id2 = f.EnsureRegister(Registers.ax); Assert.AreEqual(id0, id2); }
public override IEnumerable<RtlInstructionCluster> CreateRewriter(ImageReader rdr, ProcessorState state, Frame frame, IRewriterHost host) { return new MipsRewriter( this, new MipsDisassembler(this, rdr, IsVersion6OrLater), frame, host); }
public IEnumerable<RtlInstructionCluster> CreateRewriter(ImageReader rdr, ProcessorState state, Frame frame, IRewriterHost host) { var linAddr = rdr.Address.ToLinear(); RtlTrace trace; if (!rewriters.Traces.TryGetValue(rdr.Address, out trace)) NUnit.Framework.Assert.Fail(string.Format("Unexpected request for a rewriter at address {0}", rdr.Address)); return trace; }
private void CreateSymbolicEvaluator(Frame frame) { ctx = new SymbolicEvaluationContext(arch, frame); se = new SymbolicEvaluator(ctx); if (esp == null) esp = Tmp32("esp"); ctx.SetValue(esp, frame.FramePointer); }
protected override IEnumerable<RtlInstructionCluster> GetInstructionStream(Frame frame, IRewriterHost host) { return new X86Rewriter( arch, host, new X86State(arch), asmResult.SegmentMap.Segments.Values.First().MemoryArea.CreateLeReader(0), frame); }
public override FunctionType Deserialize(SerializedSignature ss, Frame frame) { int ncrn = 0; int nsaa = 0; // mem arg forb ret val var argser = new ArgumentDeserializer( this, Architecture, frame, Architecture.PointerType.Size, Architecture.WordWidth.Size); Identifier ret = null; if (ss.ReturnValue != null) { ret = argser.DeserializeReturnValue(ss.ReturnValue); } var args = new List<Identifier>(); if (ss.Arguments != null) { foreach (var sArg in ss.Arguments) { var dt = sArg.Type.Accept(TypeLoader); var sizeInWords = (dt.Size + 3) / 4; if (sizeInWords == 2 && (ncrn & 1) == 1) ++ncrn; Identifier arg; if (sizeInWords <= 4 - ncrn) { if (sizeInWords == 2) { arg = frame.EnsureSequence( Architecture.GetRegister(argRegs[ncrn]), Architecture.GetRegister(argRegs[ncrn + 1]), dt); ncrn += 2; } else { arg = frame.EnsureRegister( Architecture.GetRegister(argRegs[ncrn])); ncrn += 1; } } else { arg = frame.EnsureStackArgument(nsaa, dt); nsaa += AlignedStackArgumentSize(dt); } args.Add(arg); } } return new FunctionType(ret, args.ToArray()); }
public override FunctionType Deserialize(SerializedSignature ss, Frame frame) { if (ss == null) return null; this.argDeser = new ArgumentDeserializer( this, Architecture, frame, Architecture.PointerType.Size, //$BUG: x86 real mode? Architecture.WordWidth.Size); Identifier ret = null; int fpuDelta = FpuStackOffset; FpuStackOffset = 0; if (ss.ReturnValue != null) { ret = argDeser.DeserializeReturnValue(ss.ReturnValue); fpuDelta += FpuStackOffset; } FpuStackOffset = 0; var args = new List<Identifier>(); if (ss.EnclosingType != null) { var arg = DeserializeImplicitThisArgument(ss); args.Add(arg); } if (ss.Arguments != null) { if (ss.Convention == "pascal") { for (int iArg = ss.Arguments.Length -1; iArg >= 0; --iArg) { var sArg = ss.Arguments[iArg]; var arg = DeserializeArgument(sArg, iArg, ss.Convention); args.Add(arg); } args.Reverse(); } else { for (int iArg = 0; iArg < ss.Arguments.Length; ++iArg) { var sArg = ss.Arguments[iArg]; var arg = DeserializeArgument(sArg, iArg, ss.Convention); args.Add(arg); } } fpuDelta -= FpuStackOffset; } FpuStackOffset = fpuDelta; var sig = new FunctionType(ret, args.ToArray()); sig.IsInstanceMetod = ss.IsInstanceMethod; ApplyConvention(ss, sig); return sig; }
protected override IEnumerable<RtlInstructionCluster> GetInstructionStream(Frame frame, IRewriterHost host) { var addr = Address.Ptr16(10); var image = new LoadedImage(addr, new byte[1]); return arch.CreateRewriter( arch.CreateImageReader(image, addr), arch.CreateProcessorState(), frame, host); }
public void Setup() { this.mr = new MockRepository(); this.fsSvc = mr.StrictMock<IFileSystemService>(); this.services = mr.StrictMock<IServiceProvider>(); this.arch = new M68kArchitecture(); this.rtls = new List<RtlInstruction>(); this.m = new RtlEmitter(rtls); this.services.Stub(s => s.GetService(typeof(IFileSystemService))).Return(fsSvc); this.frame = new Frame(arch.FramePointerType); }
private BlockFlow CreateBlockFlow(Block block, Frame frame) { var bflow = new BlockFlow( block, prog.Architecture.CreateRegisterBitset(), new SymbolicEvaluationContext( prog.Architecture, frame)); flow[block] = bflow; return bflow; }
public void FrGrfTest() { IntelArchitecture arch = new IntelArchitecture(ProcessorMode.Real); Frame f = new Frame(PrimitiveType.Word16); uint iSz = (uint) (FlagM.ZF|FlagM.SF); Identifier grfSz = f.EnsureFlagGroup(Registers.eflags, iSz, arch.GrfToString(iSz), PrimitiveType.Byte); using (FileUnitTester fut = new FileUnitTester("Core/FrGrfTest.txt")) { f.Write(fut.TextWriter); fut.AssertFilesEqual(); } }
public VarargsFormatScanner( Program program, Frame frame, EvaluationContext ctx, IServiceProvider services) { this.program = program; this.arch = program.Architecture; this.frame = frame; this.eval = new ExpressionSimplifier(ctx); this.services = services; }
public ApplicationBuilderTests() { arch = new IntelArchitecture(ProcessorMode.Protected32); frame = arch.CreateFrame(); ret = frame.EnsureRegister(Registers.eax); arg04 = new Identifier("arg04", PrimitiveType.Word32, new StackArgumentStorage(4, PrimitiveType.Word32)); arg08 = new Identifier("arg08", PrimitiveType.Word16, new StackArgumentStorage(8, PrimitiveType.Word16)); arg0C = new Identifier("arg0C", PrimitiveType.Byte, new StackArgumentStorage(0x0C, PrimitiveType.Byte)); regOut = new Identifier("edxOut", PrimitiveType.Word32, new OutArgumentStorage(frame.EnsureRegister(Registers.edx))); sig = new ProcedureSignature(ret, new Identifier[] { arg04, arg08, arg0C, regOut }); }
public void Setup() { m = new ProcedureBuilder(arch); frame = m.Frame; ax = frame.EnsureRegister(new RegisterStorage("ax", 0, 0, PrimitiveType.Word16)); bx = frame.EnsureRegister(new RegisterStorage("bx", 3, 0, PrimitiveType.Word16)); cx = frame.EnsureRegister(new RegisterStorage("cx", 1, 0, PrimitiveType.Word16)); dx = frame.EnsureRegister(new RegisterStorage("dx", 2, 0, PrimitiveType.Word16)); flags = new FlagRegister("flags", PrimitiveType.Word16); SCZ = frame.EnsureFlagGroup(flags, 7, "SCZ", PrimitiveType.Byte); CF = frame.EnsureFlagGroup(flags, arch.CarryFlagMask, "C", PrimitiveType.Bool); rw = new LongAddRewriter(m.Procedure, arch); }