Package ghidra.pcode.exec

# Class DefaultPcodeExecutorState<T>

java.lang.Object
ghidra.pcode.exec.DefaultPcodeExecutorState<T>

Type Parameters:
  `T` - the type of values and addresses in the state

All Implemented Interfaces:
  `PcodeExecutorState<T>`, `PcodeExecutorStatePiece<T,T>`

Direct Known Subclasses:
  `BytesPcodeExecutorState`

public class DefaultPcodeExecutorState<T> extends Object implements PcodeExecutorState<T>
A p-code executor state formed from a piece whose address and value types are the same

This class will also wire in the arithmetic's `PcodeArithmetic.modBeforeStore(int, int, Object, int, Object)` and `PcodeArithmetic.modAfterLoad(int, int, Object, int, Object)`, which is only possible when the address and value type are guaranteed to match.

- ## Nested Class Summary

  ## Nested classes/interfaces inherited from interface ghidra.pcode.exec.PcodeExecutorStatePiece

  `PcodeExecutorStatePiece.Reason`

- ## Field Summary

  Fields
  Modifier and Type
  Field
  Description
  `protected final PcodeArithmetic<T>`
  `arithmetic`
  `protected final PcodeExecutorStatePiece<T,T>`
  `piece`

- ## Constructor Summary

  Constructors
  Constructor
  Description
  `DefaultPcodeExecutorState(PcodeExecutorStatePiece<T,T> piece)`
  `DefaultPcodeExecutorState(PcodeExecutorStatePiece<T,T> piece, PcodeArithmetic<T> arithmetic)`

- ## Method Summary

  Modifier and Type
  Method
  Description
  `void`
  `clear()`
  Erase the entire state or piece
  `DefaultPcodeExecutorState<T>`
  `fork()`
  Create a deep copy of 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
  `T`
  `getVar(AddressSpace space, long offset, int size, boolean quantize, PcodeExecutorStatePiece.Reason reason)`
  Get the value of a variable
  `T`
  `getVar(AddressSpace space, T offset, int size, boolean quantize, PcodeExecutorStatePiece.Reason reason)`
  Get the value of a variable
  `void`
  `setVar(AddressSpace space, long offset, int size, boolean quantize, T val)`
  Set the value of a variable
  `void`
  `setVar(AddressSpace space, T offset, int size, boolean quantize, T val)`
  Set the value of a variable

  ### Methods inherited from class java.lang.Object

  `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

  ### Methods inherited from interface ghidra.pcode.exec.PcodeExecutorState

  `getAddressArithmetic, paired`

  ### Methods inherited from interface ghidra.pcode.exec.PcodeExecutorStatePiece

  `checkRange, getVar, getVar, getVar, quantizeOffset, setVar, setVar, setVar`

- ## Field Details

  - ### piece

    protected final PcodeExecutorStatePiece<T,T> piece

  - ### arithmetic

    protected final PcodeArithmetic<T> arithmetic

- ## Constructor Details

  - ### DefaultPcodeExecutorState

    public DefaultPcodeExecutorState(PcodeExecutorStatePiece<T,T> piece, PcodeArithmetic<T> arithmetic)

  - ### DefaultPcodeExecutorState

    public DefaultPcodeExecutorState(PcodeExecutorStatePiece<T,T> piece)

- ## 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 DefaultPcodeExecutorState<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

  - ### 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

  - ### 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

  - ### 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

  - ### clear

    public void clear()
    Description copied from interface: `PcodeExecutorStatePiece`
    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.

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