Package ghidra.pcode.emu.jit.op

# Record Class JitSynthSubPieceOp

java.lang.Object
java.lang.Record
ghidra.pcode.emu.jit.op.JitSynthSubPieceOp

Record Components:
  `out` - the use-def variable node for the output
  `offset` - the offset, in bytes, to shift right
  `v` - the input use-def value node

All Implemented Interfaces:
  `JitDefOp`, `JitOp`, `JitSyntheticOp`

public record JitSynthSubPieceOp(JitOutVar out, int offset, JitVal v) extends Record implements JitDefOp, JitSyntheticOp
The synthetic use-def node for subpiece.

These are synthesized when memory/register access patterns cause only part of a use-def variable node to be "read." E.g., consider `AX` to be written and then `AL` read. These are different than `JitSubPieceOp` in that the latter have an actual `PcodeOp` associated.

Implementation Notes:
  Bits are shifted to the right by offset bytes. Then bits are truncated from the left to force it to match the out var's size.

- ## Constructor Summary

  Constructors
  Constructor
  Description
  `JitSynthSubPieceOp(JitOutVar out, int offset, JitVal v)`
  Compact constructor for validation.

- ## Method Summary

  Modifier and Type
  Method
  Description
  `boolean`
  `abuts(JitSynthSubPieceOp right)`
  Check if this piece abuts the given piece.
  `final boolean`
  `equals(Object o)`
  Indicates whether some other object is "equal to" this one.
  `final int`
  `hashCode()`
  Returns a hash code value for this object.
  `List<JitVal>`
  `inputs()`
  The input operand use-def nodes in some defined order
  `void`
  `link()`
  Add this op to the `JitVal.uses()` of each input operand, and (if applicable) set the `JitOutVar.definition()` of the output operand to this op.
  `int`
  `offset()`
  Returns the value of the `offset` record component.
  `JitOutVar`
  `out()`
  Returns the value of the `out` record component.
  `final String`
  `toString()`
  Returns a string representation of this record class.
  `JitTypeBehavior`
  `type()`
  The required type behavior for the output
  `JitTypeBehavior`
  `typeFor(int position)`
  Get the required type behavior for the input at the given position in `JitOp.inputs()`
  `void`
  `unlink()`
  Remove this op from the `JitVal.uses()` of each input operand, and (if applicable) unset the `JitOutVar.definition()` of the output operand.
  `JitVal`
  `v()`
  Returns the value of the `v` record component.
  `JitTypeBehavior`
  `vType()`
  We'd like the input to be an `int`.

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

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

  ### Methods inherited from interface ghidra.pcode.emu.jit.op.JitDefOp

  `canBeRemoved`

  ### Methods inherited from interface ghidra.pcode.emu.jit.op.JitSyntheticOp

  `op`

- ## Constructor Details

  - ### JitSynthSubPieceOp

    public JitSynthSubPieceOp(JitOutVar out, int offset, JitVal v)
    Compact constructor for validation.
    Parameters:
      `out` - the use-def variable node for the output
      `offset` - the offset, in bytes, to shift right
      `v` - the input use-def value node

- ## Method Details

  - ### link

    public void link()
    Description copied from interface: `JitOp`
    Add this op to the `JitVal.uses()` of each input operand, and (if applicable) set the `JitOutVar.definition()` of the output operand to this op.
    Specified by:
      `link` in interface `JitDefOp`
    Specified by:
      `link` in interface `JitOp`

  - ### unlink

    public void unlink()
    Description copied from interface: `JitOp`
    Remove this op from the `JitVal.uses()` of each input operand, and (if applicable) unset the `JitOutVar.definition()` of the output operand.
    Specified by:
      `unlink` in interface `JitDefOp`
    Specified by:
      `unlink` in interface `JitOp`

  - ### inputs

    public List<JitVal> inputs()
    Description copied from interface: `JitOp`
    The input operand use-def nodes in some defined order
    Specified by:
      `inputs` in interface `JitOp`
    Returns:
      the list of inputs

  - ### vType

    public JitTypeBehavior vType()
    We'd like the input to be an `int`.
    Returns:
      `JitTypeBehavior.INTEGER`

  - ### type

    public JitTypeBehavior type()
    Description copied from interface: `JitDefOp`
    The required type behavior for the output
    Specified by:
      `type` in interface `JitDefOp`
    Returns:
      the behavior

  - ### typeFor

    public JitTypeBehavior typeFor(int position)
    Description copied from interface: `JitOp`
    Get the required type behavior for the input at the given position in `JitOp.inputs()`
    Specified by:
      `typeFor` in interface `JitOp`
    Parameters:
      `position` - the input position
    Returns:
      the behavior

  - ### abuts

    public boolean abuts(JitSynthSubPieceOp right)
    Check if this piece abuts the given piece.

    To "abut," the pieces must take the same value as input, and then this piece's offset must be exactly the other's offset plus its size. Consider this diagram:

         [this][right]

    We want this piece to be in the more-significant position immediately before the given piece. We thus compute `diff` the difference in offsets and check if that is equal to the size of the right piece. If it is, then we have:

         [offset=x+diff,size=s][offset=x,size=diff]

    And the "whole piece" is

         [offset=x,size=s+diff]

    Parameters:
      `right` - the piece to the right, i.e., less significant
    Returns:
      true if the two pieces can be expressed as one whole

  - ### toString

    public final String toString()
    Returns a string representation of this record class. The representation contains the name of the class, followed by the name and value of each of the record components.
    Specified by:
      `toString` in class `Record`
    Returns:
      a string representation of this object

  - ### hashCode

    public final int hashCode()
    Returns a hash code value for this object. The value is derived from the hash code of each of the record components.
    Specified by:
      `hashCode` in class `Record`
    Returns:
      a hash code value for this object

  - ### equals

    public final boolean equals(Object o)
    Indicates whether some other object is "equal to" this one. The objects are equal if the other object is of the same class and if all the record components are equal. Reference components are compared with `Objects::equals(Object,Object)`; primitive components are compared with '=='.
    Specified by:
      `equals` in class `Record`
    Parameters:
      `o` - the object with which to compare
    Returns:
      `true` if this object is the same as the `o` argument; `false` otherwise.

  - ### out

    public JitOutVar out()
    Returns the value of the `out` record component.
    Specified by:
      `out` in interface `JitDefOp`
    Returns:
      the value of the `out` record component

  - ### offset

    public int offset()
    Returns the value of the `offset` record component.
    Returns:
      the value of the `offset` record component

  - ### v

    public JitVal v()
    Returns the value of the `v` record component.
    Returns:
      the value of the `v` record component