Package ghidra.pcode.emu.jit.gen.op

# Interface BinOpGen<T extends JitBinOp>

Type Parameters:
  `T` - the class of p-code op node in the use-def graph

All Superinterfaces:
  `org.objectweb.asm.Opcodes`, `OpGen<T>`

All Known Subinterfaces:
  `BitwiseBinOpGen<T>`, `CompareFloatOpGen<T>`, `CompareIntBinOpGen<T>`, `FloatBinOpGen<T>`, `IntBinOpGen<T>`, `ShiftIntBinOpGen<T>`

All Known Implementing Classes:
  `BoolAndOpGen`, `BoolOrOpGen`, `BoolXorOpGen`, `FloatAddOpGen`, `FloatDivOpGen`, `FloatEqualOpGen`, `FloatLessEqualOpGen`, `FloatLessOpGen`, `FloatMultOpGen`, `FloatNotEqualOpGen`, `FloatSubOpGen`, `IntAddOpGen`, `IntAndOpGen`, `IntCarryOpGen`, `IntDivOpGen`, `IntEqualOpGen`, `IntLeftOpGen`, `IntLessEqualOpGen`, `IntLessOpGen`, `IntMultOpGen`, `IntNotEqualOpGen`, `IntOrOpGen`, `IntRemOpGen`, `IntRightOpGen`, `IntSBorrowOpGen`, `IntSCarryOpGen`, `IntSDivOpGen`, `IntSLessEqualOpGen`, `IntSLessOpGen`, `IntSRemOpGen`, `IntSRightOpGen`, `IntSubOpGen`, `IntXorOpGen`

public interface BinOpGen<T extends JitBinOp> extends OpGen<T>
An extension that provides conveniences and common implementations for binary p-code operators

- ## Nested Class Summary

  Nested Classes
  Modifier and Type
  Interface
  Description
  `static enum`
  `BinOpGen.TakeOut`
  A choice of static method parameter to take as operator output

- ## Field Summary

  ### Fields inherited from interface org.objectweb.asm.Opcodes

  `AALOAD, AASTORE, ACC_ABSTRACT, ACC_ANNOTATION, ACC_BRIDGE, ACC_DEPRECATED, ACC_ENUM, ACC_FINAL, ACC_INTERFACE, ACC_MANDATED, ACC_MODULE, ACC_NATIVE, ACC_OPEN, ACC_PRIVATE, ACC_PROTECTED, ACC_PUBLIC, ACC_RECORD, ACC_STATIC, ACC_STATIC_PHASE, ACC_STRICT, ACC_SUPER, ACC_SYNCHRONIZED, ACC_SYNTHETIC, ACC_TRANSIENT, ACC_TRANSITIVE, ACC_VARARGS, ACC_VOLATILE, ACONST_NULL, ALOAD, ANEWARRAY, ARETURN, ARRAYLENGTH, ASM10_EXPERIMENTAL, ASM4, ASM5, ASM6, ASM7, ASM8, ASM9, ASTORE, ATHROW, BALOAD, BASTORE, BIPUSH, CALOAD, CASTORE, CHECKCAST, D2F, D2I, D2L, DADD, DALOAD, DASTORE, DCMPG, DCMPL, DCONST_0, DCONST_1, DDIV, DLOAD, DMUL, DNEG, DOUBLE, DREM, DRETURN, DSTORE, DSUB, DUP, DUP_X1, DUP_X2, DUP2, DUP2_X1, DUP2_X2, F_APPEND, F_CHOP, F_FULL, F_NEW, F_SAME, F_SAME1, F2D, F2I, F2L, FADD, FALOAD, FASTORE, FCMPG, FCMPL, FCONST_0, FCONST_1, FCONST_2, FDIV, FLOAD, FLOAT, FMUL, FNEG, FREM, FRETURN, FSTORE, FSUB, GETFIELD, GETSTATIC, GOTO, H_GETFIELD, H_GETSTATIC, H_INVOKEINTERFACE, H_INVOKESPECIAL, H_INVOKESTATIC, H_INVOKEVIRTUAL, H_NEWINVOKESPECIAL, H_PUTFIELD, H_PUTSTATIC, I2B, I2C, I2D, I2F, I2L, I2S, IADD, IALOAD, IAND, IASTORE, ICONST_0, ICONST_1, ICONST_2, ICONST_3, ICONST_4, ICONST_5, ICONST_M1, IDIV, IF_ACMPEQ, IF_ACMPNE, IF_ICMPEQ, IF_ICMPGE, IF_ICMPGT, IF_ICMPLE, IF_ICMPLT, IF_ICMPNE, IFEQ, IFGE, IFGT, IFLE, IFLT, IFNE, IFNONNULL, IFNULL, IINC, ILOAD, IMUL, INEG, INSTANCEOF, INTEGER, INVOKEDYNAMIC, INVOKEINTERFACE, INVOKESPECIAL, INVOKESTATIC, INVOKEVIRTUAL, IOR, IREM, IRETURN, ISHL, ISHR, ISTORE, ISUB, IUSHR, IXOR, JSR, L2D, L2F, L2I, LADD, LALOAD, LAND, LASTORE, LCMP, LCONST_0, LCONST_1, LDC, LDIV, LLOAD, LMUL, LNEG, LONG, LOOKUPSWITCH, LOR, LREM, LRETURN, LSHL, LSHR, LSTORE, LSUB, LUSHR, LXOR, MONITORENTER, MONITOREXIT, MULTIANEWARRAY, NEW, NEWARRAY, NOP, NULL, POP, POP2, PUTFIELD, PUTSTATIC, RET, RETURN, SALOAD, SASTORE, SIPUSH, SOURCE_DEPRECATED, SOURCE_MASK, SWAP, T_BOOLEAN, T_BYTE, T_CHAR, T_DOUBLE, T_FLOAT, T_INT, T_LONG, T_SHORT, TABLESWITCH, TOP, UNINITIALIZED_THIS, V_PREVIEW, V1_1, V1_2, V1_3, V1_4, V1_5, V1_6, V1_7, V1_8, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V9`

- ## Method Summary

  Modifier and Type
  Method
  Description
  `default JitType`
  `afterLeft(JitCodeGenerator gen, T op, JitType lType, JitType rType, org.objectweb.asm.MethodVisitor rv)`
  Emit code between reading the left and right operands
  `default TypeConversions.Ext`
  `ext()`
  When loading and storing variables, the kind of extension to apply
  `JitType`
  `generateBinOpRunCode(JitCodeGenerator gen, T op, JitControlFlowModel.JitBlock block, JitType lType, JitType rType, org.objectweb.asm.MethodVisitor rv)`
  Emit code for the binary operator
  `static void`
  `generateMpDelegationToStaticMethod(JitCodeGenerator gen, JitType.MpIntJitType type, String methodName, org.objectweb.asm.MethodVisitor mv, int overProvisionLeft, BinOpGen.TakeOut takeOut)`
  Emit bytecode that implements an mp-int binary operator via delegation to a static method on `JitCompiledPassage`.
  `default void`
  `generateRunCode(JitCodeGenerator gen, T op, JitControlFlowModel.JitBlock block, org.objectweb.asm.MethodVisitor rv)`
  Emit bytecode into the `run` method.
  `boolean`
  `isSigned()`
  Whether this operator is signed
  `default TypeConversions.Ext`
  `rExt()`
  When loading the right operand, the kind of extension to apply

  ### Methods inherited from interface ghidra.pcode.emu.jit.gen.op.OpGen

  `generateInitCode`

- ## Method Details

  - ### generateMpDelegationToStaticMethod

    static void generateMpDelegationToStaticMethod(JitCodeGenerator gen, JitType.MpIntJitType type, String methodName, org.objectweb.asm.MethodVisitor mv, int overProvisionLeft, BinOpGen.TakeOut takeOut)
    Emit bytecode that implements an mp-int binary operator via delegation to a static method on `JitCompiledPassage`. The method must have the signature:

         void method(int[] out, int[] inL, int[] inR);

    This method presumes that the left operand's legs are at the top of the stack, least-significant leg on top, followed by the right operand legs, also least-significant leg on top. This will allocate the output array, move the operands into their respective input arrays, invoke the method, and then place the result legs on the stack, least-significant leg on top.

    Parameters:
      `gen` - the code generator
      `type` - the type of the operands
      `methodName` - the name of the method in `JitCompiledPassage` to invoke
      `mv` - the method visitor
      `overProvisionLeft` - the number of extra ints to allocate for the left operand's array. This is to facilitate Knuth's division algorithm, which may require an extra leading leg in the dividend after normalization.
      `takeOut` - indicates which operand of the static method to actually take for the output. This is to facilitate the remainder operator, because Knuth's algorithm leaves the remainder where there dividend was.

  - ### isSigned

    boolean isSigned()
    Whether this operator is signed

    In many cases, the operator itself is not affected by the signedness of the operands; however, if size adjustments to the operands are needed, this can determine how those operands are extended.

    Returns:
      true for signed, false if not

  - ### ext

    default TypeConversions.Ext ext()
    When loading and storing variables, the kind of extension to apply
    Returns:
      the extension kind

  - ### rExt

    default TypeConversions.Ext rExt()
    When loading the right operand, the kind of extension to apply
    Returns:
      the extension kind

  - ### afterLeft

    default JitType afterLeft(JitCodeGenerator gen, T op, JitType lType, JitType rType, org.objectweb.asm.MethodVisitor rv)
    Emit code between reading the left and right operands

    This is invoked immediately after emitting code to push the left operand onto the stack, giving the implementation an opportunity to perform any manipulations of that operand necessary to set up the operation, before code to push the right operand is emitted.

    Parameters:
      `gen` - the code generator
      `op` - the operator
      `lType` - the actual type of the left operand
      `rType` - the actual type of the right operand
      `rv` - the method visitor
    Returns:
      the new actual type of the left operand

  - ### generateBinOpRunCode

    JitType generateBinOpRunCode(JitCodeGenerator gen, T op, JitControlFlowModel.JitBlock block, JitType lType, JitType rType, org.objectweb.asm.MethodVisitor rv)
    Emit code for the binary operator

    At this point both operands are on the stack. After this returns, code to write the result from the stack into the destination operand will be emitted.

    Parameters:
      `gen` - the code generator
      `op` - the operator
      `block` - the block containing the operator
      `lType` - the actual type of the left operand
      `rType` - the actual type of the right operand
      `rv` - the method visitor
    Returns:
      the actual type of the result

  - ### generateRunCode

    default void generateRunCode(JitCodeGenerator gen, T op, JitControlFlowModel.JitBlock block, org.objectweb.asm.MethodVisitor rv)
    Emit bytecode into the `run` method.

    This method must emit the code needed to load any input operands, convert them to the appropriate type, perform the actual operation, and then if applicable, store the output operand. The implementations should delegate to `JitCodeGenerator.generateValReadCode(JitVal, JitTypeBehavior, Ext)`, `JitCodeGenerator.generateVarWriteCode(JitVar, JitType, Ext)`, and `TypeConversions` appropriately.

    This default implementation emits code to load the left operand, invokes the `after-left` hook point, emits code to load the right operand, invokes `generate-binop`, and finally emits code to write the destination operand.

    Specified by:
      `generateRunCode` in interface `OpGen<T extends JitBinOp>`
    Parameters:
      `gen` - the code generator
      `op` - the p-code op (use-def node) to translate
      `block` - the basic block containing the p-code op
      `rv` - the visitor for the `run` method.