Package ghidra.pcode.exec

# Class AbstractPcodeExecutorState<A,T>

java.lang.Object
ghidra.pcode.exec.AbstractPcodeExecutorState<A,T>

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

Direct Known Subclasses:
  `DebuggerPcodeUtils.WatchValuePcodeExecutorState`, `DefaultPcodeExecutorState`

public abstract class AbstractPcodeExecutorState<A,T> extends Object implements PcodeExecutorState<T>

- ## 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 PcodeExecutorStatePiece<A,T>`
  `piece`

- ## Constructor Summary

  Constructors
  Constructor
  Description
  `AbstractPcodeExecutorState(PcodeExecutorStatePiece<A,T> piece)`

- ## Method Summary

  Modifier and Type
  Method
  Description
  `void`
  `clear()`
  Erase the entire state or piece
  `protected abstract A`
  `extractAddress(T value)`
  `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
  `T`
  `getVarInternal(AddressSpace space, long offset, int size, PcodeExecutorStatePiece.Reason reason)`
  Get the value of a variable without issuing callbacks
  `T`
  `getVarInternal(AddressSpace space, T offset, int size, PcodeExecutorStatePiece.Reason reason)`
  Get the value of a variable without issuing callbacks
  `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
  `void`
  `setVarInternal(AddressSpace space, long offset, int size, T val)`
  Set the value of a variable without issuing callbacks
  `void`
  `setVarInternal(AddressSpace space, T offset, int size, T val)`
  Set the value of a variable without issuing callbacks
  `Stream<PcodeExecutorStatePiece<?,?>>`
  `streamPieces()`
  Stream over the pieces within.

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

  `fork, getAddressArithmetic, paired`

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

  `checkRange, getNextEntryInternal, getNextEntryInternal, getVar, getVar, getVar, inspectBigInteger, inspectByte, inspectConcrete, inspectInt, inspectLong, inspectRegisterValue, inspectShort, quantizeOffset, setBigInteger, setByte, setConcrete, setInt, setLong, setRegisterValue, setRegisterValue, setShort, setVar, setVar, setVar`

- ## Field Details

  - ### piece

    protected final PcodeExecutorStatePiece<A,T> piece

- ## Constructor Details

  - ### AbstractPcodeExecutorState

    public AbstractPcodeExecutorState(PcodeExecutorStatePiece<A,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<A,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<A,T>`
    Returns:
      the arithmetic

  - ### streamPieces

    public Stream<PcodeExecutorStatePiece<?,?>> streamPieces()
    Description copied from interface: `PcodeExecutorStatePiece`
    Stream over the pieces within.

    If this piece is not a composition of others, then simply stream this piece in a singleton. Otherwise, stream the component pieces. (Do not include the composition itself, just the component pieces.)

    Specified by:
      `streamPieces` in interface `PcodeExecutorStatePiece<A,T>`
    Returns:
      the stream

  - ### extractAddress

    protected abstract A extractAddress(T 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<A,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

  - ### getVarInternal

    public T getVarInternal(AddressSpace space, T offset, int size, PcodeExecutorStatePiece.Reason reason)
    Description copied from interface: `PcodeExecutorStatePiece`
    Get the value of a variable without issuing callbacks
    Specified by:
      `getVarInternal` in interface `PcodeExecutorStatePiece<A,T>`
    Parameters:
      `space` - the address space
      `offset` - the offset within the space
      `size` - the size of the variable
      `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<A,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

  - ### getVarInternal

    public T getVarInternal(AddressSpace space, long offset, int size, PcodeExecutorStatePiece.Reason reason)
    Description copied from interface: `PcodeExecutorStatePiece`
    Get the value of a variable without issuing callbacks
    Specified by:
      `getVarInternal` in interface `PcodeExecutorStatePiece<A,T>`
    Parameters:
      `space` - the address space
      `offset` - the offset within the space
      `size` - the size of the variable
      `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<A,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

  - ### setVarInternal

    public void setVarInternal(AddressSpace space, T offset, int size, T val)
    Description copied from interface: `PcodeExecutorStatePiece`
    Set the value of a variable without issuing callbacks
    Specified by:
      `setVarInternal` in interface `PcodeExecutorStatePiece<A,T>`
    Parameters:
      `space` - the address space
      `offset` - the offset within the space
      `size` - the size of the variable
      `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<A,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

  - ### setVarInternal

    public void setVarInternal(AddressSpace space, long offset, int size, T val)
    Description copied from interface: `PcodeExecutorStatePiece`
    Set the value of a variable without issuing callbacks
    Specified by:
      `setVarInternal` in interface `PcodeExecutorStatePiece<A,T>`
    Parameters:
      `space` - the address space
      `offset` - the offset within the space
      `size` - the size of the variable
      `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<A,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<A,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<A,T>`