Package ghidra.pcode.emu

Class ThreadPcodeExecutorState<T>

java.lang.Object
ghidra.pcode.emu.ThreadPcodeExecutorState<T>
Type Parameters:
T - the type of values stored in the states
All Implemented Interfaces:
PcodeExecutorState<T>, PcodeExecutorStatePiece<T,T>
public class ThreadPcodeExecutorState<T> extends Object implements PcodeExecutorState<T>
A p-code executor state that multiplexes shared and thread-local states for use in a machine that models multi-threading

  • Field Details

  • Constructor Details

    • ThreadPcodeExecutorState

      public ThreadPcodeExecutorState(PcodeExecutorState<T> sharedState, PcodeExecutorState<T> localState)
      Create a multiplexed state
      Parameters:
      sharedState - the shared part of the state
      localState - the thread-local part of the state

  • Method Details

    • getLanguage

      public Language getLanguage()
      Description copied from interface: PcodeExecutorStatePiece
      Get the language defining the address spaces of this state piece
      Specified by:
      getLanguage in interface PcodeExecutorStatePiece<T,T>
      Returns:
      the language

    • getArithmetic

      public PcodeArithmetic<T> getArithmetic()
      Description copied from interface: PcodeExecutorStatePiece
      Get the arithmetic used to manipulate values of the type stored by this state
      Specified by:
      getArithmetic in interface PcodeExecutorStatePiece<T,T>
      Returns:
      the arithmetic

    • fork

      public ThreadPcodeExecutorState<T> fork()
      Description copied from interface: PcodeExecutorStatePiece
      Create a deep copy of this state
      Specified by:
      fork in interface PcodeExecutorState<T>
      Specified by:
      fork in interface PcodeExecutorStatePiece<T,T>
      Returns:
      the copy

    • isThreadLocalSpace

      protected boolean isThreadLocalSpace(AddressSpace space)
      Decide whether or not access to the given space is directed to thread-local state
      Parameters:
      space - the space
      Returns:
      true for thread-local state, false for shared state

    • setVar

      public void setVar(AddressSpace space, T offset, int size, boolean quantize, T val)
      Description copied from interface: PcodeExecutorStatePiece
      Set the value of a variable
      Specified by:
      setVar in interface PcodeExecutorStatePiece<T,T>
      Parameters:
      space - the address space
      offset - the offset within the space
      size - the size of the variable
      quantize - true to quantize to the language's "addressable unit"
      val - the value

    • setVar

      public void setVar(AddressSpace space, long offset, int size, boolean quantize, T val)
      Description copied from interface: PcodeExecutorStatePiece
      Set the value of a variable
      Specified by:
      setVar in interface PcodeExecutorStatePiece<T,T>
      Parameters:
      space - the address space
      offset - the offset within the space
      size - the size of the variable
      quantize - true to quantize to the language's "addressable unit"
      val - the value

    • getVar

      public T getVar(AddressSpace space, T offset, int size, boolean quantize, PcodeExecutorStatePiece.Reason reason)
      Description copied from interface: PcodeExecutorStatePiece
      Get the value of a variable
      Specified by:
      getVar in interface PcodeExecutorStatePiece<T,T>
      Parameters:
      space - the address space
      offset - the offset within the space
      size - the size of the variable
      quantize - true to quantize to the language's "addressable unit"
      reason - the reason for reading the variable
      Returns:
      the value

    • getVar

      public T getVar(AddressSpace space, long offset, int size, boolean quantize, PcodeExecutorStatePiece.Reason reason)
      Description copied from interface: PcodeExecutorStatePiece
      Get the value of a variable

      This method is typically used for reading memory variables.

      Specified by:
      getVar in interface PcodeExecutorStatePiece<T,T>
      Parameters:
      space - the address space
      offset - the offset within the space
      size - the size of the variable
      quantize - true to quantize to the language's "addressable unit"
      reason - the reason for reading the variable
      Returns:
      the value

    • getRegisterValues

      public Map<Register,T> getRegisterValues()
      Description copied from interface: PcodeExecutorStatePiece
      Get all register values known to this state

      When the state acts as a cache, it should only return those cached.

      Specified by:
      getRegisterValues in interface PcodeExecutorStatePiece<T,T>
      Returns:
      a map of registers and their values

    • getConcreteBuffer

      public MemBuffer getConcreteBuffer(Address address, PcodeArithmetic.Purpose purpose)
      Description copied from interface: PcodeExecutorStatePiece
      Bind a buffer of concrete bytes at the given start address
      Specified by:
      getConcreteBuffer in interface PcodeExecutorStatePiece<T,T>
      Parameters:
      address - the start address
      purpose - the reason why the emulator needs a concrete value
      Returns:
      a buffer

    • getSharedState

      public PcodeExecutorState<T> getSharedState()
      Get the shared state
      Returns:
      the shared state

    • getLocalState

      public PcodeExecutorState<T> getLocalState()
      Get the thread-local state
      Returns:
      the thread-local state

    • clear

      public void clear()
      Erase the entire state or piece

      This is generally only useful when the state is itself a cache to another object. This will ensure the state is reading from that object rather than a stale cache. If this is not a cache, this could in fact clear the whole state, and the machine using it will be left in the dark.

      This will only clear the thread's local state, lest we invoke clear on the shared state for every thread. Instead, if necessary, the machine should clear its local state then clear each thread's local state.

      Specified by:
      clear in interface PcodeExecutorStatePiece<T,T>