private BlockFlow CreateBlockFlow(Block block, Frame frame) { return new BlockFlow( block, prog.Architecture.CreateRegisterBitset(), new SymbolicEvaluationContext(prog.Architecture, frame)); }
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 RtlStatementStream(uint address, Frame frame) { this.linAddress = address; this.arch = new FakeArchitecture(); this.frame = frame; this.stms = new List<RtlInstructionCluster>(); }
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>(); this.fr = 1; this.gr = 3; 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 ProcedureSignature(ret, args.ToArray()); return sig; }
public OperandRewriter(M68kArchitecture arch, RtlEmitter emitter, Frame frame, PrimitiveType dataWidth) { this.arch = arch; this.m = emitter; this.frame = frame; this.DataWidth = dataWidth; }
public void Setup() { var arch = new IntelArchitecture(ProcessorMode.Protected32); f = arch.CreateFrame(); liveness = new IdentifierLiveness(arch); isLiveHelper = new RegisterLiveness.IsLiveHelper(); }
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); }
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); }
protected override IEnumerable<RtlInstructionCluster> GetInstructionStream(Frame frame, IRewriterHost host) { return arch.CreateRewriter( new LeImageReader(image, 0), arch.CreateProcessorState(), frame, this.host); }
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); }
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(iSz, arch.GrfToString(iSz), PrimitiveType.Byte); using (FileUnitTester fut = new FileUnitTester("Core/FrGrfTest.txt")) { f.Write(fut.TextWriter); fut.AssertFilesEqual(); } }
public void Setup() { prog = new Program(); prog.Architecture = new IntelArchitecture(ProcessorMode.Protected32); prog.Platform = new DefaultPlatform(null, prog.Architecture); m = new ProcedureBuilder(); proc = m.Procedure; f = proc.Frame; mpprocflow = new ProgramDataFlow(); terminates = new HashSet<Procedure>(); rl = new RegisterLiveness(prog, mpprocflow, null); rl.Procedure = proc; rl.IdentifierLiveness.BitSet = prog.Architecture.CreateRegisterBitset(); }
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 SequenceTest() { IntelArchitecture arch = new IntelArchitecture(ProcessorMode.Real); Frame f = new Frame(PrimitiveType.Word16); Identifier ax = f.EnsureRegister(Registers.ax); Identifier dx = f.EnsureRegister(Registers.dx); Identifier dxax = f.EnsureSequence(dx, ax, PrimitiveType.Word32); using (FileUnitTester fut = new FileUnitTester("Core/SequenceTest.txt")) { f.Write(fut.TextWriter); fut.AssertFilesEqual(); } Identifier dxax2 = f.EnsureSequence(dx,ax, PrimitiveType.Word32); Assert.IsTrue(dxax2 == dxax); }
public IEnumerable<RtlInstructionCluster> CreateRewriter(ImageReader rdr, ProcessorState state, Frame frame, IRewriterHost host) { return new Z80Rewriter(this, rdr, state, frame, host); }
public IEnumerable<RtlInstructionCluster> GetTrace(Address addrStart, ProcessorState state, Frame frame) { return program.Architecture.CreateRewriter( CreateReader(addrStart), state, frame, this); }
public OperandRewriter(IntelArchitecture arch, Frame frame, IRewriterHost host) { this.arch = arch; this.frame = frame; this.host = host; }
public OperandRewriter64(IntelArchitecture arch, Frame frame, IRewriterHost host) : base(arch, frame, host) { }
public abstract OperandRewriter CreateOperandRewriter(IntelArchitecture arch, Frame frame, IRewriterHost host);
public override OperandRewriter CreateOperandRewriter(IntelArchitecture arch, Frame frame, IRewriterHost host) { return new OperandRewriter64(arch, frame, host); }
public override Expression CreateStackAccess(Frame frame, int offset, DataType dataType) { var rsp = frame.EnsureRegister(Registers.rsp); return MemoryAccess.Create(rsp, offset, dataType); }
public void Setup() { m = new ProcedureBuilder(arch); frame = m.Frame; ax = frame.EnsureRegister(new RegisterStorage("ax", 0, PrimitiveType.Word16)); bx = frame.EnsureRegister(new RegisterStorage("bx", 3, PrimitiveType.Word16)); cx = frame.EnsureRegister(new RegisterStorage("cx", 1, PrimitiveType.Word16)); dx = frame.EnsureRegister(new RegisterStorage("dx", 2, PrimitiveType.Word16)); SCZ = frame.EnsureFlagGroup(7, "SCZ", PrimitiveType.Byte); CF = frame.EnsureFlagGroup(arch.CarryFlagMask, "C", PrimitiveType.Bool); rw = new LongAddRewriter(m.Procedure, arch); Procedure proc = new Procedure("test", frame); block = new Block(proc, "bloke"); }
public void FrLocals() { Frame f = new Frame(PrimitiveType.Word16); f.EnsureStackLocal(2, PrimitiveType.Word16); f.EnsureStackLocal(4, PrimitiveType.Word32); using (FileUnitTester fut = new FileUnitTester("Core/FrLocals.txt")) { f.Write(fut.TextWriter); fut.AssertFilesEqual(); } Assert.IsNotNull((StackLocalStorage) f.Identifiers[2].Storage); }
public void FrEnsureRegister() { Frame f = new Frame(PrimitiveType.Word32); f.EnsureRegister(new Mocks.MockMachineRegister("eax", 0, PrimitiveType.Word32)); Assert.AreEqual("eax", f.Identifiers[2].Name); Assert.AreSame(PrimitiveType.Word32, f.Identifiers[2].DataType); }
public Expression CreateStackAccess(Frame frame, int cbOffset, DataType dataType) { throw new NotImplementedException(); }
public virtual Expression CreateStackAccess(Frame frame, int offset, DataType dataType) { var sp = frame.EnsureRegister(Registers.sp); var ss = frame.EnsureRegister(Registers.ss); return SegmentedAccess.Create(ss, sp, offset, dataType); }
public IEnumerable<RtlInstructionCluster> CreateRewriter(ImageReader rdr, ProcessorState state, Frame frame, IRewriterHost host) { return new Pdp11Rewriter(this, new Pdp11Disassembler(rdr, this), frame); }
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); }