private BlockWorkitem CreateWorkItem(Address addr, ProcessorState state) { return new BlockWorkitem( scanner, prog, state, addr); }
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; }
public override SystemService FindService(int vector, ProcessorState state) { if (TypeLibs.Length == 0) return null; SystemService svc; this.TypeLibs[0].ServicesByVector.TryGetValue(vector&0xFFFF , out svc); return svc; }
public override SystemService FindService(int vector, ProcessorState state) { foreach (SystemService svc in realModeServices) { if (svc.SyscallInfo.Matches(vector, state)) return svc; } return null; }
public void Setup() { arch = new IntelArchitecture(ProcessorMode.Protected32); m = new ProcedureBuilder(); state = arch.CreateProcessorState(); expSimp = new ExpressionSimplifier( new IntelArchitecture(ProcessorMode.Protected32).CreateProcessorState()); SCZO = m.Frame.EnsureFlagGroup((uint)(FlagM.SF | FlagM.CF | FlagM.ZF | FlagM.OF), "SCZO", PrimitiveType.Byte); host = new BackwalkerHost(); }
public EntryPoint(Address addr, string name, ProcessorState state) { if (addr == null) throw new ArgumentNullException("addr"); if (state == null) throw new ArgumentNullException("state"); this.Address = addr; this.Name = name; this.ProcessorState = state; }
public List<Address> Build(Address addrTable, Address addrFrom, ProcessorState state) { bw = new Backwalker(this, null, null); if (bw == null) return null; List<BackwalkOperation> operations = bw.BackWalk(null); if (operations == null) return PostError("Unable to determine limit", addrFrom, addrTable); return BuildAux(bw, addrFrom, state); }
public override SystemService FindService(int vector, ProcessorState state) { EnsureTypeLibraries(); return this.typelibs .Where(t => t.ServicesByVector != null && t.ServicesByVector.Count > 0) .SelectMany(t => t.ServicesByVector) .Where(svc => svc.Value.SyscallInfo.Matches(vector, state)) .Select(svc => svc.Value) .FirstOrDefault(); }
protected Address ReadSegmentedCodeAddress(int byteSize, ImageReader rdr, ProcessorState state) { if (byteSize == PrimitiveType.Word16.Size) { return Address.SegPtr(state.GetRegister(Registers.cs).ToUInt16(), rdr.ReadLeUInt16()); } else { ushort off = rdr.ReadLeUInt16(); ushort seg = rdr.ReadLeUInt16(); return Address.SegPtr(seg, off); } }
public override SystemService FindService(RtlInstruction rtl, ProcessorState state) { if (!a6Pattern.Match(rtl)) return null; var reg = ((Identifier) a6Pattern.CapturedExpressions("addrReg")).Storage as RegisterStorage; var offset = ((Constant) a6Pattern.CapturedExpressions("offset")).ToInt32(); if (reg != Registers.a6) return null; if (funcs == null) funcs = LoadFuncs(); SystemService svc; return funcs.TryGetValue(offset, out svc) ? svc : null; }
public override SystemService FindService(int vector, ProcessorState state) { switch (vector) { // http://www.riscos.com/support/developers/prm/errors.html#89849 case 0x2B: return new SystemService { Name = "OS_GenerateError", Characteristics = new ProcedureCharacteristics { Terminates = true, }, Signature = new ProcedureSignature(null, new Identifier("r0", PrimitiveType.Pointer32, A32Registers.r0)) }; } throw new NotSupportedException(string.Format("Unknown RiscOS vector &{0:X}.", vector)); }
public List<Address> BuildAux(Backwalker bw, Address addrFrom, ProcessorState state) { int limit = 0; int[] permutation = null; foreach (BackwalkOperation op in bw.Operations) { BackwalkError err = op as BackwalkError; if (err != null) { return PostError(err.ErrorMessage, addrFrom, bw.VectorAddress); } var deref = op as BackwalkDereference; if (deref != null) { permutation = BuildMapping(deref, limit); } limit = op.Apply(limit); } if (limit == 0) return PostError("Unable to determine limit", addrFrom, bw.VectorAddress); return BuildTable(bw.VectorAddress, limit, permutation, bw.Stride, state); }
public override BlockWorkitem CreateBlockWorkItem(Address addrStart, Procedure proc, ProcessorState state) { Test_LastBlockWorkitem = base.CreateBlockWorkItem(addrStart, proc, state); return Test_LastBlockWorkitem; }
public abstract Address ReadCodeAddress(int byteSize, ImageReader rdr, ProcessorState state);
public IEnumerable<RtlInstructionCluster> CreateRewriter(ImageReader rdr, ProcessorState state, Frame frame, IRewriterHost host) { return new Pdp11Rewriter(this, new Pdp11Disassembler(rdr, this), frame); }
/// <summary> /// Performs a scan of the blocks that constitute a procedure named <paramref name="procedureName"/> /// </summary> /// <param name="addr">Address of the code from which we will start scanning.</param> /// <param name="procedureName"></param> /// <param name="state"></param> /// <returns></returns> public ProcedureBase ScanProcedure(Address addr, string procedureName, ProcessorState state) { TerminateAnyBlockAt(addr); var trampoline = GetTrampoline(addr); if (trampoline != null) return trampoline; var imp = GetImportedProcedure(addr, addr); if (imp != null) return imp; Procedure proc = EnsureProcedure(addr, procedureName); if (visitedProcs.Contains(proc)) return proc; visitedProcs.Add(proc); Debug.WriteLineIf(trace.TraceInfo, string.Format("Scanning procedure at {0}", addr)); //$REFACTOR: make the stack explicit? var oldQueue = queue; queue = new PriorityQueue<WorkItem>(); var st = state.Clone(); st.OnProcedureEntered(); var sp = proc.Frame.EnsureRegister(program.Architecture.StackRegister); st.SetValue(sp, proc.Frame.FramePointer); var block = EnqueueJumpTarget(addr, addr, proc, st); proc.ControlGraph.AddEdge(proc.EntryBlock, block); ProcessQueue(); queue = oldQueue; // Add <stackpointer> := fp explicitly to the starting block. proc.EntryBlock.Succ[0].Statements.Insert(0, addr.ToLinear(), new Assignment(sp, proc.Frame.FramePointer)); return proc; }
public Block EnqueueJumpTarget(Address addrSrc, Address addrDest, Procedure proc, ProcessorState state) { Procedure procDest; Block block = FindExactBlock(addrDest); if (block == null) { // Target wasn't a block before. Make sure it exists. block = FindContainingBlock(addrDest); if (block != null) { block = SplitBlock(block, addrDest); } else { block = AddBlock(addrDest, proc, GenerateBlockName(addrDest)); } if (proc == block.Procedure) { // Easy case: split a block in our own procedure. var wi = CreateBlockWorkItem(addrDest, proc, state); queue.Enqueue(PriorityJumpTarget, wi); } else if (IsBlockLinearProcedureExit(block)) { block = CloneBlockIntoOtherProcedure(block, proc); } else { // We just created a block in a foreign procedure. blocks.Remove(addrDest); block.Procedure.RemoveBlock(block); procDest = (Procedure) ScanProcedure(addrDest, null, state); var blockThunk = CreateCallRetThunk(addrSrc, proc, procDest); var wi = CreatePromoteWorkItem(addrDest, block, procDest); queue.Enqueue(PriorityBlockPromote, wi); block = blockThunk; } } else if (block.Procedure != proc) { // Jumped to a block with a different procedure than the current one. // Was the jump to the entry of an existing procedure? if (program.Procedures.TryGetValue(addrDest, out procDest)) { if (procDest == proc) { proc.Signature.StackDelta = block.Procedure.Signature.StackDelta; proc.Signature.FpuStackDelta = block.Procedure.Signature.FpuStackDelta; var wi = CreatePromoteWorkItem(addrDest, block, procDest); queue.Enqueue(PriorityBlockPromote, wi); } else { // We jumped to the entry of a different procedure. block = CreateCallRetThunk(addrSrc, proc, procDest); } } else { // Jumped into the middle of another procedure. Is it worth promoting the destination block // to a new procedure? if (IsBlockLinearProcedureExit(block)) { // No, just clone the block into the new procedure. block = CloneBlockIntoOtherProcedure(block, proc); } else { // We jumped into a pre-existing block of another procedure which was hairy enough // that we need to promote the block to a new procedure. procDest = EnsureProcedure(addrDest, null); var blockNew = CreateCallRetThunk(addrSrc, proc, procDest); procDest.ControlGraph.AddEdge(procDest.EntryBlock, block); var wi = CreatePromoteWorkItem(addrDest, block, procDest); queue.Enqueue(PriorityBlockPromote, wi); return blockNew; } } } return block; }
public EntryPoint(Address addr, ProcessorState state) : this(addr, null, state) { }
public ProcessorState(ProcessorState orig) { this.linearDerived = new Dictionary<RegisterStorage, Expression>(orig.linearDerived); this.stackState = new SortedList<int, Expression>(orig.stackState); this.ErrorListener = this.ErrorListener; }
public override SystemService FindService(int vector, ProcessorState state) { throw new NotImplementedException(); }
public override SystemService FindService(int vector, ProcessorState state) { if (int3svc.SyscallInfo.Matches(vector, state)) return int3svc; throw new NotImplementedException("INT services are not supported by " + this.GetType().Name); }
/// <summary> /// Creates a work item which will process code starting at the address /// <paramref name="addrStart"/>. The resulting block will belong to /// the procedure <paramref name="proc"/>. /// </summary> /// <param name="addrStart"></param> /// <param name="proc"></param> /// <param name="stateOnEntry"></param> /// <returns></returns> public virtual BlockWorkitem CreateBlockWorkItem( Address addrStart, Procedure proc, ProcessorState stateOnEntry) { return new BlockWorkitem( this, program, stateOnEntry, addrStart); }
public IEnumerable<RtlInstructionCluster> GetTrace(Address addrStart, ProcessorState state, Frame frame) { return program.Architecture.CreateRewriter( CreateReader(addrStart), state, frame, this); }
public IEnumerable<RtlInstructionCluster> CreateRewriter(ImageReader rdr, ProcessorState state, Frame frame, IRewriterHost host) { throw new NotImplementedException(); }
public void EnqueueVectorTable(Address addrFrom, Address addrTable, PrimitiveType elemSize, ushort segBase, bool calltable, Procedure proc, ProcessorState state) { ImageMapVectorTable table; if (vectors.TryGetValue(addrTable, out table)) return; table = new ImageMapVectorTable(addrTable, calltable); var wi = new VectorWorkItem(this, program, table, proc); wi.State = state.Clone(); wi.Stride = elemSize; wi.SegBase = segBase; wi.Table = table; wi.AddrFrom = addrFrom; imageMap.AddItem(addrTable, table); vectors[addrTable] = table; queue.Enqueue(PriorityVector, wi); }
public override Address ReadCodeAddress(int byteSize, ImageReader rdr, ProcessorState state) { return ReadSegmentedCodeAddress(byteSize, rdr, state); }
public IEnumerable<RtlInstructionCluster> CreateRewriter(ImageReader rdr, ProcessorState state, Frame frame, IRewriterHost host) { return new Z80Rewriter(this, rdr, state, frame, host); }
public override Address ReadCodeAddress(int byteSize, ImageReader rdr, ProcessorState state) { return Address.Ptr64(rdr.ReadLeUInt64()); }
public Address ReadCodeAddress(int size, ImageReader rdr, ProcessorState state) { throw new NotImplementedException(); }
private void BuildTest(IntelArchitecture arch, Address addr, Platform platform, Action<X86Assembler> m) { this.arch = new IntelArchitecture(ProcessorMode.Protected32); proc = new Procedure("test", arch.CreateFrame()); block = proc.AddBlock("testblock"); this.state = arch.CreateProcessorState(); var asm = new X86Assembler(arch, addr, new List<EntryPoint>()); scanner = repository.StrictMock<IScanner>(); m(asm); lr = asm.GetImage(); host = new RewriterHost(asm.ImportReferences, new Dictionary<string, ProcedureSignature> { { "GetDC", new ProcedureSignature( new Identifier("", new Pointer(VoidType.Instance, 4), new RegisterStorage("eax", 0, PrimitiveType.Word32)), new Identifier("arg", new TypeReference( "HWND", new Pointer(VoidType.Instance, 4)), new StackArgumentStorage(0, new TypeReference( "HWND", new Pointer(VoidType.Instance, 4))))) { StackDelta = 4, } } }); var rw = arch.CreateRewriter(lr.Image.CreateLeReader(addr), this.state, proc.Frame, host); var prog = new Program { Architecture = arch, Image = lr.Image, ImageMap = lr.ImageMap, Platform = platform, }; using (repository.Record()) { scanner.Stub(x => x.FindContainingBlock(Arg<Address>.Is.Anything)).Return(block); scanner.Stub(x => x.GetTrace(null, null, null)).IgnoreArguments().Return(rw); } wi = new BlockWorkitem(scanner, prog, state, addr); }