Class SymbolicPropogator


  • public class SymbolicPropogator
    extends java.lang.Object
    • Field Detail

      • memorySpaces

        protected java.util.List<AddressSpace> memorySpaces
      • program

        protected Program program
      • canceled

        protected boolean canceled
      • readExecutableAddress

        protected boolean readExecutableAddress
      • hitCodeFlow

        protected boolean hitCodeFlow
      • debug

        protected boolean debug
      • MAX_EXACT_INSTRUCTIONS

        protected static final int MAX_EXACT_INSTRUCTIONS
        See Also:
        Constant Field Values
      • lastFullHashCode

        protected int lastFullHashCode
      • lastInstrCode

        protected int lastInstrCode
      • sameInstrCount

        protected int sameInstrCount
    • Constructor Detail

      • SymbolicPropogator

        public SymbolicPropogator​(Program program)
    • 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:
        startAddr - start address
        restrictSet - the address set to restrict the constant flow to
        eval - the context evaluator to use
        saveContext - true if the context should be saved
        monitor - the task monitor
        Returns:
        the address set of instructions that were followed
        Throws:
        CancelledException - if the task is cancelled
      • saveOffCurrentContext

        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:
        toAddr - 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:
        vContext - - 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
        knownSpaceID - 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 - - the task 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 -