Package ghidra.pcode.exec

# Interface PcodeExecutorStatePiece<A,T>

Type Parameters:
  `A` - the type of address offsets
  `T` - the type of values

All Known Subinterfaces:
  `PcodeExecutorState<T>`

All Known Implementing Classes:
  `AbstractBytesPcodeExecutorStatePiece`, `AbstractLongOffsetPcodeExecutorStatePiece`, `BytesPcodeExecutorState`, `BytesPcodeExecutorStatePiece`, `DefaultPcodeExecutorState`, `LocationPcodeExecutorStatePiece`, `PairedPcodeExecutorState`, `PairedPcodeExecutorStatePiece`, `ThreadPcodeExecutorState`

public interface PcodeExecutorStatePiece<A,T>
An interface that provides storage for values of type `T`, addressed by offsets of type `A`

The typical pattern for implementing a state is to compose it from one or more state pieces. Each piece must use the same address type and arithmetic. If more than one piece is needed, they are composed using `PairedPcodeExecutorStatePiece`. Once all the pieces are composed, the root piece can be wrapped to make a state using `DefaultPcodeExecutorState` or `PairedPcodeExecutorState`. The latter corrects the address type to be a pair so it matches the type of values.

- ## Nested Class Summary

  Nested Classes
  Modifier and Type
  Interface
  Description
  `static enum`
  `PcodeExecutorStatePiece.Reason`
  Reasons for reading state

- ## Method Summary

  Modifier and Type
  Method
  Description
  `default void`
  `checkRange(AddressSpace space, long offset, int size)`
  Construct a range, if only to verify the range is valid
  `void`
  `clear()`
  Erase the entire state or piece
  `default PcodeExecutorStatePiece<A,T>`
  `fork()`
  Create a deep copy of this state
  `PcodeArithmetic<A>`
  `getAddressArithmetic()`
  Get the arithmetic used to manipulate addresses of the type used by this state
  `PcodeArithmetic<T>`
  `getArithmetic()`
  Get the arithmetic used to manipulate values of the type stored by this state
  `MemBuffer`
  `getConcreteBuffer(Address address, PcodeArithmetic.Purpose purpose)`
  Bind a buffer of concrete bytes at the given start address
  `Language`
  `getLanguage()`
  Get the language defining the address spaces of this state piece
  `Map<Register,T>`
  `getRegisterValues()`
  Get all register values known to this state
  `default T`
  `getVar(Address address, int size, boolean quantize, PcodeExecutorStatePiece.Reason reason)`
  Get the value of a variable
  `default T`
  `getVar(AddressSpace space, long offset, int size, boolean quantize, PcodeExecutorStatePiece.Reason reason)`
  Get the value of a variable
  `T`
  `getVar(AddressSpace space, A offset, int size, boolean quantize, PcodeExecutorStatePiece.Reason reason)`
  Get the value of a variable
  `default T`
  `getVar(Register reg, PcodeExecutorStatePiece.Reason reason)`
  Get the value of a register variable
  `default T`
  `getVar(Varnode var, PcodeExecutorStatePiece.Reason reason)`
  Get the value of a variable
  `default long`
  `quantizeOffset(AddressSpace space, long offset)`
  Quantize the given offset to the language's "addressable unit"
  `default void`
  `setVar(Address address, int size, boolean quantize, T val)`
  Set the value of a variable
  `default void`
  `setVar(AddressSpace space, long offset, int size, boolean quantize, T val)`
  Set the value of a variable
  `void`
  `setVar(AddressSpace space, A offset, int size, boolean quantize, T val)`
  Set the value of a variable
  `default void`
  `setVar(Register reg, T val)`
  Set the value of a register variable
  `default void`
  `setVar(Varnode var, T val)`
  Set the value of a variable

- ## Method Details

  - ### checkRange

    default void checkRange(AddressSpace space, long offset, int size)
    Construct a range, if only to verify the range is valid
    Parameters:
      `space` - the address space
      `offset` - the starting offset
      `size` - the length (in bytes) of the range

  - ### getLanguage

    Language getLanguage()
    Get the language defining the address spaces of this state piece
    Returns:
      the language

  - ### getAddressArithmetic

    PcodeArithmetic<A> getAddressArithmetic()
    Get the arithmetic used to manipulate addresses of the type used by this state
    Returns:
      the address (or offset) arithmetic

  - ### getArithmetic

    PcodeArithmetic<T> getArithmetic()
    Get the arithmetic used to manipulate values of the type stored by this state
    Returns:
      the arithmetic

  - ### fork

    default PcodeExecutorStatePiece<A,T> fork()
    Create a deep copy of this state
    Returns:
      the copy

  - ### setVar

    default void setVar(Register reg, T val)
    Set the value of a register variable
    Parameters:
      `reg` - the register
      `val` - the value

  - ### setVar

    default void setVar(Varnode var, T val)
    Set the value of a variable
    Parameters:
      `var` - the variable
      `val` - the value

  - ### setVar

    void setVar(AddressSpace space, A offset, int size, boolean quantize, T val)
    Set the value of a variable
    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

    default void setVar(AddressSpace space, long offset, int size, boolean quantize, T val)
    Set the value of a variable
    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

    default void setVar(Address address, int size, boolean quantize, T val)
    Set the value of a variable
    Parameters:
      `address` - the address in memory
      `size` - the size of the variable
      `quantize` - true to quantize to the language's "addressable unit"
      `val` - the value

  - ### getVar

    default T getVar(Register reg, PcodeExecutorStatePiece.Reason reason)
    Get the value of a register variable
    Parameters:
      `reg` - the register
      `reason` - the reason for reading the register
    Returns:
      the value

  - ### getVar

    default T getVar(Varnode var, PcodeExecutorStatePiece.Reason reason)
    Get the value of a variable
    Parameters:
      `var` - the variable
      `reason` - the reason for reading the variable
    Returns:
      the value

  - ### getVar

    T getVar(AddressSpace space, A offset, int size, boolean quantize, PcodeExecutorStatePiece.Reason reason)
    Get the value of a variable
    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

    default T getVar(AddressSpace space, long offset, int size, boolean quantize, PcodeExecutorStatePiece.Reason reason)
    Get the value of a variable

    This method is typically used for reading memory variables.

    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

    default T getVar(Address address, int size, boolean quantize, PcodeExecutorStatePiece.Reason reason)
    Get the value of a variable

    This method is typically used for reading memory variables.

    Parameters:
      `address` - the address of the variable
      `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

    Map<Register,T> getRegisterValues()
    Get all register values known to this state

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

    Returns:
      a map of registers and their values

  - ### getConcreteBuffer

    MemBuffer getConcreteBuffer(Address address, PcodeArithmetic.Purpose purpose)
    Bind a buffer of concrete bytes at the given start address
    Parameters:
      `address` - the start address
      `purpose` - the reason why the emulator needs a concrete value
    Returns:
      a buffer

  - ### quantizeOffset

    default long quantizeOffset(AddressSpace space, long offset)
    Quantize the given offset to the language's "addressable unit"
    Parameters:
      `space` - the space where the offset applies
      `offset` - the offset
    Returns:
      the quantized offset

  - ### clear

    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.