| //===-- BytecodeParser.h - Java bytecode parser -----------------*- C++ -*-===// |
| // |
| // The LLVM Compiler Infrastructure |
| // |
| // This file was developed by the LLVM research group and is distributed under |
| // the University of Illinois Open Source License. See LICENSE.TXT for details. |
| // |
| //===----------------------------------------------------------------------===// |
| // |
| // This file contains Java bytecode parser baseclass: a class that |
| // helps writing Java bytecode parsers. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #ifndef LLVM_JAVA_BYTECODEPARSER_H |
| #define LLVM_JAVA_BYTECODEPARSER_H |
| |
| #include <llvm/Java/Bytecode.h> |
| |
| namespace llvm { namespace Java { |
| |
| /// @brief This class provides a base class that eases bytecode |
| /// parsing. |
| /// |
| /// By default all the do_* methods do nothing. A subclass can |
| /// override at will to provide specific behaviour. |
| template <typename SubClass> |
| class BytecodeParser { |
| protected: |
| typedef std::vector<std::pair<int, unsigned> > SwitchCases; |
| |
| private: |
| SwitchCases switchCases_; |
| |
| protected: |
| #define THIS ((SubClass*)this) |
| |
| /// @brief parse code pointed to by \c code beginning at \c start |
| /// bytecode and ending at \c end bytecode |
| /// |
| /// This function parses the code pointed to by \c code and calls |
| /// the subclass's do_<bytecode> method appropriately. When this |
| /// function returns all code in [start, end) is parsed. |
| void parse(const uint8_t* code, unsigned start, unsigned end) { |
| for (unsigned i = start; i < end; ++i) { |
| unsigned curBC = i; |
| bool wide = code[i] == WIDE; |
| i += wide; |
| THIS->pre_inst(curBC); |
| switch (code[i]) { |
| case ACONST_NULL: |
| THIS->do_aconst_null(); |
| break; |
| case ICONST_M1: |
| case ICONST_0: |
| case ICONST_1: |
| case ICONST_2: |
| case ICONST_3: |
| case ICONST_4: |
| case ICONST_5: |
| THIS->do_iconst(code[i]-ICONST_0); |
| break; |
| case LCONST_0: |
| case LCONST_1: |
| THIS->do_lconst(code[i]-LCONST_0); |
| break; |
| case FCONST_0: |
| case FCONST_1: |
| case FCONST_2: |
| THIS->do_fconst(code[i]-FCONST_0); |
| break; |
| case DCONST_0: |
| case DCONST_1: |
| THIS->do_dconst(code[i]-DCONST_0); |
| break; |
| case BIPUSH: |
| THIS->do_iconst(readSByte(code, i)); |
| break; |
| case SIPUSH: |
| THIS->do_iconst(readSShort(code, i)); |
| break; |
| case LDC: |
| THIS->do_ldc(readUByte(code, i)); |
| break; |
| case LDC_W: |
| THIS->do_ldc(readUShort(code, i)); |
| break; |
| case LDC2_W: |
| THIS->do_ldc2(readUShort(code, i)); |
| break; |
| case ILOAD: |
| THIS->do_iload(wide ? readUShort(code, i) : readUByte(code, i)); |
| break; |
| case LLOAD: |
| THIS->do_lload(wide ? readUShort(code, i) : readUByte(code, i)); |
| break; |
| case FLOAD: |
| THIS->do_fload(wide ? readUShort(code, i) : readUByte(code, i)); |
| break; |
| case DLOAD: |
| THIS->do_dload(wide ? readUShort(code, i) : readUByte(code, i)); |
| break; |
| case ALOAD: |
| THIS->do_aload(wide ? readUShort(code, i) : readUByte(code, i)); |
| break; |
| case ILOAD_0: |
| case ILOAD_1: |
| case ILOAD_2: |
| case ILOAD_3: |
| THIS->do_iload(code[i]-ILOAD_0); |
| break; |
| case LLOAD_0: |
| case LLOAD_1: |
| case LLOAD_2: |
| case LLOAD_3: |
| THIS->do_lload(code[i]-LLOAD_0); |
| break; |
| case FLOAD_0: |
| case FLOAD_1: |
| case FLOAD_2: |
| case FLOAD_3: |
| THIS->do_fload(code[i]-FLOAD_0); |
| break; |
| case DLOAD_0: |
| case DLOAD_1: |
| case DLOAD_2: |
| case DLOAD_3: |
| THIS->do_dload(code[i]-DLOAD_0); |
| break; |
| case ALOAD_0: |
| case ALOAD_1: |
| case ALOAD_2: |
| case ALOAD_3: |
| THIS->do_aload(code[i]-ALOAD_0); |
| break; |
| case IALOAD: |
| THIS->do_iaload(); |
| break; |
| case LALOAD: |
| THIS->do_laload(); |
| break; |
| case FALOAD: |
| THIS->do_faload(); |
| break; |
| case DALOAD: |
| THIS->do_daload(); |
| break; |
| case AALOAD: |
| THIS->do_aaload(); |
| break; |
| case BALOAD: |
| THIS->do_baload(); |
| break; |
| case CALOAD: |
| THIS->do_caload(); |
| break; |
| case SALOAD: |
| THIS->do_saload(); |
| break; |
| case ISTORE: |
| THIS->do_istore(wide ? readUShort(code, i) : readUByte(code, i)); |
| break; |
| case LSTORE: |
| THIS->do_lstore(wide ? readUShort(code, i) : readUByte(code, i)); |
| break; |
| case FSTORE: |
| THIS->do_fstore(wide ? readUShort(code, i) : readUByte(code, i)); |
| break; |
| case DSTORE: |
| THIS->do_dstore(wide ? readUShort(code, i) : readUByte(code, i)); |
| break; |
| case ASTORE: |
| THIS->do_astore(wide ? readUShort(code, i) : readUByte(code, i)); |
| break; |
| case ISTORE_0: |
| case ISTORE_1: |
| case ISTORE_2: |
| case ISTORE_3: |
| THIS->do_istore(code[i]-ISTORE_0); |
| break; |
| case LSTORE_0: |
| case LSTORE_1: |
| case LSTORE_2: |
| case LSTORE_3: |
| THIS->do_lstore(code[i]-LSTORE_0); |
| break; |
| case FSTORE_0: |
| case FSTORE_1: |
| case FSTORE_2: |
| case FSTORE_3: |
| THIS->do_fstore(code[i]-FSTORE_0); |
| break; |
| case DSTORE_0: |
| case DSTORE_1: |
| case DSTORE_2: |
| case DSTORE_3: |
| THIS->do_dstore(code[i]-DSTORE_0); |
| break; |
| case ASTORE_0: |
| case ASTORE_1: |
| case ASTORE_2: |
| case ASTORE_3: |
| THIS->do_astore(code[i]-ASTORE_0); |
| break; |
| case IASTORE: |
| THIS->do_iastore(); |
| break; |
| case LASTORE: |
| THIS->do_lastore(); |
| break; |
| case FASTORE: |
| THIS->do_fastore(); |
| break; |
| case DASTORE: |
| THIS->do_dastore(); |
| break; |
| case AASTORE: |
| THIS->do_aastore(); |
| break; |
| case BASTORE: |
| THIS->do_bastore(); |
| break; |
| case CASTORE: |
| THIS->do_castore(); |
| break; |
| case SASTORE: |
| THIS->do_sastore(); |
| break; |
| case POP: |
| THIS->do_pop(); |
| break; |
| case POP2: |
| THIS->do_pop2(); |
| break; |
| case DUP: |
| THIS->do_dup(); |
| break; |
| case DUP_X1: |
| THIS->do_dup_x1(); |
| break; |
| case DUP_X2: |
| THIS->do_dup_x2(); |
| break; |
| case DUP2: |
| THIS->do_dup2(); |
| break; |
| case DUP2_X1: |
| THIS->do_dup2_x1(); |
| break; |
| case DUP2_X2: |
| THIS->do_dup2_x2(); |
| break; |
| case SWAP: |
| THIS->do_swap(); |
| break; |
| case IADD: |
| THIS->do_iadd(); |
| break; |
| case LADD: |
| THIS->do_ladd(); |
| break; |
| case FADD: |
| THIS->do_fadd(); |
| break; |
| case DADD: |
| THIS->do_dadd(); |
| break; |
| case ISUB: |
| THIS->do_isub(); |
| break; |
| case LSUB: |
| THIS->do_lsub(); |
| break; |
| case FSUB: |
| THIS->do_fsub(); |
| break; |
| case DSUB: |
| THIS->do_dsub(); |
| break; |
| case IMUL: |
| THIS->do_imul(); |
| break; |
| case LMUL: |
| THIS->do_lmul(); |
| break; |
| case FMUL: |
| THIS->do_fmul(); |
| break; |
| case DMUL: |
| THIS->do_dmul(); |
| break; |
| case IDIV: |
| THIS->do_idiv(); |
| break; |
| case LDIV: |
| THIS->do_ldiv(); |
| break; |
| case FDIV: |
| THIS->do_fdiv(); |
| break; |
| case DDIV: |
| THIS->do_ddiv(); |
| break; |
| case IREM: |
| THIS->do_irem(); |
| break; |
| case LREM: |
| THIS->do_lrem(); |
| break; |
| case FREM: |
| THIS->do_frem(); |
| break; |
| case DREM: |
| THIS->do_drem(); |
| break; |
| case INEG: |
| THIS->do_ineg(); |
| break; |
| case LNEG: |
| THIS->do_lneg(); |
| break; |
| case FNEG: |
| THIS->do_fneg(); |
| break; |
| case DNEG: |
| THIS->do_dneg(); |
| break; |
| case ISHL: |
| THIS->do_ishl(); |
| break; |
| case LSHL: |
| THIS->do_lshl(); |
| break; |
| case ISHR: |
| THIS->do_ishr(); |
| break; |
| case LSHR: |
| THIS->do_lshr(); |
| break; |
| case IUSHR: |
| THIS->do_iushr(); |
| break; |
| case LUSHR: |
| THIS->do_lushr(); |
| break; |
| case IAND: |
| THIS->do_iand(); |
| break; |
| case LAND: |
| THIS->do_land(); |
| break; |
| case IOR: |
| THIS->do_ior(); |
| break; |
| case LOR: |
| THIS->do_lor(); |
| break; |
| case IXOR: |
| THIS->do_ixor(); |
| break; |
| case LXOR: |
| THIS->do_lxor(); |
| break; |
| case IINC: { |
| unsigned index = wide ? readUShort(code, i) : readUByte(code, i); |
| int amount = wide ? readSShort(code, i) : readSByte(code, i); |
| THIS->do_iinc(index, amount); |
| break; |
| } |
| case I2L: |
| THIS->do_i2l(); |
| break; |
| case I2F: |
| THIS->do_i2f(); |
| break; |
| case I2D: |
| THIS->do_i2d(); |
| break; |
| case L2I: |
| THIS->do_l2i(); |
| break; |
| case L2F: |
| THIS->do_l2f(); |
| break; |
| case L2D: |
| THIS->do_l2d(); |
| break; |
| case F2I: |
| THIS->do_f2i(); |
| break; |
| case F2L: |
| THIS->do_f2l(); |
| break; |
| case F2D: |
| THIS->do_f2d(); |
| break; |
| case D2I: |
| THIS->do_d2i(); |
| break; |
| case D2L: |
| THIS->do_d2l(); |
| break; |
| case D2F: |
| THIS->do_d2f(); |
| break; |
| case I2B: |
| THIS->do_i2b(); |
| break; |
| case I2C: |
| THIS->do_i2c(); |
| break; |
| case I2S: |
| THIS->do_i2s(); |
| break; |
| case LCMP: |
| THIS->do_lcmp(); |
| break; |
| case FCMPL: |
| THIS->do_fcmpl(); |
| break; |
| case FCMPG: |
| THIS->do_fcmpg(); |
| break; |
| case DCMPL: |
| THIS->do_dcmpl(); |
| break; |
| case DCMPG: |
| THIS->do_dcmpg(); |
| break; |
| case IFEQ: { |
| unsigned t = curBC + readSShort(code, i); |
| THIS->do_ifeq(t, i + 1); |
| break; |
| } |
| case IFNE: { |
| unsigned t = curBC + readSShort(code, i); |
| THIS->do_ifne(t, i + 1); |
| break; |
| } |
| case IFLT: { |
| unsigned t = curBC + readSShort(code, i); |
| THIS->do_iflt(t, i + 1); |
| break; |
| } |
| case IFGE: { |
| unsigned t = curBC + readSShort(code, i); |
| THIS->do_ifge(t, i + 1); |
| break; |
| } |
| case IFGT: { |
| unsigned t = curBC + readSShort(code, i); |
| THIS->do_ifgt(t, i + 1); |
| break; |
| } |
| case IFLE: { |
| unsigned t = curBC + readSShort(code, i); |
| THIS->do_ifle(t, i + 1); |
| break; |
| } |
| case IF_ICMPEQ: { |
| unsigned t = curBC + readSShort(code, i); |
| THIS->do_if_icmpeq(t, i + 1); |
| break; |
| } |
| case IF_ICMPNE: { |
| unsigned t = curBC + readSShort(code, i); |
| THIS->do_if_icmpne(t, i + 1); |
| break; |
| } |
| case IF_ICMPLT: { |
| unsigned t = curBC + readSShort(code, i); |
| THIS->do_if_icmplt(t, i + 1); |
| break; |
| } |
| case IF_ICMPGE: { |
| unsigned t = curBC + readSShort(code, i); |
| THIS->do_if_icmpge(t, i + 1); |
| break; |
| } |
| case IF_ICMPGT: { |
| unsigned t = curBC + readSShort(code, i); |
| THIS->do_if_icmpgt(t, i + 1); |
| break; |
| } |
| case IF_ICMPLE: { |
| unsigned t = curBC + readSShort(code, i); |
| THIS->do_if_icmple(t, i + 1); |
| break; |
| } |
| case IF_IACMPEQ: { |
| unsigned t = curBC + readSShort(code, i); |
| THIS->do_if_acmpeq(t, i + 1); |
| break; |
| } |
| case IF_IACMPNE: { |
| unsigned t = curBC + readSShort(code, i); |
| THIS->do_if_acmpne(t, i + 1); |
| break; |
| } |
| case GOTO: |
| THIS->do_goto(curBC + readSShort(code, i)); |
| break; |
| case JSR: { |
| unsigned t = curBC + readSShort(code, i); |
| THIS->do_jsr(t, i + 1); |
| break; |
| } |
| case RET: |
| THIS->do_ret(readUByte(code, i)); |
| break; |
| case TABLESWITCH: { |
| switchCases_.clear(); |
| skipPadBytes(i); |
| int def = readSInt(code, i); |
| int low = readSInt(code, i); |
| int high = readSInt(code, i); |
| switchCases_.reserve(high - low + 1); |
| while (low <= high) |
| switchCases_.push_back( |
| std::make_pair(low++, curBC + readSInt(code, i))); |
| THIS->do_tableswitch(curBC + def, switchCases_); |
| break; |
| } |
| case LOOKUPSWITCH: { |
| switchCases_.clear(); |
| skipPadBytes(i); |
| int def = readSInt(code, i); |
| int pairCount = readSInt(code, i); |
| switchCases_.reserve(pairCount); |
| while (pairCount--) { |
| int value = readSInt(code, i); |
| switchCases_.push_back( |
| std::make_pair(value, curBC + readSInt(code, i))); |
| } |
| THIS->do_lookupswitch(curBC + def, switchCases_); |
| break; |
| } |
| case IRETURN: |
| THIS->do_ireturn(); |
| break; |
| case LRETURN: |
| THIS->do_lreturn(); |
| break; |
| case FRETURN: |
| THIS->do_freturn(); |
| break; |
| case DRETURN: |
| THIS->do_dreturn(); |
| break; |
| case ARETURN: |
| THIS->do_areturn(); |
| break; |
| case RETURN: |
| THIS->do_return(); |
| break; |
| case GETSTATIC: |
| THIS->do_getstatic(readUShort(code, i)); |
| break; |
| case PUTSTATIC: |
| THIS->do_putstatic(readUShort(code, i)); |
| break; |
| case GETFIELD: |
| THIS->do_getfield(readUShort(code, i)); |
| break; |
| case PUTFIELD: |
| THIS->do_putfield(readUShort(code, i)); |
| break; |
| case INVOKEVIRTUAL: |
| THIS->do_invokevirtual(readUShort(code, i)); |
| break; |
| case INVOKESPECIAL: |
| THIS->do_invokespecial(readUShort(code, i)); |
| break; |
| case INVOKESTATIC: |
| THIS->do_invokestatic(readUShort(code, i)); |
| break; |
| case INVOKEINTERFACE: { |
| THIS->do_invokeinterface(readUShort(code, i)); |
| unsigned count = readUByte(code, i); |
| unsigned zero = readUByte(code, i); |
| break; |
| } |
| case XXXUNUSEDXXX: |
| // FIXME: must throw something |
| break; |
| case NEW: |
| THIS->do_new(readUShort(code, i)); |
| break; |
| case NEWARRAY: |
| THIS->do_newarray(static_cast<JType>(readUByte(code, i))); |
| break; |
| case ANEWARRAY: |
| THIS->do_anewarray(readUShort(code, i)); |
| break; |
| case ARRAYLENGTH: |
| THIS->do_arraylength(); |
| break; |
| case ATHROW: |
| THIS->do_athrow(); |
| break; |
| case CHECKCAST: |
| THIS->do_checkcast(readUShort(code, i)); |
| break; |
| case INSTANCEOF: |
| THIS->do_instanceof(readUShort(code, i)); |
| break; |
| case MONITORENTER: |
| THIS->do_monitorenter(); |
| break; |
| case MONITOREXIT: |
| THIS->do_monitorexit(); |
| break; |
| case WIDE: |
| // FIXME: must throw something |
| break; |
| case MULTIANEWARRAY: { |
| unsigned index = readUShort(code, i); |
| unsigned dims = readUByte(code, i); |
| THIS->do_multianewarray(index, dims); |
| break; |
| } |
| case IFNULL: { |
| unsigned t = curBC + readSShort(code, i); |
| THIS->do_ifnull(t, i + 1); |
| break; |
| } |
| case IFNONNULL: { |
| unsigned t = curBC + readSShort(code, i); |
| THIS->do_ifnonnull(t, i + 1); |
| break; |
| } |
| case GOTO_W: |
| THIS->do_goto(curBC + readSInt(code, i)); |
| break; |
| case JSR_W: { |
| unsigned t = curBC + readSInt(code, i); |
| THIS->do_jsr(t, i + 1); |
| break; |
| } |
| case BREAKPOINT: |
| case IMPDEP1: |
| case IMPDEP2: |
| case NOP: |
| break; |
| default: |
| // FIXME: must throw something |
| break; |
| } |
| } |
| } |
| |
| #undef THIS |
| |
| /// @brief called before every bytecode |
| void pre_inst(unsigned bcI) { } |
| /// @brief called on ACONST_NULL |
| void do_aconst_null() { } |
| /// @brief called on ICONST_<n>, SIPUSH and BIPUSH |
| void do_iconst(int value) { } |
| /// @brief called on LCONST_<n> |
| void do_lconst(long long value) { } |
| /// @brief called on FCONST_<n> |
| void do_fconst(float value) { } |
| /// @brief called on DCONST_<n> |
| void do_dconst(double value) { } |
| /// @brief called on LDC and LDC_W |
| void do_ldc(unsigned index) { } |
| /// @brief called on LDC2_W |
| void do_ldc2(unsigned index) { } |
| /// @brief called on ILOAD and ILOAD_<n> |
| void do_iload(unsigned index) { } |
| /// @brief called on LLOAD and LLOAD_<n> |
| void do_lload(unsigned index) { } |
| /// @brief called on FLOAD and FLOAD_<n> |
| void do_fload(unsigned index) { } |
| /// @brief called on DLOAD and DLOAD_<n> |
| void do_dload(unsigned index) { } |
| /// @brief called on ALOAD and ALOAD_<n> |
| void do_aload(unsigned index) { } |
| /// @brief called on IALOAD |
| void do_iaload() { } |
| /// @brief called on LALOAD |
| void do_laload() { } |
| /// @brief called on FALOAD |
| void do_faload() { } |
| /// @brief called on DALOAD |
| void do_daload() { } |
| /// @brief called on AALOAD |
| void do_aaload() { } |
| /// @brief called on BALOAD |
| void do_baload() { } |
| /// @brief called on CALOAD |
| void do_caload() { } |
| /// @brief called on SALOAD |
| void do_saload() { } |
| /// @brief called on ISTORE and ISTORE_<n> |
| void do_istore(unsigned index) { } |
| /// @brief called on LSTORE and LSTORE_<n> |
| void do_lstore(unsigned index) { } |
| /// @brief called on FSTORE and FSTORE_<n> |
| void do_fstore(unsigned index) { } |
| /// @brief called on DSTORE and DSTORE_<n> |
| void do_dstore(unsigned index) { } |
| /// @brief called on ASTORE and ASTORE_<n> |
| void do_astore(unsigned index) { } |
| /// @brief called on IASTORE |
| void do_iastore() { } |
| /// @brief called on LASTORE |
| void do_lastore() { } |
| /// @brief called on FASTORE |
| void do_fastore() { } |
| /// @brief called on DASTORE |
| void do_dastore() { } |
| /// @brief called on AASTORE |
| void do_aastore() { } |
| /// @brief called on BASTORE |
| void do_bastore() { } |
| /// @brief called on CASTORE |
| void do_castore() { } |
| /// @brief called on SASTORE |
| void do_sastore() { } |
| /// @brief called on POP |
| void do_pop() { } |
| /// @brief called on POP2 |
| void do_pop2() { } |
| /// @brief called on DUP |
| void do_dup() { } |
| /// @brief called on DUP_X1 |
| void do_dup_x1() { } |
| /// @brief called on DUP_X2 |
| void do_dup_x2() { } |
| /// @brief called on DUP2 |
| void do_dup2() { } |
| /// @brief called on DUP2_X1 |
| void do_dup2_x1() { } |
| /// @brief called on DUP2_X2 |
| void do_dup2_x2() { } |
| /// @brief called on SWAP |
| void do_swap() { } |
| /// @brief called on IADD |
| void do_iadd() { } |
| /// @brief called on LADD |
| void do_ladd() { } |
| /// @brief called on FADD |
| void do_fadd() { } |
| /// @brief called on DADD |
| void do_dadd() { } |
| /// @brief called on ISUB |
| void do_isub() { } |
| /// @brief called on LSUB |
| void do_lsub() { } |
| /// @brief called on FSUB |
| void do_fsub() { } |
| /// @brief called on DSUB |
| void do_dsub() { } |
| /// @brief called on IMUL |
| void do_imul() { } |
| /// @brief called on LMUL |
| void do_lmul() { } |
| /// @brief called on FMUL |
| void do_fmul() { } |
| /// @brief called on DMUL |
| void do_dmul() { } |
| /// @brief called on IDIV |
| void do_idiv() { } |
| /// @brief called on LDIV |
| void do_ldiv() { } |
| /// @brief called on FDIV |
| void do_fdiv() { } |
| /// @brief called on DDIV |
| void do_ddiv() { } |
| /// @brief called on IREM |
| void do_irem() { } |
| /// @brief called on LREM |
| void do_lrem() { } |
| /// @brief called on FREM |
| void do_frem() { } |
| /// @brief called on DREM |
| void do_drem() { } |
| /// @brief called on INEG |
| void do_ineg() { } |
| /// @brief called on LNEG |
| void do_lneg() { } |
| /// @brief called on FNEG |
| void do_fneg() { } |
| /// @brief called on DNEG |
| void do_dneg() { } |
| /// @brief called on ISHL |
| void do_ishl() { } |
| /// @brief called on LSHL |
| void do_lshl() { } |
| /// @brief called on ISHR |
| void do_ishr() { } |
| /// @brief called on LSHR |
| void do_lshr() { } |
| /// @brief called on IUSHR |
| void do_iushr() { } |
| /// @brief called on LUSHR |
| void do_lushr() { } |
| /// @brief called on IAND |
| void do_iand() { } |
| /// @brief called on LAND |
| void do_land() { } |
| /// @brief called on IOR |
| void do_ior() { } |
| /// @brief called on LOR |
| void do_lor() { } |
| /// @brief called on IXOR |
| void do_ixor() { } |
| /// @brief called on LXOR |
| void do_lxor() { } |
| /// @brief called on IINC |
| void do_iinc(unsigned index, int amount) { } |
| /// @brief called on I2L |
| void do_i2l() { } |
| /// @brief called on I2F |
| void do_i2f() { } |
| /// @brief called on I2D |
| void do_i2d() { } |
| /// @brief called on L2I |
| void do_l2i() { } |
| /// @brief called on L2F |
| void do_l2f() { } |
| /// @brief called on L2D |
| void do_l2d() { } |
| /// @brief called on F2I |
| void do_f2i() { } |
| /// @brief called on F2L |
| void do_f2l() { } |
| /// @brief called on F2D |
| void do_f2d() { } |
| /// @brief called on D2I |
| void do_d2i() { } |
| /// @brief called on D2L |
| void do_d2l() { } |
| /// @brief called on D2F |
| void do_d2f() { } |
| /// @brief called on I2B |
| void do_i2b() { } |
| /// @brief called on I2C |
| void do_i2c() { } |
| /// @brief called on I2S |
| void do_i2s() { } |
| /// @brief called on LCMP |
| void do_lcmp() { } |
| /// @brief called on FCMPL |
| void do_fcmpl() { } |
| /// @brief called on DCMPL |
| void do_dcmpl() { } |
| /// @brief called on FCMPG |
| void do_fcmpg() { } |
| /// @brief called on DCMPG |
| void do_dcmpg() { } |
| /// @brief called on IFEQ |
| void do_ifeq(unsigned t, unsigned f) { } |
| /// @brief called on IFNE |
| void do_ifne(unsigned t, unsigned f) { } |
| /// @brief called on IFLT |
| void do_iflt(unsigned t, unsigned f) { } |
| /// @brief called on IFGE |
| void do_ifge(unsigned t, unsigned f) { } |
| /// @brief called on IFGT |
| void do_ifgt(unsigned t, unsigned f) { } |
| /// @brief called on IFLE |
| void do_ifle(unsigned t, unsigned f) { } |
| /// @brief called on IF_ICMPEQ |
| void do_if_icmpeq(unsigned t, unsigned f) { } |
| /// @brief called on IF_ICMPNE |
| void do_if_icmpne(unsigned t, unsigned f) { } |
| /// @brief called on IF_ICMPLT |
| void do_if_icmplt(unsigned t, unsigned f) { } |
| /// @brief called on IF_ICMPGE |
| void do_if_icmpge(unsigned t, unsigned f) { } |
| /// @brief called on IF_ICMPGT |
| void do_if_icmpgt(unsigned t, unsigned f) { } |
| /// @brief called on IF_ICMPLE |
| void do_if_icmple(unsigned t, unsigned f) { } |
| /// @brief called on IF_ACMPEQ |
| void do_if_acmpeq(unsigned t, unsigned f) { } |
| /// @brief called on IF_ACMPNE |
| void do_if_acmpne(unsigned t, unsigned f) { } |
| /// @brief called on GOTO and GOTO_W |
| void do_goto(unsigned target) { } |
| /// @brief called on JSR and JSR_W |
| void do_jsr(unsigned target, unsigned retAddress) { } |
| /// @brief called on RET |
| void do_ret(unsigned index) { } |
| /// @brief called on TABLESWITCH |
| void do_tableswitch(unsigned defTarget, const SwitchCases& sw) { } |
| /// @brief called on LOOKUPSWITCH |
| void do_lookupswitch(unsigned defTarget, const SwitchCases& sw) { } |
| /// @brief called on IRETURN |
| void do_ireturn() { } |
| /// @brief called on LRETURN |
| void do_lreturn() { } |
| /// @brief called on FRETURN |
| void do_freturn() { } |
| /// @brief called on DRETURN |
| void do_dreturn() { } |
| /// @brief called on ARETURN |
| void do_areturn() { } |
| /// @brief called on RETURN |
| void do_return() { } |
| /// @brief called on GETSTATIC |
| void do_getstatic(unsigned index) { } |
| /// @brief called on PUTSTATIC |
| void do_putstatic(unsigned index) { } |
| /// @brief called on GETFIELD |
| void do_getfield(unsigned index) { } |
| /// @brief called on PUTFIELD |
| void do_putfield(unsigned index) { } |
| /// @brief called on INVOKEVIRTUAL |
| void do_invokevirtual(unsigned index) { } |
| /// @brief called on INVOKESPECIAL |
| void do_invokespecial(unsigned index) { } |
| /// @brief called on INVOKESTATIC |
| void do_invokestatic(unsigned index) { } |
| /// @brief called on INVOKEINTERFACE |
| void do_invokeinterface(unsigned index) { } |
| /// @brief called on NEW |
| void do_new(unsigned index) { } |
| /// @brief called on NEWARRAY |
| void do_newarray(JType type) { } |
| /// @brief called on ANEWARRAY |
| void do_anewarray(unsigned index) { } |
| /// @brief called on ARRAYLENGTH |
| void do_arraylength() { } |
| /// @brief called on ATHROW |
| void do_athrow() { } |
| /// @brief called on CHECKCAST |
| void do_checkcast(unsigned index) { } |
| /// @brief called on INSTANCEOF |
| void do_instanceof(unsigned index) { } |
| /// @brief called on MONITORENTER |
| void do_monitorenter() { } |
| /// @brief called on MONITOREXIT |
| void do_monitorexit() { } |
| /// @brief called on MULTIANEWARRAY |
| void do_multianewarray(unsigned index, unsigned dims) { } |
| /// @brief called on IFNULL |
| void do_ifnull(unsigned t, unsigned f) { } |
| /// @brief called on IFNONNULL |
| void do_ifnonnull(unsigned t, unsigned f) { } |
| }; |
| |
| } } // namespace llvm::Java |
| |
| #endif//LLVM_JAVA_BYTECODEPARSER_H |
