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

Interface OpGen<T extends JitOp>

Type Parameters:
T - the class of p-code op node in the use-def graph
All Superinterfaces:
org.objectweb.asm.Opcodes
All Known Subinterfaces:
BinOpGen<T>, BitwiseBinOpGen<T>, CompareFloatOpGen<T>, CompareIntBinOpGen<T>, FloatBinOpGen<T>, FloatUnOpGen<T>, IntBinOpGen<T>, IntUnOpGen<T>, ShiftIntBinOpGen<T>, UnOpGen<T>
All Known Implementing Classes:
BoolAndOpGen, BoolNegateOpGen, BoolOrOpGen, BoolXorOpGen, BranchIndOpGen, BranchOpGen, CallOtherMissingOpGen, CallOtherOpGen, CatenateOpGen, CBranchOpGen, CopyOpGen, FloatAbsOpGen, FloatAddOpGen, FloatCeilOpGen, FloatDivOpGen, FloatEqualOpGen, FloatFloat2FloatOpGen, FloatFloorOpGen, FloatInt2FloatOpGen, FloatLessEqualOpGen, FloatLessOpGen, FloatMultOpGen, FloatNaNOpGen, FloatNegOpGen, FloatNotEqualOpGen, FloatRoundOpGen, FloatSqrtOpGen, FloatSubOpGen, FloatTruncOpGen, Int2CompOpGen, IntAddOpGen, IntAndOpGen, IntCarryOpGen, IntDivOpGen, IntEqualOpGen, IntLeftOpGen, IntLessEqualOpGen, IntLessOpGen, IntMultOpGen, IntNegateOpGen, IntNotEqualOpGen, IntOrOpGen, IntRemOpGen, IntRightOpGen, IntSBorrowOpGen, IntSCarryOpGen, IntSDivOpGen, IntSExtOpGen, IntSLessEqualOpGen, IntSLessOpGen, IntSRemOpGen, IntSRightOpGen, IntSubOpGen, IntXorOpGen, IntZExtOpGen, LoadOpGen, LzCountOpGen, NopOpGen, PhiOpGen, PopCountOpGen, StoreOpGen, SubPieceOpGen, SynthSubPieceOpGen, UnimplementedOpGen
public interface OpGen<T extends JitOp> extends org.objectweb.asm.Opcodes
The bytecode generator for a specific p-code op

The JitCodeGenerator selects the correct generator for each PcodeOp using JitDataFlowModel.getJitOp(PcodeOp) and lookup(JitOp). The following table lists each p-code op, its use-def class, its generator class, and a brief strategy for its bytecode implementation.

P-code Op Use-Def Type Generator Type Bytecodes / Methods
Misc Data
unimplemented JitUnimplementedOp UnimplementedOpGen new, athrow
copy JitCopyOp CopyOpGen none; defers to VarGen
load JitLoadOp LoadOpGen JitCompiledPassage.readIntLE4(byte[], int), etc.
store JitStoreOp StoreOpGen JitCompiledPassage.writeIntLE4(int, byte[], int), etc.
Control Flow
branch,
call		 JitBranchOp BranchOpGen goto, areturn
cbranch JitCBranchOp CBranchOpGen ifeq, ifne, goto, areturn
branchind,
callind,
return		 JitBranchIndOp BranchIndOpGen areturn
callother JitCallOtherOp,
JitCallOtherDefOp,
JitCallOtherMissingOp,
JitNopOp		 CallOtherOpGen,
CallOtherMissingOpGen,
NopOpGen		 See JitDataFlowUseropLibrary:
Integer Comparison
int_equal JitIntEqualOp IntEqualOpGen if_icmpeq, ifeq
int_notequal JitIntNotEqualOp IntNotEqualOpGen if_icmpne, ifne
int_sless JitIntSLessOp IntSLessOpGen if_icmplt, iflt
int_slessequal JitIntSLessEqualOp IntSLessEqualOpGen if_icmple, ifle
int_less JitIntLessOp IntLessOpGen Integer.compareUnsigned(int, int), iflt, etc.
int_lessequal JitIntLessEqualOp IntLessEqualOpGen Integer.compareUnsigned(int, int), ifle, etc.
Integer Arithmetic
int_zext JitIntZExtOp IntZExtOpGen none; defers to VarGen and TypeConversions
int_sext JitIntSExtOp IntSExtOpGen ishl, ishr, etc.
int_add JitIntAddOp IntAddOpGen iadd, ladd
int_sub JitIntSubOp IntSubOpGen isub, lsub
int_carry JitIntCarryOp IntCarryOpGen Integer.compareUnsigned(int, int), iadd, ishr, etc.
int_scarry JitIntSCarryOp IntSCarryOpGen JitCompiledPassage.sCarryIntRaw(int, int), ishr, etc.
int_sborrow JitIntSBorrowOp IntSBorrowOpGen JitCompiledPassage.sBorrowIntRaw(int, int), ishr, etc.
int_2comp JitInt2CompOp Int2CompOpGen ineg, lneg
int_negate JitIntNegateOp IntNegateOpGen iconst_m1, ixor, etc.
int_xor JitIntXorOp IntXorOpGen ixor, lxor
int_and JitIntAndOp IntAndOpGen iand, land
int_or JitIntOrOp IntOrOpGen ior, lor
int_left JitIntLeftOp IntLeftOpGen JitCompiledPassage.intLeft(int, int), etc.
int_right JitIntRightOp IntRightOpGen JitCompiledPassage.intRight(int, int), etc.
int_sright JitIntSRightOp IntSRightOpGen JitCompiledPassage.intSRight(int, int), etc.
int_mult JitIntMultOp IntMultOpGen imul, lmul
int_div JitIntDivOp IntDivOpGen Integer.divideUnsigned(int, int), etc.
int_sdiv JitIntSDivOp IntSDivOpGen idiv, ldiv
int_rem JitIntRemOp IntRemOpGen Integer.remainderUnsigned(int, int), etc.
int_srem JitIntSRemOp IntSRemOpGen irem, lrem
Boolean Logic
bool_negate JitBoolNegateOp BoolNegateOpGen Conditional jumps to ldc 0 or 1
bool_xor JitBoolXorOp BoolXorOpGen Conditional jumps to ldc 0 or 1
bool_and JitBoolAndOp BoolAndOpGen Conditional jumps to ldc 0 or 1
bool_or JitBoolOrOp BoolOrOpGen Conditional jumps to ldc 0 or 1
Float Comparison
float_equal JitFloatEqualOp FloatEqualOpGen fcmpl, dcmpl, ifeq
float_notequal JitFloatNotEqualOp FloatNotEqualOpGen fcmpl, dcmpl, ifne
float_less JitFloatLessOp FloatLessOpGen fcmpg, dcmpg, iflt
float_lessequal JitFloatLessEqualOp FloatLessEqualOpGen fcmpg, dcmpg, ifle
float_nan JitFloatNaNOp FloatNaNOpGen Float.isNaN(float), Double.isNaN(double)
Float Arithmetic
float_add JitFloatAddOp FloatAddOpGen fadd, dadd
float_div JitFloatDivOp FloatDivOpGen fdiv, ddiv
float_mult JitFloatMultOp FloatMultOpGen fmul, dmul
float_sub JitFloatSubOp FloatSubOpGen fsub, dsub
float_neg JitFloatNegOp FloatNegOpGen fneg, dneg
float_abs JitFloatAbsOp FloatAbsOpGen Math.abs(float), Math.abs(double)
float_sqrt JitFloatSqrtOp FloatSqrtOpGen Math.sqrt(double)
float_int2float JitFloatInt2FloatOp FloatInt2FloatOpGen i2f, i2d, l2f, l2d
float_float2float JitFloatFloat2FloatOp FloatFloat2FloatOpGen f2d, d2f
float_trunc JitFloatTruncOp FloatTruncOpGen f2i, f2l, d2i, d2l
float_ceil JitFloatCeilOp FloatCeilOpGen Math.ceil(double)
float_floor JitFloatFloorOp FloatFloorOpGen Math.floor(double)
float_round JitFloatRoundOp FloatRoundOpGen +0.5 then Math.floor(double)
Miscellaneous
subpiece JitSubPieceOp SubPieceOpGen iushr, lushr
popcount JitPopCountOp PopCountOpGen Integer.bitCount(int), etc.
lzcount JitLzCountOp LzCountOpGen Integer.numberOfLeadingZeros(int), etc.
Synthetic
(none) JitCatenateOp CatenateOpGen
(none) JitSynthSubPieceOp SynthSubPieceOpGen
(none) JitPhiOp PhiOpGen

There are other p-code ops. Some are only used in "high" p-code, and so we need not implement them here. Others are used in abstract virtual machines, e.g., PcodeOp.NEW or are just not yet implemented, e.g., PcodeOp.SEGMENTOP.

The mapping from PcodeOp opcode to JitOp is done in, e.g., JitOp.binOp(PcodeOp, JitOutVar, JitVal, JitVal), and the mapping from JitOp to OpGen is done in lookup(JitOp).

The synthetic use-def nodes do not correspond to any p-code op. They are synthesized based on access patterns to the JitDataFlowState. Their generators do not emit any bytecode. See JitVarScopeModel regarding coalescing and allocating variables.

  • 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 void
    generateInitCode(JitCodeGenerator gen, T op, org.objectweb.asm.MethodVisitor iv)
    Emit bytecode into the class constructor.
    static void
    generateMpLegsFromArray(int legCount, org.objectweb.asm.MethodVisitor mv)
    Emit bytecode to push all legs from an array onto the stack
    static void
    generateMpLegsFromTemp(JitAllocationModel.JvmTempAlloc temp, int legCount, org.objectweb.asm.MethodVisitor mv)
    Emit bytecode to move all legs from a temporary allocation onto the stack
    static void
    generateMpLegsIntoArray(JitAllocationModel.JvmTempAlloc temp, int arrSize, int legCount, org.objectweb.asm.MethodVisitor mv)
    Emit bytecode to copy all legs from a temporary allocation into an array
    static void
    generateMpLegsIntoTemp(JitAllocationModel.JvmTempAlloc temp, int legCount, org.objectweb.asm.MethodVisitor mv)
    Emit bytecode to move all legs from the stack into a temporary allocation
    void
    generateRunCode(JitCodeGenerator gen, T op, JitControlFlowModel.JitBlock block, org.objectweb.asm.MethodVisitor rv)
    Emit bytecode into the run method.
    static void
    generateSyserrInts(JitCodeGenerator gen, int count, org.objectweb.asm.MethodVisitor mv)
     
    static <T extends JitOp>
    OpGen<T>
    lookup(T op)
    Lookup the generator for a given p-code op use-def node

  • Method Details

    • lookup

      static <T extends JitOp> OpGen<T> lookup(T op)
      Lookup the generator for a given p-code op use-def node
      Type Parameters:
      T - the class of the op
      Parameters:
      op - the JitOp whose generator to look up
      Returns:
      the generator

    • generateMpLegsIntoTemp

      static void generateMpLegsIntoTemp(JitAllocationModel.JvmTempAlloc temp, int legCount, org.objectweb.asm.MethodVisitor mv)
      Emit bytecode to move all legs from the stack into a temporary allocation

      This consumes legCount legs from the stack. Nothing else is pushed to the stack. The legs are placed in ascending indices as popped from the stack, i.e., in little-endian order.

      Parameters:
      temp - the allocation of temporary legs
      legCount - the number of legs to move
      mv - the method visitor

    • generateMpLegsFromTemp

      static void generateMpLegsFromTemp(JitAllocationModel.JvmTempAlloc temp, int legCount, org.objectweb.asm.MethodVisitor mv)
      Emit bytecode to move all legs from a temporary allocation onto the stack

      This consumes nothing. It places legCount legs onto the stack, pushed in descending order, i.e., such that they would be popped in little-endian order.

      Parameters:
      temp - the allocation of temporary legs
      legCount - the number of lets to move
      mv - the method visitor

    • generateMpLegsIntoArray

      static void generateMpLegsIntoArray(JitAllocationModel.JvmTempAlloc temp, int arrSize, int legCount, org.objectweb.asm.MethodVisitor mv)
      Emit bytecode to copy all legs from a temporary allocation into an array

      This does not consume anything from the stack. Upon return, the new array is pushed onto the stack. The legs are positioned in the array in the same order as in the locals. When used with generateMpLegsIntoTemp(JvmTempAlloc, int, MethodVisitor), this is little-endian order.

      Parameters:
      temp - the allocation of temporary legs
      arrSize - the size of the array, possibly over-provisioned
      legCount - the number of legs to move
      mv - the method visitor

    • generateMpLegsFromArray

      static void generateMpLegsFromArray(int legCount, org.objectweb.asm.MethodVisitor mv)
      Emit bytecode to push all legs from an array onto the stack

      This consumes the array at the top of the stack, and pushes its legs onto the stack in the reverse order as they are positioned in the array. If the legs are in little-endian order, as is convention, this method will push the legs to the stack with the least-significant leg on top.

      Parameters:
      legCount - the number of legs in the array
      mv - the method visitor

    • generateSyserrInts

      static void generateSyserrInts(JitCodeGenerator gen, int count, org.objectweb.asm.MethodVisitor mv)

    • generateInitCode

      default void generateInitCode(JitCodeGenerator gen, T op, org.objectweb.asm.MethodVisitor iv)
      Emit bytecode into the class constructor.
      Parameters:
      gen - the code generator
      op - the p-code op (use-def node) to translate
      iv - the visitor for the class constructor

    • generateRunCode

      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.

      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.