Package ghidra.program.util

Class SymbolicPropogator

  • public class SymbolicPropogator
extends java.lang.Object

    • Field Detail

      • memorySpaces NEW

        protected java.util.List<AddressSpace> memorySpaces

      • program NEW

        protected Program program

      • savedProgramContext NEW

        protected ProgramContext savedProgramContext

      • canceled NEW

        protected boolean canceled

      • readExecutableAddress NEW

        protected boolean readExecutableAddress

      • conflict NEW

        protected boolean conflict

      • hitCodeFlow NEW

        protected boolean hitCodeFlow

      • debug NEW

        protected boolean debug

      • MAX_EXACT_INSTRUCTIONS NEW

        protected static final int MAX_EXACT_INSTRUCTIONS
        See Also:
        Constant Field Values

      • lastFullHashCode NEW

        protected int lastFullHashCode

      • lastInstrCode NEW

        protected int lastInstrCode

      • sameInstrCount NEW

        protected int sameInstrCount

Constructor Detail

  • Method Detail

    • setDebug

      public void setDebug​(boolean debug)

    • flowConstants

      public AddressSet flowConstants​(Address startAddr,
                                AddressSetView restrictSet,
                                ContextEvaluator eval,
                                boolean saveContext,
                                TaskMonitor monitor)
                         throws CancelledException
      Process a subroutine using the processor function. The process function can control what flows are followed and when to stop.
      Parameters:
      entryPoint - start address
      processor - processor to use
      Returns:
      the address set of instructions that were followed
      Throws:
      CancelledException

    • saveOffCurrentContext NEW

      protected VarnodeContext saveOffCurrentContext​(Address startAddr)
      Save off the current context and set the current context to a copy This is done so that the values in the context are not changed, but can be used for computation.
      Parameters:
      startAddr -
      Returns:

    • getRegisterValue

      public SymbolicPropogator.Value getRegisterValue​(Address toAddr,
                                                 Register reg)
      Get constant or register relative value assigned to the specified register at the specified address
      Parameters:
      addr - address
      reg - register
      Returns:
      register value

    • getRegisterValueRepresentation

      public java.lang.String getRegisterValueRepresentation​(Address addr,
                                                       Register reg)
      Do not depend on this method! For display debugging purposes only. This will change.
      Parameters:
      addr -
      reg -
      Returns:

    • setRegister

      public void setRegister​(Address addr,
                        Register stackReg)

    • makeReference

      public void makeReference​(VarnodeContext varnodeContext,
                          Instruction instruction,
                          int pcodeop,
                          int opIndex,
                          Varnode vt,
                          RefType refType,
                          TaskMonitor monitor)
      Make from the instruction to the reference based on the varnode passed in.
      Parameters:
      varnodeContext - - context to use for any other infomation needed
      instruction - - instruction to place the reference on.
      pcodeop - - pcode op that caused the reference
      opIndex - - operand it should be placed on, or -1 if unknown
      vt - - place to reference, could be a full address, or just a constant
      refType - - type of reference
      monitor -

    • makeReference

      public void makeReference​(VarnodeContext vContext,
                          Instruction instruction,
                          int opIndex,
                          long knownSpaceID,
                          long wordOffset,
                          int size,
                          RefType refType,
                          int pcodeop,
                          boolean knownReference,
                          TaskMonitor monitor)
      Make a reference from the instruction to the address based on the spaceID,offset passed in. This could make a reference into an overlay (overriding the spaceID), or into memory, if spaceID is a constant space. The target could be an external Address carried along and then finally used. External addresses are OK as long as nothing is done to the offset.
      Parameters:
      varnodeContext - - context to use for any other infomation needed
      instruction - - instruction to place the reference on.
      opIndex - - operand it should be placed on, or -1 if unknown
      spaceID - target space ID or -1 if only offset is known
      wordOffset - - target offset that is word addressing based
      refType - - type of reference
      pcodeop - - pcode op that caused the reference
      monitor -

    • encounteredBranch

      public boolean encounteredBranch()
      Returns:
      true if any branching instructions have been encountered

    • readExecutable

      public boolean readExecutable()
      Returns:
      return true if the code ever read from an executable location

    • setParamRefCheck

      public void setParamRefCheck​(boolean checkParamRefsOption)
      enable/disable checking parameters for constant references
      Parameters:
      checkParamRefsOption - true to enable

    • setReturnRefCheck

      public void setReturnRefCheck​(boolean checkReturnRefsOption)
      enable/disable checking return for constant references
      Parameters:
      checkReturnRefsOption -

    • setStoredRefCheck

      public void setStoredRefCheck​(boolean checkStoredRefsOption)
      enable/disable checking stored values for constant references
      Parameters:
      checkStoredRefsOption -