Package ghidra.pcode.exec

# Class IndependentPairedPcodeExecutorState<L,R>

java.lang.Object
ghidra.pcode.exec.IndependentPairedPcodeExecutorState<L,R>

Type Parameters:
  `L` - the type of values for the "left" state
  `R` - the type of values for the "right" state

All Implemented Interfaces:
  `PcodeExecutorState<org.apache.commons.lang3.tuple.Pair<L,R>>`, `PcodeExecutorStatePiece<org.apache.commons.lang3.tuple.Pair<L,R>,org.apache.commons.lang3.tuple.Pair<L,R>>`

public class IndependentPairedPcodeExecutorState<L,R> extends Object implements PcodeExecutorState<org.apache.commons.lang3.tuple.Pair<L,R>>
A paired executor state

This composes a delegate state and piece "left" and "write" creating a single state which instead stores pairs of values, where the left component has the value type of the left state, and the right component has the value type of the right state. Note that each states is addressed using its own value type. Every operation on this state is decomposed into operations upon the delegate states, and the final result composed from the results of those operations.

Where a response cannot be composed of both states, the paired state defers to the left. In this way, the left state controls the machine, while the right is computed in tandem. The right never directly controls the machine

- ## Nested Class Summary

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

  `PcodeExecutorStatePiece.Reason`

- ## Constructor Summary

  Constructors
  Constructor
  Description
  `IndependentPairedPcodeExecutorState(PcodeExecutorStatePiece<L,L> left, PcodeExecutorStatePiece<R,R> right)`
  Compose a paired state from the given left and right states
  `IndependentPairedPcodeExecutorState(PcodeExecutorStatePiece<L,L> left, PcodeExecutorStatePiece<R,R> right, PcodeArithmetic<org.apache.commons.lang3.tuple.Pair<L,R>> arithmetic)`

- ## Method Summary

  Modifier and Type
  Method
  Description
  `void`
  `clear()`
  Erase the entire state or piece
  `IndependentPairedPcodeExecutorState<L,R>`
  `fork(PcodeStateCallbacks cb)`
  Create a deep copy of this state
  `PcodeArithmetic<org.apache.commons.lang3.tuple.Pair<L,R>>`
  `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
  `PcodeExecutorStatePiece<L,L>`
  `getLeft()`
  Get the delegate backing the left side of paired values
  `Map<Register,org.apache.commons.lang3.tuple.Pair<L,R>>`
  `getRegisterValues()`
  Get all register values known to this state
  `PcodeExecutorStatePiece<R,R>`
  `getRight()`
  Get the delegate backing the right side of paired values
  `org.apache.commons.lang3.tuple.Pair<L,R>`
  `getVar(AddressSpace space, org.apache.commons.lang3.tuple.Pair<L,R> offset, int size, boolean quantize, PcodeExecutorStatePiece.Reason reason)`
  Get the value of a variable
  `org.apache.commons.lang3.tuple.Pair<L,R>`
  `getVarInternal(AddressSpace space, org.apache.commons.lang3.tuple.Pair<L,R> offset, int size, PcodeExecutorStatePiece.Reason reason)`
  Get the value of a variable without issuing callbacks
  `void`
  `setVar(AddressSpace space, org.apache.commons.lang3.tuple.Pair<L,R> offset, int size, boolean quantize, org.apache.commons.lang3.tuple.Pair<L,R> val)`
  Set the value of a variable
  `void`
  `setVarInternal(AddressSpace space, org.apache.commons.lang3.tuple.Pair<L,R> offset, int size, org.apache.commons.lang3.tuple.Pair<L,R> 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

  `getAddressArithmetic, paired`

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

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

- ## Constructor Details

  - ### IndependentPairedPcodeExecutorState

    public IndependentPairedPcodeExecutorState(PcodeExecutorStatePiece<L,L> left, PcodeExecutorStatePiece<R,R> right, PcodeArithmetic<org.apache.commons.lang3.tuple.Pair<L,R>> arithmetic)

  - ### IndependentPairedPcodeExecutorState

    public IndependentPairedPcodeExecutorState(PcodeExecutorStatePiece<L,L> left, PcodeExecutorStatePiece<R,R> right)
    Compose a paired state from the given left and right states
    Parameters:
      `left` - the state backing the left side of paired values ("control")
      `right` - the state backing the right side of paired values ("auxiliary")

- ## 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<L,R>`
    Returns:
      the language

  - ### getArithmetic

    public PcodeArithmetic<org.apache.commons.lang3.tuple.Pair<L,R>> 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<L,R>`
    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<L,R>`
    Returns:
      the stream

  - ### fork

    public IndependentPairedPcodeExecutorState<L,R> fork(PcodeStateCallbacks cb)
    Description copied from interface: `PcodeExecutorStatePiece`
    Create a deep copy of this state
    Specified by:
      `fork` in interface `PcodeExecutorState<L>`
    Specified by:
      `fork` in interface `PcodeExecutorStatePiece<L,R>`
    Parameters:
      `cb` - callbacks to receive emulation events
    Returns:
      the copy

  - ### getRegisterValues

    public Map<Register,org.apache.commons.lang3.tuple.Pair<L,R>> 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<L,R>`
    Returns:
      a map of registers and their values

  - ### setVar

    public void setVar(AddressSpace space, org.apache.commons.lang3.tuple.Pair<L,R> offset, int size, boolean quantize, org.apache.commons.lang3.tuple.Pair<L,R> val)
    Description copied from interface: `PcodeExecutorStatePiece`
    Set the value of a variable
    Specified by:
      `setVar` in interface `PcodeExecutorStatePiece<L,R>`
    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, org.apache.commons.lang3.tuple.Pair<L,R> offset, int size, org.apache.commons.lang3.tuple.Pair<L,R> val)
    Description copied from interface: `PcodeExecutorStatePiece`
    Set the value of a variable without issuing callbacks
    Specified by:
      `setVarInternal` in interface `PcodeExecutorStatePiece<L,R>`
    Parameters:
      `space` - the address space
      `offset` - the offset within the space
      `size` - the size of the variable
      `val` - the value

  - ### getVar

    public org.apache.commons.lang3.tuple.Pair<L,R> getVar(AddressSpace space, org.apache.commons.lang3.tuple.Pair<L,R> 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<L,R>`
    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 org.apache.commons.lang3.tuple.Pair<L,R> getVarInternal(AddressSpace space, org.apache.commons.lang3.tuple.Pair<L,R> 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<L,R>`
    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

  - ### 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<L,R>`
    Parameters:
      `address` - the start address
      `purpose` - the reason why the emulator needs a concrete value
    Returns:
      a buffer

  - ### getLeft

    public PcodeExecutorStatePiece<L,L> getLeft()
    Get the delegate backing the left side of paired values
    Returns:
      the left state

  - ### getRight

    public PcodeExecutorStatePiece<R,R> getRight()
    Get the delegate backing the right side of paired values
    Returns:
      the right state

  - ### 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<L,R>`