Package ghidra.program.database.code

# Class InstructionDB

java.lang.Object
ghidra.program.database.DatabaseObject
ghidra.program.database.code.InstructionDB

All Implemented Interfaces:
  `InstructionContext`, `ProcessorContext`, `ProcessorContextView`, `CodeUnit`, `Instruction`, `MemBuffer`, `PropertySet`

public class InstructionDB extends DatabaseObject implements Instruction, InstructionContext
Database implementation for an Instruction.

- ## Field Summary

  Fields
  Modifier and Type
  Field
  Description
  `protected long`
  `addr`
  `protected Address`
  `address`
  `protected byte[]`
  `bytes`
  `protected CodeManager`
  `codeMgr`
  `protected Address`
  `endAddr`
  `protected int`
  `length`
  `protected Lock`
  `lock`
  `protected ProgramDB`
  `program`
  `protected ReferenceDBManager`
  `refMgr`

  ### Fields inherited from class ghidra.program.database.DatabaseObject

  `key`

  ### Fields inherited from interface ghidra.program.model.listing.CodeUnit

  `COMMENT_PROPERTY, DEFINED_DATA_PROPERTY, EOL_COMMENT, INSTRUCTION_PROPERTY, MNEMONIC, PLATE_COMMENT, POST_COMMENT, PRE_COMMENT, REPEATABLE_COMMENT, SPACE_PROPERTY`

  ### Fields inherited from interface ghidra.program.model.listing.Instruction

  `INVALID_DEPTH_CHANGE, MAX_LENGTH_OVERRIDE`

- ## Constructor Summary

  Constructors
  Constructor
  Description
  `InstructionDB(CodeManager codeMgr, DBObjectCache<? extends ghidra.program.database.code.CodeUnitDB> cache, Address address, long addr, InstructionPrototype proto, byte flags)`
  Construct a new InstructionDB.

- ## Method Summary

  Modifier and Type
  Method
  Description
  `void`
  `addMnemonicReference(Address refAddr, RefType refType, SourceType sourceType)`
  Add a reference to the mnemonic for this code unit.
  `void`
  `addOperandReference(int opIndex, Address refAddr, RefType type, SourceType sourceType)`
  Add a memory reference to the operand at the given index.
  `static int`
  `checkLengthOverride(int length, InstructionPrototype prototype)`
  Check and revise a specified `length` to arrive at a suitable length-override value.
  `void`
  `clearFallThroughOverride()`
  Restores this instruction's fallthrough address back to the default fallthrough for this instruction.
  `void`
  `clearRegister(Register register)`
  Clears the register within this context.
  `int`
  `compareTo(Address a)`
  Compares the given address to the address range of this node.
  `boolean`
  `contains(Address testAddr)`
  Returns true if address is contained in the range of this codeUnit.
  `boolean`
  `equals(Object obj)`
  Return true if obj is equal to this.
  `Address`
  `getAddress()`
  Get the Address which corresponds to the offset 0.
  `Address`
  `getAddress(int opIndex)`
  Get the Address for the given operand index if one exists.
  `String`
  `getAddressString(boolean showBlockName, boolean pad)`
  Get the string representation of the starting address for this code unit.
  `Register`
  `getBaseContextRegister()`
  `BigInteger`
  `getBigInteger(int offset, int size, boolean signed)`
  returns the value at the given offset, taking into account the endianness.
  `byte`
  `getByte(int offset)`
  Get one byte from memory at the current position plus offset.
  `byte[]`
  `getBytes()`
  Get the bytes that make up this code unit.
  `int`
  `getBytes(byte[] b, int offset)`
  Reads `b.length` bytes from this memory buffer starting at the address of this memory buffer plus the given memoryBufferOffset from that position.
  `void`
  `getBytesInCodeUnit(byte[] buffer, int bufferOffset)`
  Copies max(buffer.length, code unit length) bytes into buffer starting at the given offset in `buffer`.
  `String`
  `getComment(CommentType commentType)`
  Get the comment for the given type
  `String[]`
  `getCommentAsArray(CommentType commentType)`
  Get the comment for the given type and parse it into an array of strings such that each line is its own string.
  `Address`
  `getDefaultFallThrough()`
  Get the default fallthrough for this instruction.
  `int`
  `getDefaultFallThroughOffset()`
  Get default fall-through offset in bytes from start of instruction to the fallthrough instruction.
  `Address[]`
  `getDefaultFlows()`
  Get an array of Address objects for all default flows established by the underlying instruction prototype.
  `String`
  `getDefaultOperandRepresentation(int opIndex)`
  Get the operand representation for the given operand index without markup.
  `List<Object>`
  `getDefaultOperandRepresentationList(int opIndex)`
  Get the operand representation for the given operand index.
  `int`
  `getDelaySlotDepth()`
  Get the number of delay slot instructions for this argument.
  `ExternalReference`
  `getExternalReference(int opIndex)`
  Gets the external reference (if any) at the opIndex
  `Address`
  `getFallFrom()`
  `Address`
  `getFallThrough()`
  Get the fallthrough for this instruction, factoring in any fallthrough override and delay slotted instructions.
  `FlowOverride`
  `getFlowOverride()`
  `Address[]`
  `getFlows()`
  Get an array of Address objects for all flows other than a fall-through.
  `FlowType`
  `getFlowType()`
  `Object[]`
  `getInputObjects()`
  Get the Input objects used by this instruction.
  `InstructionContext`
  `getInstructionContext()`
  `int`
  `getInt(int offset)`
  returns the int at the given offset, taking into account the endianness.
  `int`
  `getIntProperty(String name)`
  Get the int property for name.
  `String`
  `getLabel()`
  Returns the label for this code unit..
  `int`
  `getLength()`
  Get length of this code unit.
  `long`
  `getLong(int offset)`
  returns the long at the given offset, taking into account the endianness.
  `Address`
  `getMaxAddress()`
  Returns the ending address for this code unit..
  `MemBuffer`
  `getMemBuffer()`
  Get the read-only memory buffer containing the instruction bytes.
  `Memory`
  `getMemory()`
  Get the Memory object actually used by the MemBuffer.
  `Address`
  `getMinAddress()`
  Returns the starting address for this code unit..
  `Reference[]`
  `getMnemonicReferences()`
  Get references for the mnemonic for this code unit.
  `String`
  `getMnemonicString()`
  Returns the mnemonic for this code unit, e.g., MOV, JMP.
  `Instruction`
  `getNext()`
  `int`
  `getNumOperands()`
  Returns the number of operands for this code unit..
  `Saveable`
  `getObjectProperty(String name)`
  Get the object property for name; returns null if there is no name property for this code unit.
  `Reference[]`
  `getOperandReferences(int opIndex)`
  Returns the references for the operand index..
  `RefType`
  `getOperandRefType(int opIndex)`
  Get the operand reference type for the given operand index.
  `int`
  `getOperandType(int opIndex)`
  Get the type of a specific operand.
  `Object[]`
  `getOpObjects(int opIndex)`
  Get objects used by this operand (Address, Scalar, Register ...)
  `RegisterValue`
  `getOriginalPrototypeContext(Register baseContextReg)`
  Get the original context used to establish the shared prototype
  `byte[]`
  `getParsedBytes()`
  Get the actual bytes parsed when forming this instruction.
  `int`
  `getParsedLength()`
  Get the actual number of bytes parsed when forming this instruction.
  `ParserContext`
  `getParserContext()`
  Get the instruction parser context for the instruction which corresponds to this context object.
  `ParserContext`
  `getParserContext(Address instructionAddress)`
  Get the instruction parser context which corresponds to the specified instruction address.
  `PcodeOp[]`
  `getPcode()`
  Get an array of PCode operations (micro code) that this instruction performs.
  `PcodeOp[]`
  `getPcode(boolean includeOverrides)`
  Get an array of PCode operations (micro code) that this instruction performs.
  `PcodeOp[]`
  `getPcode(int opIndex)`
  Get an array of PCode operations (micro code) that a particular operand performs to compute its value.
  `protected int`
  `getPreferredCacheLength()`
  `Instruction`
  `getPrevious()`
  `Reference`
  `getPrimaryReference(int index)`
  Returns the primary reference for the operand index..
  `Symbol`
  `getPrimarySymbol()`
  Returns the Primary Symbol for this code unit..
  `ProcessorContextView`
  `getProcessorContext()`
  Get the read-only processor context containing the context-register state state at the corresponding instruction.
  `Program`
  `getProgram()`
  Returns the program that generated this CodeUnit..
  `InstructionPrototype`
  `getPrototype()`
  `ReferenceIterator`
  `getReferenceIteratorTo()`
  Returns an iterator over all references TO this code unit..
  `Reference[]`
  `getReferencesFrom()`
  Get ALL memory references FROM this code unit.
  `Register`
  `getRegister(int opIndex)`
  If operand is a pure Register, return the register.
  `Register`
  `getRegister(String name)`
  Get a Register given the name of a register
  `List<Register>`
  `getRegisters()`
  Returns all the Registers for the processor as an unmodifiable list
  `RegisterValue`
  `getRegisterValue(Register register)`
  Get the RegisterValue for the given register.
  `Object[]`
  `getResultObjects()`
  Get the Result objects produced/affected by this instruction These would probably only be Register or Address
  `Scalar`
  `getScalar(int opIndex)`
  Returns the scalar at the given operand index.
  `String`
  `getSeparator(int opIndex)`
  Get the separator strings between an operand.
  `short`
  `getShort(int offset)`
  returns the short at the given offset, taking into account the endianness.
  `String`
  `getStringProperty(String name)`
  Get the string property for name; returns null if there is no name property for this code unit.
  `Symbol[]`
  `getSymbols()`
  Returns the Symbols for this code unit..
  `BigInteger`
  `getValue(Register register, boolean signed)`
  Get the contents of a processor register as a BigInteger object
  `boolean`
  `getVoidProperty(String name)`
  Returns whether this code unit is marked as having the name property.
  `protected boolean`
  `hasBeenDeleted(DBRecord rec)`
  Perform any refresh necessary and determine if this code unit has been deleted.
  `boolean`
  `hasFallthrough()`
  `int`
  `hashCode()`
  `boolean`
  `hasProperty(String name)`
  Returns true if the codeunit has the given property defined.
  `boolean`
  `hasValue(Register register)`
  Returns true if a value is defined for the given register.
  `boolean`
  `isBigEndian()`
  Returns true if the underlying bytes are in big-endian order, false if they are little endian.
  `boolean`
  `isFallthrough()`
  `boolean`
  `isFallThroughOverridden()`
  `boolean`
  `isInDelaySlot()`
  `boolean`
  `isLengthOverridden()`
  Determine if an instruction length override has been set.
  `Iterator<String>`
  `propertyNames()`
  Get an iterator over the property names which have values applied.
  `protected boolean`
  `refresh()`
  Tells the object to refresh its state from the database.
  `protected boolean`
  `refresh(DBRecord record)`
  Tells the object to refresh its state from the database using the specified record if not null.
  `void`
  `removeExternalReference(int opIndex)`
  Remove external reference (if any) at the given opIndex
  `void`
  `removeMnemonicReference(Address refAddr)`
  Remove a reference to the mnemonic for this code unit.
  `void`
  `removeOperandReference(int opIndex, Address refAddr)`
  Remove a reference to the operand.
  `void`
  `removeProperty(String name)`
  Remove the property value associated with the given name .
  `void`
  `setComment(CommentType commentType, String comment)`
  Set the comment for the given comment type.
  `void`
  `setCommentAsArray(CommentType commentType, String[] comment)`
  Set the comment (with each line in its own string) for the given comment type
  `void`
  `setFallThrough(Address fallThroughAddr)`
  Overrides the instruction's default fallthrough address to the given address.
  `void`
  `setFlowOverride(FlowOverride flow)`
  Set the flow override for this instruction.
  `void`
  `setLengthOverride(int len)`
  Set instruction length override.
  `void`
  `setPrimaryMemoryReference(Reference ref)`
  Sets a memory reference to be the primary reference at its address/opIndex location.
  `void`
  `setProperty(String name)`
  Set the named property.
  `void`
  `setProperty(String name, int value)`
  Set the named integer property with the given value.
  `void`
  `setProperty(String name, String value)`
  Set the named string property with the given value.
  `<T extends Saveable>
  void`
  `setProperty(String name, T value)`
  Set the named property with the given `Saveable` value.
  `void`
  `setRegisterReference(int opIndex, Register reg, SourceType sourceType, RefType refType)`
  Sets a register reference at the `offset` on the specified operand index, which effectively substitutes the previous operation interpretation
  NOTE: If another reference was previously set on the operand, then it will be replaced with this register reference
  `void`
  `setRegisterValue(RegisterValue value)`
  Sets the specified register value within this context.
  `void`
  `setStackReference(int opIndex, int offset, SourceType sourceType, RefType refType)`
  Sets a stack reference at the `offset` on the specified operand index, which effectively substitutes the previous operation interpretation
  NOTE: If another reference was previously set on the operand, then it will be replaced with this stack reference
  `void`
  `setValue(Register register, BigInteger value)`
  Sets the value for a Register.
  `String`
  `toString()`
  Returns a string that represents this code unit with default markup.

  ### Methods inherited from class ghidra.program.database.DatabaseObject

  `checkDeleted, checkIsValid, checkIsValid, getKey, isDeleted, isInvalid, keyChanged, setDeleted, setInvalid, validate`

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

  `clone, finalize, getClass, notify, notifyAll, wait, wait, wait`

  ### Methods inherited from interface ghidra.program.model.listing.CodeUnit

  `addMnemonicReference, addOperandReference, compareTo, contains, getAddressString, getBytes, getBytesInCodeUnit, getComment, getComment, getCommentAsArray, getCommentAsArray, getExternalReference, getLabel, getLength, getMaxAddress, getMinAddress, getMnemonicReferences, getOperandReferences, getPrimaryReference, getPrimarySymbol, getProgram, getReferenceIteratorTo, getReferencesFrom, getSymbols, removeExternalReference, removeMnemonicReference, removeOperandReference, setComment, setComment, setCommentAsArray, setCommentAsArray, setPrimaryMemoryReference, setRegisterReference, setStackReference`

  ### Methods inherited from interface ghidra.program.model.lang.InstructionContext

  `getAddress`

  ### Methods inherited from interface ghidra.program.model.mem.MemBuffer

  `getAddress, getBigInteger, getByte, getBytes, getInputStream, getInputStream, getInt, getLong, getMemory, getShort, getUnsignedByte, getUnsignedInt, getUnsignedShort, getVarLengthInt, getVarLengthUnsignedInt, isBigEndian, isInitializedMemory`

  ### Methods inherited from interface ghidra.program.model.lang.ProcessorContext

  `clearRegister, setRegisterValue, setValue`

  ### Methods inherited from interface ghidra.program.model.lang.ProcessorContextView

  `getBaseContextRegister, getRegister, getRegisters, getRegisterValue, getValue, hasValue`

  ### Methods inherited from interface ghidra.program.model.util.PropertySet

  `getIntProperty, getObjectProperty, getStringProperty, getVoidProperty, hasProperty, propertyNames, removeProperty, setProperty, setProperty, setProperty, setProperty`

- ## Field Details

  - ### codeMgr

    protected CodeManager codeMgr

  - ### address

    protected Address address

  - ### addr

    protected long addr

  - ### endAddr

    protected Address endAddr

  - ### length

    protected int length

  - ### refMgr

    protected ReferenceDBManager refMgr

  - ### program

    protected ProgramDB program

  - ### bytes

    protected byte[] bytes

  - ### lock

    protected Lock lock

- ## Constructor Details

  - ### InstructionDB

    public InstructionDB(CodeManager codeMgr, DBObjectCache<? extends ghidra.program.database.code.CodeUnitDB> cache, Address address, long addr, InstructionPrototype proto, byte flags)
    Construct a new InstructionDB.
    Parameters:
      `codeMgr` - code manager
      `cache` - code unit cache
      `address` - min address of this instruction
      `addr` - database key
      `proto` - instruction prototype
      `flags` - flow override flags

- ## Method Details

  - ### refresh

    protected boolean refresh(DBRecord record)
    Description copied from class: `DatabaseObject`
    Tells the object to refresh its state from the database using the specified record if not null. NOTE: The default implementation ignores the record and invokes refresh(). Implementations of this method must take care if multiple database tables are used since the record supplied could correspond to another object. In some cases it may be best not to override this method or ignore the record provided.
    Parameters:
      `record` - valid record associated with object's key (optional, may be null to force record lookup or other refresh technique)
    Returns:
      true if the object was able to refresh itself. Return false if record is null and object was deleted. Objects that extend this class must implement a refresh method. If an object can never refresh itself, then it should always return false.

  - ### getPreferredCacheLength

    protected int getPreferredCacheLength()

  - ### hasBeenDeleted

    protected boolean hasBeenDeleted(DBRecord rec)
    Perform any refresh necessary and determine if this code unit has been deleted. If a record has been provided, it may be used to facilitate a refresh without performing a record query from the database
    Parameters:
      `rec` - optional record which corresponds to code unit. A null record does NOT indicate existence and a record query may be required.
    Returns:
      true if removal of code unit has been confirmed

  - ### getDelaySlotDepth

    public int getDelaySlotDepth()
    Description copied from interface: `Instruction`
    Get the number of delay slot instructions for this argument. This should be 0 for instructions which don't have a delay slot. This is used to support the delay slots found on some RISC processors such as SPARC and the PA-RISC. This returns an integer instead of a boolean in case some other processor executes more than one instruction from a delay slot.
    Specified by:
      `getDelaySlotDepth` in interface `Instruction`
    Returns:
      delay slot depth (number of instructions)

  - ### getOriginalPrototypeContext

    public RegisterValue getOriginalPrototypeContext(Register baseContextReg)
    Get the original context used to establish the shared prototype
    Parameters:
      `baseContextReg` - is a context register
    Returns:
      prototype context value

  - ### getParsedLength

    public int getParsedLength()
    Description copied from interface: `Instruction`
    Get the actual number of bytes parsed when forming this instruction. While this method will generally return the same value as `CodeUnit.getLength()`, its value will differ when `Instruction.setLengthOverride(int)` has been used. In addition, it is important to note that `CodeUnit.getMaxAddress()` will always reflect a non-overlapping address which reflects `CodeUnit.getLength()`. This method is equivalent to the following code for a given instruction:

         InstructionPrototype proto = instruction.Instruction.getPrototype();
         int length = proto.getLength();

    Specified by:
      `getParsedLength` in interface `Instruction`
    Returns:
      the actual number of bytes parsed when forming this instruction

  - ### getParsedBytes

    public byte[] getParsedBytes() throws MemoryAccessException
    Description copied from interface: `Instruction`
    Get the actual bytes parsed when forming this instruction. While this method will generally return the same value as `CodeUnit.getBytes()`, it will return more bytes when `Instruction.setLengthOverride(int)` has been used. In this override situation, the bytes returned will generally duplicate some of the parsed bytes associated with the next instruction that this instruction overlaps. This method is equivalent to the following code for a given instruction:

         InstructionPrototype proto = instruction.Instruction.getPrototype();
         Memory mem = instruction.MemBuffer.getMemory();
         byte[] bytes = mem.getBytes(instruction.MemBuffer.getAddress(), proto.getLength());
         int length = proto.getLength();

    Specified by:
      `getParsedBytes` in interface `Instruction`
    Returns:
      the actual number of bytes parsed when forming this instruction
    Throws:
      `MemoryAccessException` - if the full number of bytes could not be read

  - ### getFallFrom

    public Address getFallFrom()
    Specified by:
      `getFallFrom` in interface `Instruction`
    Returns:
      the Address for the instruction that fell through to this instruction. This is useful for handling instructions that are found in a delay slot. Note: if an instruction is in a delayslot, then it may have a branch into the delayslot, which is handled as follows

           JMPIF Y, X
             lab:
               _ADD         getFallFrom() = JMPIF
           MOV              getFallFrom() = _ADD

           JMP Y, X
             lab:
               _ADD         getFallFrom() = null
           MOV              getFallFrom() = _ADD

           JMPIF Y, X
               _ADD         getFallFrom() = JMPIF
           MOV              getFallFrom() = JMPIF

           JMP Y, X
               _ADD         getFallFrom() = JMP
           MOV              getFallFrom() = null

  - ### getFallThrough

    public Address getFallThrough()
    Description copied from interface: `Instruction`
    Get the fallthrough for this instruction, factoring in any fallthrough override and delay slotted instructions.
    Specified by:
      `getFallThrough` in interface `Instruction`
    Returns:
      fall-through address or null if instruction has no fallthrough

  - ### getFlows

    public Address[] getFlows()
    Description copied from interface: `Instruction`
    Get an array of Address objects for all flows other than a fall-through. This will include any flow references which have been added to the instruction.
    Specified by:
      `getFlows` in interface `Instruction`
    Returns:
      flow addresses or null if there are no flows

  - ### getDefaultFlows

    public Address[] getDefaultFlows()
    Description copied from interface: `Instruction`
    Get an array of Address objects for all default flows established by the underlying instruction prototype. References are ignored.
    Specified by:
      `getDefaultFlows` in interface `Instruction`
    Returns:
      flow addresses or null if there are no flows

  - ### getFlowType

    public FlowType getFlowType()
    Specified by:
      `getFlowType` in interface `Instruction`
    Returns:
      the flow type of this instruction (how this instruction flows to the next instruction).

  - ### getNext

    public Instruction getNext()
    Specified by:
      `getNext` in interface `Instruction`
    Returns:
      the instruction following this one in address order or null if none found.

  - ### getOperandRefType

    public RefType getOperandRefType(int opIndex)
    Description copied from interface: `Instruction`
    Get the operand reference type for the given operand index.
    Specified by:
      `getOperandRefType` in interface `Instruction`
    Parameters:
      `opIndex` - operand index
    Returns:
      the operand reference type for the given operand index.

  - ### getSeparator

    public String getSeparator(int opIndex)
    Description copied from interface: `Instruction`
    Get the separator strings between an operand. The separator string for 0 are the characters before the first operand. The separator string for numOperands+1 are the characters after the last operand.
    Specified by:
      `getSeparator` in interface `Instruction`
    Parameters:
      `opIndex` - valid values are 0 thru numOperands+1
    Returns:
      separator string, or null if there is no string

  - ### getDefaultOperandRepresentation

    public String getDefaultOperandRepresentation(int opIndex)
    Description copied from interface: `Instruction`
    Get the operand representation for the given operand index without markup.
    Specified by:
      `getDefaultOperandRepresentation` in interface `Instruction`
    Parameters:
      `opIndex` - operand index
    Returns:
      operand represented as a string.

  - ### getDefaultOperandRepresentationList

    public List<Object> getDefaultOperandRepresentationList(int opIndex)
    Description copied from interface: `Instruction`
    Get the operand representation for the given operand index. A list of Register, Address, Scalar, Character and String objects is returned - without markup!
    Specified by:
      `getDefaultOperandRepresentationList` in interface `Instruction`
    Parameters:
      `opIndex` - operand index
    Returns:
      ArrayList of pieces of the operand representation. Unsupported languages may return null.

  - ### getOperandType

    public int getOperandType(int opIndex)
    Description copied from interface: `Instruction`
    Get the type of a specific operand.
    Specified by:
      `getOperandType` in interface `Instruction`
    Parameters:
      `opIndex` - the index of the operand. (zero based)
    Returns:
      the type of the operand.
    See Also:
      - `OperandType`

  - ### getOpObjects

    public Object[] getOpObjects(int opIndex)
    Description copied from interface: `Instruction`
    Get objects used by this operand (Address, Scalar, Register ...)
    Specified by:
      `getOpObjects` in interface `Instruction`
    Parameters:
      `opIndex` - index of the operand.
    Returns:
      objects used by this operand (Address, Scalar, Register ...)

  - ### getPrevious

    public Instruction getPrevious()
    Specified by:
      `getPrevious` in interface `Instruction`
    Returns:
      the instruction before this one in address order or null if none found.

  - ### getPrototype

    public InstructionPrototype getPrototype()
    Specified by:
      `getPrototype` in interface `Instruction`
    Returns:
      the prototype for this instruction.

  - ### getRegister

    public Register getRegister(int opIndex)
    Description copied from interface: `Instruction`
    If operand is a pure Register, return the register.
    Specified by:
      `getRegister` in interface `Instruction`
    Parameters:
      `opIndex` - index of the operand.
    Returns:
      A register if the operand represents a register.

  - ### getInputObjects

    public Object[] getInputObjects()
    Description copied from interface: `Instruction`
    Get the Input objects used by this instruction. These could be Scalars, Registers, Addresses
    Specified by:
      `getInputObjects` in interface `Instruction`
    Returns:
      an array of objects that are used by this instruction

  - ### getResultObjects

    public Object[] getResultObjects()
    Description copied from interface: `Instruction`
    Get the Result objects produced/affected by this instruction These would probably only be Register or Address
    Specified by:
      `getResultObjects` in interface `Instruction`
    Returns:
      an array of objects that are affected by this instruction

  - ### isInDelaySlot

    public boolean isInDelaySlot()
    Specified by:
      `isInDelaySlot` in interface `Instruction`
    Returns:
      true if this instruction was disassembled in a delay slot

  - ### getAddress

    public Address getAddress(int opIndex)
    Description copied from interface: `CodeUnit`
    Get the Address for the given operand index if one exists. Data objects have one operand (the value).
    Specified by:
      `getAddress` in interface `CodeUnit`
    Parameters:
      `opIndex` - index of the operand.
    Returns:
      An address if the operand represents a fully qualified address (given the context), or if the operand is a Scalar treated as an address. Null is returned if no address or scalar exists on that operand.

  - ### toString

    public String toString()
    Returns a string that represents this code unit with default markup. Only the mnemonic and operands are included.

  - ### getMnemonicString

    public String getMnemonicString()
    Description copied from interface: `CodeUnit`
    Returns the mnemonic for this code unit, e.g., MOV, JMP.
    Specified by:
      `getMnemonicString` in interface `CodeUnit`
    Returns:
      the mnemonic for this code unit, e.g., MOV, JMP

  - ### getNumOperands

    public int getNumOperands()
    Description copied from interface: `CodeUnit`
    Returns the number of operands for this code unit..
    Specified by:
      `getNumOperands` in interface `CodeUnit`
    Returns:
      the number of operands for this code unit.

  - ### getScalar

    public Scalar getScalar(int opIndex)
    Description copied from interface: `CodeUnit`
    Returns the scalar at the given operand index. Data objects have one operand (the value).
    Specified by:
      `getScalar` in interface `CodeUnit`
    Parameters:
      `opIndex` - index of the operand.
    Returns:
      the scalar at the given operand index or null if no scalar exists at that index.

  - ### equals

    public boolean equals(Object obj)
    Return true if obj is equal to this.

  - ### getFlowOverride

    public FlowOverride getFlowOverride()
    Specified by:
      `getFlowOverride` in interface `Instruction`
    Returns:
      the flow override which may have been set on this instruction.

  - ### setFlowOverride

    public void setFlowOverride(FlowOverride flow)
    Description copied from interface: `Instruction`
    Set the flow override for this instruction.
    Specified by:
      `setFlowOverride` in interface `Instruction`
    Parameters:
      `flow` - flow override setting or `FlowOverride.NONE` to clear.

  - ### getPcode

    public PcodeOp[] getPcode()
    Description copied from interface: `Instruction`
    Get an array of PCode operations (micro code) that this instruction performs. Flow overrides are not factored into pcode.
    Specified by:
      `getPcode` in interface `Instruction`
    Returns:
      an array of Pcode operations, a zero length array if the language does not support PCode

  - ### getPcode

    public PcodeOp[] getPcode(boolean includeOverrides)
    Description copied from interface: `Instruction`
    Get an array of PCode operations (micro code) that this instruction performs. NOTE: If includeOverrides is true, unique temporary varnodes may be produced which vary in size to those produced for other instructions.
    Specified by:
      `getPcode` in interface `Instruction`
    Parameters:
      `includeOverrides` - if true any flow overrides will be factored into generated pcode.
    Returns:
      an array of Pcode operations, a zero length array if the language does not support PCode

  - ### getPcode

    public PcodeOp[] getPcode(int opIndex)
    Description copied from interface: `Instruction`
    Get an array of PCode operations (micro code) that a particular operand performs to compute its value.
    Specified by:
      `getPcode` in interface `Instruction`
    Parameters:
      `opIndex` - index of the operand to retrieve PCode
    Returns:
      an array of PCode operations, a zero length array if the language does not support PCode

  - ### isFallThroughOverridden

    public boolean isFallThroughOverridden()
    Specified by:
      `isFallThroughOverridden` in interface `Instruction`
    Returns:
      true if this instructions fallthrough has been overriden.

  - ### clearFallThroughOverride

    public void clearFallThroughOverride()
    Description copied from interface: `Instruction`
    Restores this instruction's fallthrough address back to the default fallthrough for this instruction.
    Specified by:
      `clearFallThroughOverride` in interface `Instruction`

  - ### setFallThrough

    public void setFallThrough(Address fallThroughAddr)
    Description copied from interface: `Instruction`
    Overrides the instruction's default fallthrough address to the given address. The given address may be null to indicate that the instruction has no fallthrough.
    Specified by:
      `setFallThrough` in interface `Instruction`
    Parameters:
      `fallThroughAddr` - the address to be used as this instructions fallthrough address. May be null.

  - ### setLengthOverride

    public void setLengthOverride(int len) throws CodeUnitInsertionException
    Description copied from interface: `Instruction`
    Set instruction length override. Specified length must be in the range 0..7 where 0 clears the setting and adopts the default length. The specified length must be less than the actual number of bytes consumed by the prototype and be a multiple of the language specified instruction alignment.

    NOTE: Use of the feature with a delay slot instruction is discouraged.

    Specified by:
      `setLengthOverride` in interface `Instruction`
    Parameters:
      `len` - effective instruction code unit length.
    Throws:
      `CodeUnitInsertionException` - if expanding instruction length conflicts with another instruction or length is not a multiple of the language specified instruction alignment.

  - ### checkLengthOverride

    public static int checkLengthOverride(int length, InstructionPrototype prototype) throws IllegalArgumentException, CodeUnitInsertionException
    Check and revise a specified `length` to arrive at a suitable length-override value.
    Parameters:
      `length` - instruction byte-length (must be in the range 0..`prototype-length`). If smaller than the prototype length it must have a value no greater than 7, otherwise an error will be thrown. A value of 0 or greater-than-or-equal the prototype length will be ignored and not impose and override length. The length value must be a multiple of the `instruction alignment` .
      `prototype` - instruction prototype
    Returns:
      length-override value (0 = disable length-override)
    Throws:
      `CodeUnitInsertionException` - thrown if the new Instruction would overlap and existing `CodeUnit` or the specified `length` is unsupported.
      `IllegalArgumentException` - if a negative `length` is specified.

  - ### isLengthOverridden

    public boolean isLengthOverridden()
    Description copied from interface: `Instruction`
    Determine if an instruction length override has been set.
    Specified by:
      `isLengthOverridden` in interface `Instruction`
    Returns:
      true if length override has been set else false.

  - ### getDefaultFallThrough

    public Address getDefaultFallThrough()
    Description copied from interface: `Instruction`
    Get the default fallthrough for this instruction. This accounts for any instructions contained with delay slots.
    Specified by:
      `getDefaultFallThrough` in interface `Instruction`
    Returns:
      fall-through address or null if instruction has no default fallthrough

  - ### getDefaultFallThroughOffset

    public int getDefaultFallThroughOffset()
    Description copied from interface: `Instruction`
    Get default fall-through offset in bytes from start of instruction to the fallthrough instruction. This accounts for any instructions contained with delay slots.
    Specified by:
      `getDefaultFallThroughOffset` in interface `Instruction`
    Returns:
      default fall-through offset or zero (0) if instruction has no fallthrough

  - ### hasFallthrough

    public boolean hasFallthrough()
    Specified by:
      `hasFallthrough` in interface `Instruction`
    Returns:
      true if this instruction has a fall-through flow.

  - ### isFallthrough

    public boolean isFallthrough()
    Specified by:
      `isFallthrough` in interface `Instruction`
    Returns:
      true if this instruction has no execution flow other than fall-through.

  - ### getProcessorContext

    public ProcessorContextView getProcessorContext()
    Description copied from interface: `InstructionContext`
    Get the read-only processor context containing the context-register state state at the corresponding instruction. This is primarily used during the parse phase to provide the initial context-register state.
    Specified by:
      `getProcessorContext` in interface `InstructionContext`
    Returns:
      the read-only processor context

  - ### getMemBuffer

    public MemBuffer getMemBuffer()
    Description copied from interface: `InstructionContext`
    Get the read-only memory buffer containing the instruction bytes. Its position will correspond to the instruction address.
    Specified by:
      `getMemBuffer` in interface `InstructionContext`
    Returns:
      instruction memory buffer

  - ### getParserContext

    public ParserContext getParserContext() throws MemoryAccessException
    Description copied from interface: `InstructionContext`
    Get the instruction parser context for the instruction which corresponds to this context object.
    Specified by:
      `getParserContext` in interface `InstructionContext`
    Returns:
      the instruction parser context for the instruction which corresponds to this context object.
    Throws:
      `MemoryAccessException` - if memory error occurred while resolving instruction details.

  - ### getInstructionContext

    public InstructionContext getInstructionContext()
    Specified by:
      `getInstructionContext` in interface `Instruction`
    Returns:
      the instruction context for this instruction

  - ### getParserContext

    public ParserContext getParserContext(Address instructionAddress) throws UnknownContextException, MemoryAccessException
    Description copied from interface: `InstructionContext`
    Get the instruction parser context which corresponds to the specified instruction address. This may be obtained via either caching or by parsing the instruction at the specified address. The returned ParserContext may be cast to the prototype's implementation without checking. This method will throw an UnknownContextException if a compatible ParserContext is not found at the specified address.
    Specified by:
      `getParserContext` in interface `InstructionContext`
    Parameters:
      `instructionAddress` - instruction address of requested context
    Returns:
      the instruction parser context at the specified instruction address
    Throws:
      `UnknownContextException` - if the instruction at the specified address was not previously parsed or attempting to instantiate context resulted in an exception.
      `MemoryAccessException` - if memory error occurred while resolving instruction details.

  - ### refresh

    protected boolean refresh()
    Description copied from class: `DatabaseObject`
    Tells the object to refresh its state from the database.
    Specified by:
      `refresh` in class `DatabaseObject`
    Returns:
      true if the object was able to refresh itself. Return false if the object was deleted. Objects that extend this class must implement a refresh method. If an object can never refresh itself, then it should always return false.

  - ### addMnemonicReference

    public void addMnemonicReference(Address refAddr, RefType refType, SourceType sourceType)
    Description copied from interface: `CodeUnit`
    Add a reference to the mnemonic for this code unit.
    Specified by:
      `addMnemonicReference` in interface `CodeUnit`
    Parameters:
      `refAddr` - address to add as a reference.
      `refType` - the type of reference to add.
      `sourceType` - the source of this reference

  - ### addOperandReference

    public void addOperandReference(int opIndex, Address refAddr, RefType type, SourceType sourceType)
    Description copied from interface: `CodeUnit`
    Add a memory reference to the operand at the given index.
    Specified by:
      `addOperandReference` in interface `CodeUnit`
    Parameters:
      `opIndex` - operand index
      `refAddr` - reference address
      `type` - the reference type to be added.
      `sourceType` - the source of this reference
    See Also:
      - `CodeUnit.addOperandReference(int, ghidra.program.model.address.Address, ghidra.program.model.symbol.RefType, SourceType)`

  - ### compareTo

    public int compareTo(Address a)
    Description copied from interface: `CodeUnit`
    Compares the given address to the address range of this node.
    Specified by:
      `compareTo` in interface `CodeUnit`
    Parameters:
      `a` - address to compare.
    Returns:
      a negative integer if this addr is greater than the maximum range address zero if addr is in the range a positive integer if addr is less than minimum range address

  - ### contains

    public boolean contains(Address testAddr)
    Description copied from interface: `CodeUnit`
    Returns true if address is contained in the range of this codeUnit.
    Specified by:
      `contains` in interface `CodeUnit`
    Parameters:
      `testAddr` - the address to test.
    Returns:
      true if address is contained in the range of this codeUnit

  - ### getAddressString

    public String getAddressString(boolean showBlockName, boolean pad)
    Description copied from interface: `CodeUnit`
    Get the string representation of the starting address for this code unit.
    Specified by:
      `getAddressString` in interface `CodeUnit`
    Parameters:
      `showBlockName` - true if the string should include the memory block name
      `pad` - if true, the address will be padded with leading zeros. Even if pad is false, the string will be padded to make the address string contain at least 4 digits.
    Returns:
      string representation of address

  - ### isBigEndian

    public boolean isBigEndian()
    Description copied from interface: `MemBuffer`
    Returns true if the underlying bytes are in big-endian order, false if they are little endian.
    Specified by:
      `isBigEndian` in interface `MemBuffer`
    Returns:
      true if the underlying bytes are in big-endian order, false if they are little endian.

  - ### getShort

    public short getShort(int offset) throws MemoryAccessException
    Description copied from interface: `MemBuffer`
    returns the short at the given offset, taking into account the endianness.
    Specified by:
      `getShort` in interface `MemBuffer`
    Parameters:
      `offset` - the offset from the membuffers origin (the address that it is set at)
    Returns:
      the short at the given offset, taking into account the endianness.
    Throws:
      `MemoryAccessException` - if a 2-byte short value cannot be read at the specified offset

  - ### getInt

    public int getInt(int offset) throws MemoryAccessException
    Description copied from interface: `MemBuffer`
    returns the int at the given offset, taking into account the endianness.
    Specified by:
      `getInt` in interface `MemBuffer`
    Parameters:
      `offset` - the offset from the membuffers origin (the address that it is set at)
    Returns:
      the int at the given offset, taking into account the endianness.
    Throws:
      `MemoryAccessException` - if a 4-byte integer value cannot be read at the specified offset

  - ### getLong

    public long getLong(int offset) throws MemoryAccessException
    Description copied from interface: `MemBuffer`
    returns the long at the given offset, taking into account the endianness.
    Specified by:
      `getLong` in interface `MemBuffer`
    Parameters:
      `offset` - the offset from the membuffers origin (the address that it is set at)
    Returns:
      the long at the given offset, taking into account the endianness.
    Throws:
      `MemoryAccessException` - if a 8-byte long value cannot be read at the specified offset

  - ### getBigInteger

    public BigInteger getBigInteger(int offset, int size, boolean signed) throws MemoryAccessException
    Description copied from interface: `MemBuffer`
    returns the value at the given offset, taking into account the endianness.
    Specified by:
      `getBigInteger` in interface `MemBuffer`
    Parameters:
      `offset` - the offset from the membuffers origin (the address that it is set at)
      `size` - the number of bytes to include in the value
      `signed` - true if value should be treated as a signed twos-compliment value.
    Returns:
      the value at the given offset, taking into account the endianness.
    Throws:
      `MemoryAccessException` - if the request size value cannot be read at the specified offset

  - ### getComment

    public String getComment(CommentType commentType)
    Description copied from interface: `CodeUnit`
    Get the comment for the given type
    Specified by:
      `getComment` in interface `CodeUnit`
    Parameters:
      `commentType` - `comment type`
    Returns:
      the comment string of the appropriate type or null if no comment of that type exists for this code unit

  - ### getCommentAsArray

    public String[] getCommentAsArray(CommentType commentType)
    Description copied from interface: `CodeUnit`
    Get the comment for the given type and parse it into an array of strings such that each line is its own string.
    Specified by:
      `getCommentAsArray` in interface `CodeUnit`
    Parameters:
      `commentType` - `comment type`
    Returns:
      an array of strings where each item in the array is a line of text in the comment. If there is no comment of the requested type, an empty array is returned.

  - ### getExternalReference

    public ExternalReference getExternalReference(int opIndex)
    Description copied from interface: `CodeUnit`
    Gets the external reference (if any) at the opIndex
    Specified by:
      `getExternalReference` in interface `CodeUnit`
    Parameters:
      `opIndex` - the operand index to look for external references
    Returns:
      the external reference at the operand or null if none exists.

  - ### getIntProperty

    public int getIntProperty(String name) throws NoValueException
    Description copied from interface: `PropertySet`
    Get the int property for name.
    Specified by:
      `getIntProperty` in interface `PropertySet`
    Parameters:
      `name` - the name of the property
    Returns:
      integer property value property has been set
    Throws:
      `NoValueException` - if there is not name property for this code unit

  - ### getLabel

    public String getLabel()
    Description copied from interface: `CodeUnit`
    Returns the label for this code unit..
    Specified by:
      `getLabel` in interface `CodeUnit`
    Returns:
      the label for this code unit.

  - ### getLength

    public int getLength()
    Description copied from interface: `CodeUnit`
    Get length of this code unit. NOTE: If an `instruction length-override` is set this method will return the reduced length.
    Specified by:
      `getLength` in interface `CodeUnit`
    Returns:
      code unit length

  - ### getMaxAddress

    public Address getMaxAddress()
    Description copied from interface: `CodeUnit`
    Returns the ending address for this code unit..
    Specified by:
      `getMaxAddress` in interface `CodeUnit`
    Returns:
      the ending address for this code unit.

  - ### getMinAddress

    public Address getMinAddress()
    Description copied from interface: `CodeUnit`
    Returns the starting address for this code unit..
    Specified by:
      `getMinAddress` in interface `CodeUnit`
    Returns:
      the starting address for this code unit.

  - ### getAddress

    public Address getAddress()
    Description copied from interface: `MemBuffer`
    Get the Address which corresponds to the offset 0.
    Specified by:
      `getAddress` in interface `MemBuffer`
    Returns:
      the current address of offset 0.

  - ### getMnemonicReferences

    public Reference[] getMnemonicReferences()
    Description copied from interface: `CodeUnit`
    Get references for the mnemonic for this code unit.
    Specified by:
      `getMnemonicReferences` in interface `CodeUnit`
    Returns:
      an array of memory references. A zero length array will be returned if there are no references for the mnemonic.

  - ### getObjectProperty

    public Saveable getObjectProperty(String name)
    Description copied from interface: `PropertySet`
    Get the object property for name; returns null if there is no name property for this code unit.
    Specified by:
      `getObjectProperty` in interface `PropertySet`
    Parameters:
      `name` - the name of the property
    Returns:
      `Saveable` property value, with map-specific implementation class, or null.

  - ### getOperandReferences

    public Reference[] getOperandReferences(int opIndex)
    Description copied from interface: `CodeUnit`
    Returns the references for the operand index..
    Specified by:
      `getOperandReferences` in interface `CodeUnit`
    Parameters:
      `opIndex` - operand index (0 is the first operand)
    Returns:
      the references for the operand index.

  - ### getPrimaryReference

    public Reference getPrimaryReference(int index)
    Description copied from interface: `CodeUnit`
    Returns the primary reference for the operand index..
    Specified by:
      `getPrimaryReference` in interface `CodeUnit`
    Parameters:
      `index` - operand index (0 is the first operand)
    Returns:
      the primary reference for the operand index.

  - ### getPrimarySymbol

    public Symbol getPrimarySymbol()
    Description copied from interface: `CodeUnit`
    Returns the Primary Symbol for this code unit..
    Specified by:
      `getPrimarySymbol` in interface `CodeUnit`
    Returns:
      the Primary Symbol for this code unit.

  - ### getProgram

    public Program getProgram()
    Description copied from interface: `CodeUnit`
    Returns the program that generated this CodeUnit..
    Specified by:
      `getProgram` in interface `CodeUnit`
    Returns:
      the program that generated this CodeUnit.

  - ### getReferencesFrom

    public Reference[] getReferencesFrom()
    Description copied from interface: `CodeUnit`
    Get ALL memory references FROM this code unit.
    Specified by:
      `getReferencesFrom` in interface `CodeUnit`
    Returns:
      an array of memory references from this codeUnit or an empty array if there are no references.

  - ### getReferenceIteratorTo

    public ReferenceIterator getReferenceIteratorTo()
    Description copied from interface: `CodeUnit`
    Returns an iterator over all references TO this code unit..
    Specified by:
      `getReferenceIteratorTo` in interface `CodeUnit`
    Returns:
      an iterator over all references TO this code unit.

  - ### getStringProperty

    public String getStringProperty(String name)
    Description copied from interface: `PropertySet`
    Get the string property for name; returns null if there is no name property for this code unit.
    Specified by:
      `getStringProperty` in interface `PropertySet`
    Parameters:
      `name` - the name of the property
    Returns:
      string property value or null

  - ### getSymbols

    public Symbol[] getSymbols()
    Description copied from interface: `CodeUnit`
    Returns the Symbols for this code unit..
    Specified by:
      `getSymbols` in interface `CodeUnit`
    Returns:
      the Symbols for this code unit.

  - ### getVoidProperty

    public boolean getVoidProperty(String name)
    Description copied from interface: `PropertySet`
    Returns whether this code unit is marked as having the name property.
    Specified by:
      `getVoidProperty` in interface `PropertySet`
    Parameters:
      `name` - the name of the property
    Returns:
      true if property has been set, else false

  - ### hasProperty

    public boolean hasProperty(String name)
    Description copied from interface: `PropertySet`
    Returns true if the codeunit has the given property defined. This method works for all property map types.
    Specified by:
      `hasProperty` in interface `PropertySet`
    Parameters:
      `name` - the name of the property
    Returns:
      true if property has been set, else false

  - ### propertyNames

    public Iterator<String> propertyNames()
    Description copied from interface: `PropertySet`
    Get an iterator over the property names which have values applied.
    Specified by:
      `propertyNames` in interface `PropertySet`
    Returns:
      iterator of all property map names which have values applied

  - ### removeExternalReference

    public void removeExternalReference(int opIndex)
    Description copied from interface: `CodeUnit`
    Remove external reference (if any) at the given opIndex
    Specified by:
      `removeExternalReference` in interface `CodeUnit`
    Parameters:
      `opIndex` - the index of the operand from which to remove any external reference.

  - ### removeMnemonicReference

    public void removeMnemonicReference(Address refAddr)
    Description copied from interface: `CodeUnit`
    Remove a reference to the mnemonic for this code unit.
    Specified by:
      `removeMnemonicReference` in interface `CodeUnit`
    Parameters:
      `refAddr` - the address to remove as a reference.

  - ### removeOperandReference

    public void removeOperandReference(int opIndex, Address refAddr)
    Description copied from interface: `CodeUnit`
    Remove a reference to the operand.
    Specified by:
      `removeOperandReference` in interface `CodeUnit`
    Parameters:
      `opIndex` - operand index
      `refAddr` - address referencing the operand

  - ### removeProperty

    public void removeProperty(String name)
    Description copied from interface: `PropertySet`
    Remove the property value associated with the given name .
    Specified by:
      `removeProperty` in interface `PropertySet`
    Parameters:
      `name` - the name of the property

  - ### setComment

    public void setComment(CommentType commentType, String comment)
    Description copied from interface: `CodeUnit`
    Set the comment for the given comment type. Passing `null` clears the comment
    Specified by:
      `setComment` in interface `CodeUnit`
    Parameters:
      `commentType` - `comment type`
      `comment` - comment for code unit; null clears the comment

  - ### setCommentAsArray

    public void setCommentAsArray(CommentType commentType, String[] comment)
    Description copied from interface: `CodeUnit`
    Set the comment (with each line in its own string) for the given comment type
    Specified by:
      `setCommentAsArray` in interface `CodeUnit`
    Parameters:
      `commentType` - `comment type`
      `comment` - an array of strings where each string is a single line of the comment.

  - ### setPrimaryMemoryReference

    public void setPrimaryMemoryReference(Reference ref)
    Description copied from interface: `CodeUnit`
    Sets a memory reference to be the primary reference at its address/opIndex location. The primary reference is the one that is used in the getOperandRepresentation() method.
    Specified by:
      `setPrimaryMemoryReference` in interface `CodeUnit`
    Parameters:
      `ref` - the reference to be set as primary.

  - ### setProperty

    public void setProperty(String name, int value)
    Description copied from interface: `PropertySet`
    Set the named integer property with the given value.
    Specified by:
      `setProperty` in interface `PropertySet`
    Parameters:
      `name` - the name of the property.
      `value` - value to be stored.

  - ### setProperty

    public <T extends Saveable> void setProperty(String name, T value)
    Description copied from interface: `PropertySet`
    Set the named property with the given `Saveable` value.
    Specified by:
      `setProperty` in interface `PropertySet`
    Type Parameters:
      `T` - `Saveable` implementation
    Parameters:
      `name` - the name of the property.
      `value` - value to be stored.

  - ### setProperty

    public void setProperty(String name, String value)
    Description copied from interface: `PropertySet`
    Set the named string property with the given value.
    Specified by:
      `setProperty` in interface `PropertySet`
    Parameters:
      `name` - the name of the property.
      `value` - value to be stored.

  - ### setProperty

    public void setProperty(String name)
    Description copied from interface: `PropertySet`
    Set the named property. This method is used for "void" properites. The property is either set or not set - there is no value
    Specified by:
      `setProperty` in interface `PropertySet`
    Parameters:
      `name` - the name of the property.

  - ### setStackReference

    public void setStackReference(int opIndex, int offset, SourceType sourceType, RefType refType)
    Description copied from interface: `CodeUnit`
    Sets a stack reference at the `offset` on the specified operand index, which effectively substitutes the previous operation interpretation
    NOTE: If another reference was previously set on the operand, then it will be replaced with this stack reference
    Specified by:
      `setStackReference` in interface `CodeUnit`
    Parameters:
      `opIndex` - the index of the operand to set this stack reference
      `offset` - the (+/-) offset from stack base address
      `sourceType` - the source of this reference
      `refType` - type of reference, RefType.READ,WRITE,PTR...

  - ### setRegisterReference

    public void setRegisterReference(int opIndex, Register reg, SourceType sourceType, RefType refType)
    Description copied from interface: `CodeUnit`
    Sets a register reference at the `offset` on the specified operand index, which effectively substitutes the previous operation interpretation
    NOTE: If another reference was previously set on the operand, then it will be replaced with this register reference
    Specified by:
      `setRegisterReference` in interface `CodeUnit`
    Parameters:
      `opIndex` - the index of the operand to set this register reference
      `reg` - a register
      `sourceType` - the source of this reference
      `refType` - type of reference, RefType.READ,WRITE,PTR...

  - ### getBytes

    public int getBytes(byte[] b, int offset)
    Description copied from interface: `MemBuffer`
    Reads `b.length` bytes from this memory buffer starting at the address of this memory buffer plus the given memoryBufferOffset from that position. The actual number of bytes may be fewer if bytes can't be read.
    Specified by:
      `getBytes` in interface `MemBuffer`
    Parameters:
      `b` - the buffer into which bytes will be placed
      `offset` - the offset in this memory buffer from which to start reading bytes.
    Returns:
      the number of bytes read which may be fewer than b.length if available bytes are exhausted or no bytes are available at the specified offset.

  - ### getBytes

    public byte[] getBytes() throws MemoryAccessException
    Description copied from interface: `CodeUnit`
    Get the bytes that make up this code unit. NOTE: If an `instruction length-override` is set this method will not return all bytes associated with the `instruction prototype`.
    Specified by:
      `getBytes` in interface `CodeUnit`
    Returns:
      an array of bytes that are in memory at the codeunits address. The array length is the same as the codeUnits length
    Throws:
      `MemoryAccessException` - if the full number of bytes could not be read.

  - ### getByte

    public byte getByte(int offset) throws MemoryAccessException
    Description copied from interface: `MemBuffer`
    Get one byte from memory at the current position plus offset.
    Specified by:
      `getByte` in interface `MemBuffer`
    Parameters:
      `offset` - the displacement from the current position.
    Returns:
      the data at offset from the current position.
    Throws:
      `MemoryAccessException` - if memory cannot be read at the specified offset

  - ### getMemory

    public Memory getMemory()
    Description copied from interface: `MemBuffer`
    Get the Memory object actually used by the MemBuffer.
    Specified by:
      `getMemory` in interface `MemBuffer`
    Returns:
      the Memory used by this MemBuffer or null if not available.

  - ### getValue

    public BigInteger getValue(Register register, boolean signed)
    Description copied from interface: `ProcessorContextView`
    Get the contents of a processor register as a BigInteger object
    Specified by:
      `getValue` in interface `ProcessorContextView`
    Parameters:
      `register` - register to get the value for
    Returns:
      a BigInteger object containing the value of the register if a value exists, otherwise null.

  - ### getRegisterValue

    public RegisterValue getRegisterValue(Register register)
    Description copied from interface: `ProcessorContextView`
    Get the RegisterValue for the given register.
    Specified by:
      `getRegisterValue` in interface `ProcessorContextView`
    Parameters:
      `register` - register to get the value for
    Returns:
      RegisterValue object containing the value of the register if a value exists, otherwise null.

  - ### setValue

    public void setValue(Register register, BigInteger value) throws ContextChangeException
    Description copied from interface: `ProcessorContext`
    Sets the value for a Register.
    Specified by:
      `setValue` in interface `ProcessorContext`
    Parameters:
      `register` - the register to have its value set
      `value` - the value for the register (null is not permitted).
    Throws:
      `ContextChangeException` - an illegal attempt to change context was made

  - ### clearRegister

    public void clearRegister(Register register) throws ContextChangeException
    Description copied from interface: `ProcessorContext`
    Clears the register within this context.
    Specified by:
      `clearRegister` in interface `ProcessorContext`
    Parameters:
      `register` - register to be cleared.
    Throws:
      `ContextChangeException` - an illegal attempt to change context was made

  - ### setRegisterValue

    public void setRegisterValue(RegisterValue value) throws ContextChangeException
    Description copied from interface: `ProcessorContext`
    Sets the specified register value within this context.
    Specified by:
      `setRegisterValue` in interface `ProcessorContext`
    Parameters:
      `value` - register value
    Throws:
      `ContextChangeException` - an illegal attempt to change context was made

  - ### getRegister

    public Register getRegister(String name)
    Description copied from interface: `ProcessorContextView`
    Get a Register given the name of a register
    Specified by:
      `getRegister` in interface `ProcessorContextView`
    Parameters:
      `name` - the name of the register.
    Returns:
      The register with the given name.

  - ### getBaseContextRegister

    public Register getBaseContextRegister()
    Specified by:
      `getBaseContextRegister` in interface `ProcessorContextView`
    Returns:
      the base processor context register or null if one has not been defined

  - ### getRegisters

    public List<Register> getRegisters()
    Description copied from interface: `ProcessorContextView`
    Returns all the Registers for the processor as an unmodifiable list
    Specified by:
      `getRegisters` in interface `ProcessorContextView`
    Returns:
      all the Registers for the processor

  - ### hasValue

    public boolean hasValue(Register register)
    Description copied from interface: `ProcessorContextView`
    Returns true if a value is defined for the given register.
    Specified by:
      `hasValue` in interface `ProcessorContextView`
    Parameters:
      `register` - the register to check for a value.
    Returns:
      true if the given register has a value.

  - ### hashCode

    public int hashCode()
    Overrides:
      `hashCode` in class `Object`

  - ### getBytesInCodeUnit

    public void getBytesInCodeUnit(byte[] buffer, int bufferOffset) throws MemoryAccessException
    Description copied from interface: `CodeUnit`
    Copies max(buffer.length, code unit length) bytes into buffer starting at the given offset in `buffer`.
    Specified by:
      `getBytesInCodeUnit` in interface `CodeUnit`
    Parameters:
      `buffer` - byte array to copy into
      `bufferOffset` - offset in byte array the copy will start
    Throws:
      `MemoryAccessException` - if the full number of bytes could not be read.