Package ghidra.pcode.emu.jit.op

# Record Class JitCatenateOp

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

Record Components:
  `out` - the use-def variable node for the output
  `parts` - the inputs to be concatenated

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

public record JitCatenateOp(JitOutVar out, List<JitVal> parts) extends Record implements JitDefOp, JitSyntheticOp
The synthetic use-def node for concatenation.

These are synthesized when memory/register access patterns cause multiple use-def variable nodes to be "read" at the same time. E.g., consider `AL` and `AH` to be written and then `AX` read.

- ## Constructor Summary

  Constructors
  Constructor
  Description
  `JitCatenateOp(JitOutVar out, List<JitVal> parts)`
  Compact constructor for validation

- ## Method Summary

  Modifier and Type
  Method
  Description
  `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
  `Iterable<JitVal>`
  `iterParts(boolean bigEndian)`
  Iterate over the parts from most to least significant
  `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.
  `JitOutVar`
  `out()`
  Returns the value of the `out` record component.
  `List<JitVal>`
  `parts()`
  Returns the value of the `parts` record component.
  `JitTypeBehavior`
  `partType()`
  We'd like every part to be an `int`.
  `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.

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

  - ### JitCatenateOp

    public JitCatenateOp(JitOutVar out, List<JitVal> parts)
    Compact constructor for validation
    Parameters:
      `out` - the use-def variable node for the output
      `parts` - the inputs to be concatenated

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

  - ### iterParts

    public Iterable<JitVal> iterParts(boolean bigEndian)
    Iterate over the parts from most to least significant
    Parameters:
      `bigEndian` - the byte order off the machine
    Returns:
      an iterable over the parts

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

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

  - ### partType

    public JitTypeBehavior partType()
    We'd like every part 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

  - ### 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. All components in this record class are compared with `Objects::equals(Object,Object)`.
    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

  - ### parts

    public List<JitVal> parts()
    Returns the value of the `parts` record component.
    Returns:
      the value of the `parts` record component