C# Address.ToLinear方法代码示例

        public void ApplySignatureToProcedure(Address addr, ProcedureSignature sig, Procedure proc)
        {
            proc.Signature = sig;

            int i = 0;
            var stmts = proc.EntryBlock.Succ[0].Statements;
            var linAddr = addr.ToLinear();
            foreach (var param in sig.Parameters)
            {
                var starg = param.Storage as StackArgumentStorage;
                if (starg != null)
                {
                    proc.Frame.EnsureStackArgument(
                        starg.StackOffset + sig.ReturnAddressOnStack,
                        param.DataType,
                        param.Name);
                }
                else
                {
                    var paramId = proc.Frame.EnsureIdentifier(param.Storage);
                    paramId.DataType = param.DataType;

                    // Need to take an extra step with parameters being passed
                    // in a register. It's perfectly possible for a user to 
                    // create a variable which they want to call 'r2' but which
                    // the calling convention of the machine wants to call 'r1'.
                    // To avoid this, we create a temporary identifier for 
                    // the formal parameter, and inject an copy statement in the
                    // entry block that moves the parameter value into the 
                    // register.
                    stmts.Insert(i, linAddr, NewMethod(param, paramId));
                    ++i;
                }
            }
        }

 /// <summary>
 /// Returns true if the specified address + length partially overlaps
 /// a relocation. 
 /// </summary>
 /// <returns></returns>
 public bool Overlaps(Address addr, uint length)
 {
     ulong linAddr = addr.ToLinear();
     ulong linAddrEnd = linAddr + length;
     ulong linReloc;
     if (map.TryGetLowerBoundKey(linAddr, out linReloc))
     {
         // |-reloc----|
         //      |-addr----|
         var linRelocEnd = linReloc + (uint)map[linReloc].DataType.Size;
         if (linReloc < linAddr && linAddr < linRelocEnd)
         {
             return true;
         }
     }
     if (map.TryGetUpperBoundKey(linAddr, out linReloc))
     {
         //     |-reloc----|
         // |-addr----|
         var linRelocEnd = linReloc + (uint)map[linReloc].DataType.Size;
         if (linReloc < linAddrEnd)
         {
             if (linAddrEnd < linRelocEnd)
                 return true;
         }
     }
     return false;
 }

 public bool IsInRange(Address addr)
 {
     return IsInRange(addr.ToLinear());
 }

 public void DumpData(LoadedImage image, Address address, long cbBytes, TextWriter stm)
 {
     ulong cSkip = address.ToLinear() & 0x0F;
     ImageReader rdr = arch.CreateImageReader(image, address);
     while (cbBytes > 0)
     {
         StringBuilder sb = new StringBuilder(0x12);
         try
         {
             stm.Write("{0} ", rdr.Address);
             for (int i = 0; i < 16; ++i)
             {
                 if (cbBytes > 0 && cSkip == 0)
                 {
                     byte b = rdr.ReadByte();
                     stm.Write("{0:X2} ", b);
                     sb.Append(0x20 <= b && b < 0x7F
                         ? (char) b
                         : '.');
                     --cbBytes;
                 }
                 else
                 {
                     stm.Write("   ");
                     if (cSkip > 0)
                         sb.Append(' ');
                     --cSkip;
                 }
             }
         }
         catch
         {
             stm.WriteLine();
             stm.WriteLine("...end of image");
             return;
         }
         stm.WriteLine(sb.ToString());
     }
 }

        /// <summary>
        /// Splits the given block at the specified address, yielding two blocks. The first block is the original block,
        /// now truncated, with a single out edge to the new block. The second block receives the out edges of the first block.
        /// </summary>
        /// <param name="block"></param>
        /// <param name="addr"></param>
        /// <returns>The newly created, empty second block</returns>
        public Block SplitBlock(Block blockToSplit, Address addr)
        {
            var graph = blockToSplit.Procedure.ControlGraph;
            var blockNew = AddBlock(addr, blockToSplit.Procedure, GenerateBlockName(addr));
            foreach (var succ in graph.Successors(blockToSplit))
            {
                graph.AddEdge(blockNew, succ);
            }
            foreach (var succ in graph.Successors(blockNew))
            {
                graph.RemoveEdge(blockToSplit, succ);
            }

            var linAddr = addr.ToLinear();
            var stmsToMove = blockToSplit.Statements.FindAll(s => s.LinearAddress >= linAddr).ToArray();
            if (blockToSplit.Statements.Count > 0 && blockToSplit.Statements.Last.LinearAddress >= linAddr)
            {
                graph.AddEdge(blockToSplit, blockNew);
                blockToSplit.Statements.RemoveAll(s => s.LinearAddress >= linAddr);
            }
            blockNew.Statements.AddRange(stmsToMove);
            foreach (var stm in stmsToMove)
            {
                stm.Block = blockNew;
            }
            blocks[blockStarts[blockToSplit]].End = linAddr;
            return blockNew;
        }

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

        /// <summary>
        /// Adds a new basic block to the procedure <paramref name="proc"/>.
        /// </summary>
        /// <param name="addr"></param>
        /// <param name="proc"></param>
        /// <param name="blockName"></param>
        /// <returns></returns>
        public Block AddBlock(Address addr, Procedure proc, string blockName)
        {
            Block b = new Block(proc, blockName) { Address = addr };
            blocks.Add(addr, new BlockRange(b, addr.ToLinear(), image.BaseAddress.ToLinear() + (uint)image.Bytes.Length));
            blockStarts.Add(b, addr);
            proc.ControlGraph.Blocks.Add(b);

            imageMap.AddItem(addr, new ImageMapBlock { Block = b }); 
            return b;
        }

 public void BwiX86_SetCallSignatureAdAddress(Address addrCallInstruction, FunctionType signature)
 {
     sigs.Add(addrCallInstruction.ToLinear(), signature);
 }

 public bool IsValidAddress(Address addr)
 {
     if (addr == null)
         return false;
     return IsValidLinearAddress(addr.ToLinear());
 }

        /// <summary>
        /// Creates a small basic block, consisting solely of a 'call' followed by a 'return'
        /// instruction. 
        /// </summary>
        /// <param name="addrFrom"></param>
        /// <param name="procOld"></param>
        /// <param name="procNew"></param>
        /// <returns></returns>
        public Block CreateCallRetThunk(Address addrFrom, Procedure procOld, Procedure procNew)
        {
            //$BUG: ReturnAddressOnStack property needs to be properly set, the
            // EvenOdd sample shows how this doesn't work currently. 
            var blockName = string.Format(
                "{0}_thunk_{1}", 
                Block.GenerateName(addrFrom),
                procNew.Name);
            var callRetThunkBlock = procOld.AddBlock(blockName);
            callRetThunkBlock.IsSynthesized = true;

            var linFrom = addrFrom.ToLinear();
            callRetThunkBlock.Statements.Add(
                addrFrom.ToLinear(), 
                new CallInstruction(
                    new ProcedureConstant(program.Platform.PointerType, procNew),
                    new CallSite(
                        procNew.Signature.ReturnAddressOnStack,
                        0)));
            program.CallGraph.AddEdge(callRetThunkBlock.Statements.Last, procNew);

            callRetThunkBlock.Statements.Add(linFrom, new ReturnInstruction());
            procOld.ControlGraph.AddEdge(callRetThunkBlock, procOld.ExitBlock);
            SetProcedureReturnAddressBytes(procOld, procNew.Frame.ReturnAddressSize, addrFrom);
            return callRetThunkBlock;
        }

        /// <summary>
        /// Adds a new basic block to the procedure <paramref name="proc"/>.
        /// </summary>
        /// <param name="addr"></param>
        /// <param name="proc"></param>
        /// <param name="blockName"></param>
        /// <returns></returns>
        public Block AddBlock(Address addr, Procedure proc, string blockName)
        {
            Block b = new Block(proc, blockName) { Address = addr };
            var lastMem = segmentMap.Segments.Values.Last().MemoryArea;
            blocks.Add(addr, new BlockRange(b, addr.ToLinear(), lastMem.BaseAddress.ToLinear() + (uint)lastMem.Length));
            blockStarts.Add(b, addr);
            proc.ControlGraph.Blocks.Add(b);

            imageMap.AddItem(addr, new ImageMapBlock { Block = b }); 
            return b;
        }

		private Address RoundToNearestRow(Address addr)
		{
			ulong rows = addr.ToLinear() / cbRow;
			return imageMap.MapLinearAddressToAddress(rows * cbRow);
		}

 private bool IsAddressInSelection(Address addr)
 {
     if (addr == null || addrAnchor == null || addrSelected == null)
         return false;
     var linAddr = addr.ToLinear();
     var linAnch = addrAnchor.ToLinear();
     var linSel = addrSelected.ToLinear();
     if (linAnch <= linSel)
     {
         return linAnch <= linAddr && linAddr <= linSel;
     }
     else 
     {
         return linSel <= linAddr && linAddr <= linAnch;
     }
 }

        private void ApplySignatureToProcedure(Address addr, ProcedureSignature sig, Procedure proc)
        {
            proc.Signature = sig;

            int i = 0;
            var stmts = proc.EntryBlock.Succ[0].Statements;
            var linAddr = addr.ToLinear();
            foreach (var param in sig.Parameters)
            {
                Identifier dst;
                var starg = param.Storage as StackArgumentStorage;
                if (starg != null)
                {
                    dst = proc.Frame.EnsureStackArgument(
                        starg.StackOffset + sig.ReturnAddressOnStack,
                        param.DataType);
                }
                else
                {
                    dst = proc.Frame.EnsureIdentifier(param.Storage);
                }
                stmts.Insert(i, linAddr, new Assignment(dst, param));
                ++i;
            }
        }

 public override void InjectProcedureEntryStatements(Procedure proc, Address addr, CodeEmitter m)
 {
     switch (Architecture.Name)
     {
     case "mips-be-32":
         // MIPS ELF ABI: r25 is _always_ set to the address of a procedure on entry.
         m.Assign(proc.Frame.EnsureRegister(Architecture.GetRegister(25)), Constant.Word32((uint)addr.ToLinear()));
         break;
     }
 }