C# Core.ProcessorState类代码示例

 public StartupFinder(IServiceProvider services, Program program, Address addrStart)
 {
     this.services = services;
     this.prog= program;
     this.start = addrStart;
     this.state = program.Architecture.CreateProcessorState();
 }

        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 == 1 || bw.Stride == 0) && bw.JumpSize > 1 
                    ? bw.JumpSize 
                    : bw.Stride,
                state);
        }

 private BlockWorkitem CreateWorkItem(Address addr, ProcessorState state)
 {
     return new BlockWorkitem(
         scanner, 
         program,
         state,
         addr);
 }

 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 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;
 }

		public override SystemService FindService(int vector, ProcessorState state)
		{
			foreach (SystemService svc in realModeServices)
			{
				if (svc.SyscallInfo.Matches(vector, state))
					return svc;
			}
			return null;
		}

 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();
 }

		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 override SystemService FindService(int vector, ProcessorState state)
		{
            EnsureTypeLibraries(PlatformIdentifier);
			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 override SystemService FindService(int vector, ProcessorState state)
 {
     base.EnsureTypeLibraries(base.PlatformIdentifier);
     foreach (var module in this.Metadata.Modules.Values)
     {
         SystemService svc;
         if (module.ServicesByVector.TryGetValue(vector & 0xFFFF, out svc))
             return svc;
     }
     return null;
 }

 private bool Matches(ProcessorState state)
 {
     for (int i = 0; i < RegisterValues.Length; ++i)
     {
         Constant v = state.GetRegister(RegisterValues[i].Register);
         if (v == null || v == Constant.Invalid)
             return false;
         if (v.ToUInt32() != RegisterValues[i].Value)
             return false;
     }
     return true;
 }

 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);
     }
 }