[llvm-commits] CVS: llvm-java/include/llvm/Java/BytecodeParser.h Compiler.h Bytecode.h
Alkis Evlogimenos
alkis at cs.uiuc.edu
Mon May 24 20:51:00 PDT 2004
Changes in directory llvm-java/include/llvm/Java:
BytecodeParser.h added (r1.1)
Compiler.h updated: 1.4 -> 1.5
Bytecode.h updated: 1.6 -> 1.7
---
Log message:
Huge refactoring. Parsing code now lives in BytecodeParser and
Compiler uses the pimpl idiom. CompilerImpl is a BytecodeParser which
also uses a Bytecode2BasicBlockMapper (BytecodeParser) to build the
bytecode->BasicBlock map.
The refactoring of the parsing code eliminates the duplicate switches
and makes the code simpler (several bytecodes are handled by one call
iconst_<n>, bipush and sipush for example).
Some bugs in the Bytecode2BasicBlockMapper where fixes (not all basic
blocks were created).
---
Diffs of the changes: (+774 -33)
Index: llvm-java/include/llvm/Java/BytecodeParser.h
diff -c /dev/null llvm-java/include/llvm/Java/BytecodeParser.h:1.1
*** /dev/null Mon May 24 20:48:10 2004
--- llvm-java/include/llvm/Java/BytecodeParser.h Mon May 24 20:48:00 2004
***************
*** 0 ****
--- 1,763 ----
+ //===-- 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;
+
+ enum JSetCC { EQ, NE, LT, GE, GT, LE };
+
+ enum JType {
+ REFERENCE = 0, // this is not defined in the java spec
+ BOOLEAN = 4,
+ CHAR = 5,
+ FLOAT = 6,
+ DOUBLE = 7,
+ BYTE = 8,
+ SHORT = 9,
+ INT = 10,
+ LONG = 11,
+ };
+
+ private:
+ SwitchCases switchCases_;
+
+ protected:
+ #define THIS ((SubClass*)this)
+
+ /// @brief parse code pointed to by \c code of size \c size
+ ///
+ /// 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 up to
+ /// \c size is parsed.
+ void parse(const uint8_t* code, unsigned size) {
+ using namespace Opcode;
+
+ for (unsigned i = 0; i < size; ++i) {
+ unsigned curBC = i;
+ bool wide = code[i] == WIDE;
+ i += wide;
+ switch (code[i]) {
+ case ACONST_NULL:
+ THIS->do_aconst_null(curBC);
+ 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(curBC, code[i]-ICONST_0);
+ break;
+ case LCONST_0:
+ case LCONST_1:
+ THIS->do_lconst(curBC, code[i]-LCONST_0);
+ break;
+ case FCONST_0:
+ case FCONST_1:
+ case FCONST_2:
+ THIS->do_fconst(curBC, code[i]-FCONST_0);
+ break;
+ case DCONST_0:
+ case DCONST_1:
+ THIS->do_dconst(curBC, code[i]-DCONST_0);
+ break;
+ case BIPUSH:
+ THIS->do_iconst(curBC, readSByte(code, i));
+ break;
+ case SIPUSH:
+ THIS->do_iconst(curBC, readSShort(code, i));
+ break;
+ case LDC:
+ THIS->do_ldc(curBC, readUByte(code, i));
+ break;
+ case LDC_W:
+ THIS->do_ldc(curBC, readUShort(code, i));
+ break;
+ case LDC2_W:
+ THIS->do_ldc(curBC, readUShort(code, i));
+ break;
+ case ILOAD:
+ THIS->do_load(
+ curBC, INT,
+ wide ? readUShort(code, i) : readUByte(code, i));
+ break;
+ case LLOAD:
+ THIS->do_load(
+ curBC, LONG,
+ wide ? readUShort(code, i) : readUByte(code, i));
+ break;
+ case FLOAD:
+ THIS->do_load(
+ curBC, FLOAT,
+ wide ? readUShort(code, i) : readUByte(code, i));
+ break;
+ case DLOAD:
+ THIS->do_load(
+ curBC, DOUBLE,
+ wide ? readUShort(code, i) : readUByte(code, i));
+ break;
+ case ALOAD:
+ THIS->do_load(
+ curBC, REFERENCE,
+ wide ? readUShort(code, i) : readUByte(code, i));
+ break;
+ case ILOAD_0:
+ case ILOAD_1:
+ case ILOAD_2:
+ case ILOAD_3:
+ THIS->do_load(curBC, INT, code[i]-ILOAD_0);
+ break;
+ case LLOAD_0:
+ case LLOAD_1:
+ case LLOAD_2:
+ case LLOAD_3:
+ THIS->do_load(curBC, LONG, code[i]-LLOAD_0);
+ break;
+ case FLOAD_0:
+ case FLOAD_1:
+ case FLOAD_2:
+ case FLOAD_3:
+ THIS->do_load(curBC, FLOAT, code[i]-FLOAD_0);
+ break;
+ case DLOAD_0:
+ case DLOAD_1:
+ case DLOAD_2:
+ case DLOAD_3:
+ THIS->do_load(curBC, DOUBLE, code[i]-DLOAD_0);
+ break;
+ case ALOAD_0:
+ case ALOAD_1:
+ case ALOAD_2:
+ case ALOAD_3:
+ THIS->do_load(curBC, REFERENCE, code[i]-ALOAD_0);
+ break;
+ case IALOAD:
+ THIS->do_aload(curBC, INT);
+ break;
+ case LALOAD:
+ THIS->do_aload(curBC, LONG);
+ break;
+ case FALOAD:
+ THIS->do_aload(curBC, FLOAT);
+ break;
+ case DALOAD:
+ THIS->do_aload(curBC, DOUBLE);
+ break;
+ case AALOAD:
+ THIS->do_aload(curBC, REFERENCE);
+ break;
+ case BALOAD:
+ THIS->do_aload(curBC, BYTE);
+ break;
+ case CALOAD:
+ THIS->do_aload(curBC, CHAR);
+ break;
+ case SALOAD:
+ THIS->do_aload(curBC, SHORT);
+ break;
+ case ISTORE:
+ THIS->do_store(
+ curBC, INT,
+ wide ? readUShort(code, i) : readUByte(code, i));
+ break;
+ case LSTORE:
+ THIS->do_store(
+ curBC, LONG,
+ wide ? readUShort(code, i) : readUByte(code, i));
+ break;
+ case FSTORE:
+ THIS->do_store(
+ curBC, FLOAT,
+ wide ? readUShort(code, i) : readUByte(code, i));
+ break;
+ case DSTORE:
+ THIS->do_store(
+ curBC, DOUBLE,
+ wide ? readUShort(code, i) : readUByte(code, i));
+ break;
+ case ASTORE:
+ THIS->do_store(
+ curBC, REFERENCE,
+ wide ? readUShort(code, i) : readUByte(code, i));
+ break;
+ case ISTORE_0:
+ case ISTORE_1:
+ case ISTORE_2:
+ case ISTORE_3:
+ THIS->do_store(curBC, INT, code[i]-ISTORE_0);
+ break;
+ case LSTORE_0:
+ case LSTORE_1:
+ case LSTORE_2:
+ case LSTORE_3:
+ THIS->do_store(curBC, LONG, code[i]-LSTORE_0);
+ break;
+ case FSTORE_0:
+ case FSTORE_1:
+ case FSTORE_2:
+ case FSTORE_3:
+ THIS->do_store(curBC, FLOAT, code[i]-FSTORE_0);
+ break;
+ case DSTORE_0:
+ case DSTORE_1:
+ case DSTORE_2:
+ case DSTORE_3:
+ THIS->do_store(curBC, DOUBLE, code[i]-DSTORE_0);
+ break;
+ case ASTORE_0:
+ case ASTORE_1:
+ case ASTORE_2:
+ case ASTORE_3:
+ THIS->do_store(curBC, REFERENCE, code[i]-ASTORE_0);
+ break;
+ case IASTORE:
+ THIS->do_astore(curBC, INT);
+ break;
+ case LASTORE:
+ THIS->do_astore(curBC, LONG);
+ break;
+ case FASTORE:
+ THIS->do_astore(curBC, FLOAT);
+ break;
+ case DASTORE:
+ THIS->do_astore(curBC, DOUBLE);
+ break;
+ case AASTORE:
+ THIS->do_astore(curBC, REFERENCE);
+ break;
+ case BASTORE:
+ THIS->do_astore(curBC, BYTE);
+ break;
+ case CASTORE:
+ THIS->do_astore(curBC, CHAR);
+ break;
+ case SASTORE:
+ THIS->do_astore(curBC, SHORT);
+ break;
+ case POP:
+ THIS->do_pop(curBC);
+ break;
+ case POP2:
+ THIS->do_pop2(curBC);
+ break;
+ case DUP:
+ THIS->do_dup(curBC);
+ break;
+ case DUP_X1:
+ THIS->do_dup_x1(curBC);
+ break;
+ case DUP_X2:
+ THIS->do_dup_x2(curBC);
+ break;
+ case DUP2:
+ THIS->do_dup2(curBC);
+ break;
+ case DUP2_X1:
+ THIS->do_dup2_x1(curBC);
+ break;
+ case DUP2_X2:
+ THIS->do_dup2_x2(curBC);
+ break;
+ case SWAP:
+ THIS->do_swap(curBC);
+ break;
+ case IADD:
+ case LADD:
+ case FADD:
+ case DADD:
+ THIS->do_add(curBC);
+ break;
+ case ISUB:
+ case LSUB:
+ case FSUB:
+ case DSUB:
+ THIS->do_sub(curBC);
+ break;
+ case IMUL:
+ case LMUL:
+ case FMUL:
+ case DMUL:
+ THIS->do_mul(curBC);
+ break;
+ case IDIV:
+ case LDIV:
+ case FDIV:
+ case DDIV:
+ THIS->do_div(curBC);
+ break;
+ case IREM:
+ case LREM:
+ case FREM:
+ case DREM:
+ THIS->do_rem(curBC);
+ break;
+ case INEG:
+ case LNEG:
+ case FNEG:
+ case DNEG:
+ THIS->do_neg(curBC);
+ break;
+ case ISHL:
+ case LSHL:
+ THIS->do_shl(curBC);
+ break;
+ case ISHR:
+ case LSHR:
+ THIS->do_shr(curBC);
+ break;
+ case IUSHR:
+ case LUSHR:
+ THIS->do_ushr(curBC);
+ break;
+ case IAND:
+ case LAND:
+ THIS->do_and(curBC);
+ break;
+ case IOR:
+ case LOR:
+ THIS->do_or(curBC);
+ break;
+ case IXOR:
+ case LXOR:
+ THIS->do_xor(curBC);
+ break;
+ case IINC:
+ THIS->do_iinc(
+ curBC, readUByte(code, i), readUByte(code, i));
+ break;
+ case I2L:
+ THIS->do_convert(curBC, LONG);
+ break;
+ case I2F:
+ THIS->do_convert(curBC, FLOAT);
+ break;
+ case I2D:
+ THIS->do_convert(curBC, DOUBLE);
+ break;
+ case L2I:
+ THIS->do_convert(curBC, INT);
+ break;
+ case L2F:
+ THIS->do_convert(curBC, FLOAT);
+ break;
+ case L2D:
+ THIS->do_convert(curBC, DOUBLE);
+ break;
+ case F2I:
+ THIS->do_convert(curBC, INT);
+ break;
+ case F2L:
+ THIS->do_convert(curBC, LONG);
+ break;
+ case F2D:
+ THIS->do_convert(curBC, DOUBLE);
+ break;
+ case D2I:
+ THIS->do_convert(curBC, INT);
+ break;
+ case D2L:
+ THIS->do_convert(curBC, LONG);
+ break;
+ case D2F:
+ THIS->do_convert(curBC, FLOAT);
+ break;
+ case I2B:
+ THIS->do_convert(curBC, BYTE);
+ break;
+ case I2C:
+ THIS->do_convert(curBC, CHAR);
+ break;
+ case I2S:
+ THIS->do_convert(curBC, SHORT);
+ break;
+ case LCMP:
+ THIS->do_cmp(curBC);
+ break;
+ case FCMPL:
+ THIS->do_cmpl(curBC);
+ break;
+ case FCMPG:
+ THIS->do_cmpg(curBC);
+ break;
+ case DCMPL:
+ THIS->do_cmpl(curBC);
+ break;
+ case DCMPG:
+ THIS->do_cmpg(curBC);
+ break;
+ case IFEQ: {
+ unsigned t = curBC + readSShort(code, i);
+ THIS->do_if(curBC, EQ, INT, t, i + 1);
+ break;
+ }
+ case IFNE: {
+ unsigned t = curBC + readSShort(code, i);
+ THIS->do_if(curBC, NE, INT, t, i + 1);
+ break;
+ }
+ case IFLT: {
+ unsigned t = curBC + readSShort(code, i);
+ THIS->do_if(curBC, LT, INT, t, i + 1);
+ break;
+ }
+ case IFGE: {
+ unsigned t = curBC + readSShort(code, i);
+ THIS->do_if(curBC, GE, INT, t, i + 1);
+ break;
+ }
+ case IFGT: {
+ unsigned t = curBC + readSShort(code, i);
+ THIS->do_if(curBC, GT, INT, t, i + 1);
+ break;
+ }
+ case IFLE: {
+ unsigned t = curBC + readSShort(code, i);
+ THIS->do_if(curBC, LE, INT, t, i + 1);
+ break;
+ }
+ case IF_ICMPEQ: {
+ unsigned t = curBC + readSShort(code, i);
+ THIS->do_ifcmp(curBC, EQ, t, i + 1);
+ break;
+ }
+ case IF_ICMPNE: {
+ unsigned t = curBC + readSShort(code, i);
+ THIS->do_ifcmp(curBC, NE, t, i + 1);
+ break;
+ }
+ case IF_ICMPLT: {
+ unsigned t = curBC + readSShort(code, i);
+ THIS->do_ifcmp(curBC, LT, t, i + 1);
+ break;
+ }
+ case IF_ICMPGE: {
+ unsigned t = curBC + readSShort(code, i);
+ THIS->do_ifcmp(curBC, GE, t, i + 1);
+ break;
+ }
+ case IF_ICMPGT: {
+ unsigned t = curBC + readSShort(code, i);
+ THIS->do_ifcmp(curBC, GT, t, i + 1);
+ break;
+ }
+ case IF_ICMPLE: {
+ unsigned t = curBC + readSShort(code, i);
+ THIS->do_ifcmp(curBC, LE, t, i + 1);
+ break;
+ }
+ case IF_IACMPEQ: {
+ unsigned t = curBC + readSShort(code, i);
+ THIS->do_ifcmp(curBC, EQ, t, i + 1);
+ break;
+ }
+ case IF_IACMPNE: {
+ unsigned t = curBC + readSShort(code, i);
+ THIS->do_ifcmp(curBC, NE, t, i + 1);
+ break;
+ }
+ case GOTO:
+ THIS->do_goto(curBC, curBC + readSShort(code, i));
+ break;
+ case JSR:
+ THIS->do_jsr(curBC, curBC + readSShort(code, i));
+ break;
+ case RET:
+ THIS->do_ret(curBC, readUByte(code, i));
+ break;
+ case TABLESWITCH: {
+ switchCases_.clear();
+ skipPadBytes(code, 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_switch(curBC, curBC + def, switchCases_);
+ break;
+ }
+ case LOOKUPSWITCH: {
+ switchCases_.clear();
+ skipPadBytes(code, i);
+ int def = readSInt(code, i);
+ unsigned pairCount = readUInt(code, i);
+ switchCases_.reserve(pairCount);
+ while (pairCount--)
+ switchCases_.push_back(
+ std::make_pair(readSInt(code, i),
+ curBC + readSInt(code, i)));
+ THIS->do_switch(curBC, curBC + def, switchCases_);
+ break;
+ }
+ case IRETURN:
+ case LRETURN:
+ case FRETURN:
+ case DRETURN:
+ case ARETURN:
+ THIS->do_return(curBC);
+ break;
+ case RETURN:
+ THIS->do_return_void(curBC);
+ break;
+ case GETSTATIC:
+ THIS->do_getstatic(curBC, readUShort(code, i));
+ break;
+ case PUTSTATIC:
+ THIS->do_putstatic(curBC, readUShort(code, i));
+ break;
+ case GETFIELD:
+ THIS->do_getfield(curBC, readUShort(code, i));
+ break;
+ case PUTFIELD:
+ THIS->do_putfield(curBC, readUShort(code, i));
+ break;
+ case INVOKEVIRTUAL:
+ THIS->do_invokevirtual(curBC, readUShort(code, i));
+ break;
+ case INVOKESPECIAL:
+ THIS->do_invokespecial(curBC, readUShort(code, i));
+ break;
+ case INVOKESTATIC:
+ THIS->do_invokestatic(curBC, readUShort(code, i));
+ break;
+ case INVOKEINTERFACE: {
+ THIS->do_invokeinterface(curBC, 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(curBC, readUShort(code, i));
+ break;
+ case NEWARRAY:
+ THIS->do_newarray(curBC,
+ static_cast<JType>(readUByte(code, i)));
+ break;
+ case ANEWARRAY:
+ THIS->do_anewarray(curBC, readUShort(code, i));
+ break;
+ case ARRAYLENGTH:
+ THIS->do_arraylength(curBC);
+ break;
+ case ATHROW:
+ THIS->do_athrow(curBC);
+ break;
+ case CHECKCAST:
+ THIS->do_checkcast(curBC, readUShort(code, i));
+ break;
+ case INSTANCEOF:
+ THIS->do_instanceof(curBC, readUShort(code, i));
+ break;
+ case MONITORENTER:
+ THIS->do_monitorenter(curBC);
+ break;
+ case MONITOREXIT:
+ THIS->do_monitorexit(curBC);
+ break;
+ case WIDE:
+ // FIXME: must throw something
+ break;
+ case MULTIANEWARRAY:
+ THIS->do_multianewarray(
+ curBC, readUShort(code, i), readUByte(code, i));
+ break;
+ case IFNULL: {
+ unsigned t = curBC + readUShort(code, i);
+ THIS->do_if(curBC, EQ, REFERENCE, t, i + 1);
+ break;
+ }
+ case IFNONNULL: {
+ unsigned t = curBC + readUShort(code, i);
+ THIS->do_if(curBC, NE, REFERENCE, t, i + 1);
+ break;
+ }
+ case GOTO_W:
+ THIS->do_goto(curBC, curBC + readSInt(code, i));
+ break;
+ case JSR_W:
+ THIS->do_jsr(curBC, curBC + readSInt(code, i));
+ break;
+ case BREAKPOINT:
+ case IMPDEP1:
+ case IMPDEP2:
+ case NOP:
+ break;
+ }
+ }
+ }
+
+ #undef THIS
+
+ /// @brief called on ACONST_NULL
+ void do_aconst_null(unsigned bcI) { }
+ /// @brief called on ICONST_<n>, SIPUSH and BIPUSH
+ void do_iconst(unsigned bcI, int value) { }
+ /// @brief called on LCONST_<n>
+ void do_lconst(unsigned bcI, long long value) { }
+ /// @brief called on FCONST_<n>
+ void do_fconst(unsigned bcI, float value) { }
+ /// @brief called on DCONST_<n>
+ void do_dconst(unsigned bcI, double value) { }
+ /// @brief called on LDC, LDC_W and LDC2_W
+ void do_ldc(unsigned bcI, unsigned index) { }
+ /// @brief called on ILOAD, LLOAD, FLOAD, DLOAD, ALOAD,
+ /// ILOAD_<n>, LLOAD_<n>, FLOAD_<n>, DLOAD_<n>, and ALOAD_<n>
+ void do_load(unsigned bcI, JType type, unsigned index) { }
+ /// @brief called on IALOAD, LALOAD, FALOAD, DALOAD, AALOAD,
+ /// BALOAD, CALOAD, and SALOAD
+ void do_aload(unsigned bcI, JType type) { }
+ /// @brief called on ISTORE, LSTORE, FSTORE, DSTORE, ASTORE,
+ /// ISTORE_<n>, LSTORE_<n>, FSTORE_<n>, DSTORE_<n>, and
+ /// ASTORE_<n>
+ void do_store(unsigned bcI, JType type, unsigned index) { }
+ /// @brief called on IASTORE, LASTORE, FASTORE, DASTORE, AASTORE,
+ /// BASTORE, CASTORE, and SASTORE
+ void do_astore(unsigned bcI, JType type) { }
+ /// @brief called on POP
+ void do_pop(unsigned bcI) { }
+ /// @brief called on POP2
+ void do_pop2(unsigned bcI) { }
+ /// @brief called on DUP
+ void do_dup(unsigned bcI) { }
+ /// @brief called on DUP_X1
+ void do_dup_x1(unsigned bcI) { }
+ /// @brief called on DUP_X2
+ void do_dup_x2(unsigned bcI) { }
+ /// @brief called on DUP2
+ void do_dup2(unsigned bcI) { }
+ /// @brief called on DUP2_X1
+ void do_dup2_x1(unsigned bcI) { }
+ /// @brief called on DUP2_X2
+ void do_dup2_x2(unsigned bcI) { }
+ /// @brief called on SWAP
+ void do_swap(unsigned bcI) { }
+ /// @brief called on IADD, LADD, FADD, and DADD
+ void do_add(unsigned bcI) { }
+ /// @brief called on ISUB, LSUB, FSUB, and DSUB
+ void do_sub(unsigned bcI) { }
+ /// @brief called on IMUL, LMUL, FMUL, and DMUL
+ void do_mul(unsigned bcI) { }
+ /// @brief called on IDIV, LDIV, FDIV, and DDIV
+ void do_div(unsigned bcI) { }
+ /// @brief called on IREM, LREM, FREM, and DREM
+ void do_rem(unsigned bcI) { }
+ /// @brief called on INEG, LNEG, FNEG, and DNEG
+ void do_neg(unsigned bcI) { }
+ /// @brief called on ISHL and LSHL
+ void do_shl(unsigned bcI) { }
+ /// @brief called on ISHR and LSHR
+ void do_shr(unsigned bcI) { }
+ /// @brief called on IUSHR and LUSHR
+ void do_ushr(unsigned bcI) { }
+ /// @brief called on IAND and LAND
+ void do_and(unsigned bcI) { }
+ /// @brief called on IOR or LOR
+ void do_or(unsigned bcI) { }
+ /// @brief called on IXOR and LXOR
+ void do_xor(unsigned bcI) { }
+ /// @brief called on IINC
+ void do_iinc(unsigned bcI, unsigned index, unsigned amount) { }
+ /// @brief called on I2L, I2F, I2D, L2I, L2F, L2D, F2I, F2L,
+ /// F2D, D2I, D2L, D2F, I2B, I2C, and I2S
+ void do_convert(unsigned bcI, JType to) { }
+ /// @brief called on LCMP
+ void do_cmp(unsigned bcI) { }
+ /// @brief called on FCMPL and DCMPL
+ void do_cmpl(unsigned bcI) { }
+ /// @brief called on FCMPG and DCMPG
+ void do_cmpg(unsigned bcI) { }
+ /// @brief called on IF<op>, IFNULL, and IFNONNULL
+ void do_if(unsigned bcI, JSetCC cc, JType type,
+ unsigned t, unsigned f) { }
+ /// @brief called on IFCMP<op> and IFACMP<op>
+ void do_ifcmp(unsigned bcI, JSetCC cc,
+ unsigned t, unsigned f) { }
+ /// @brief called on GOTO and GOTO_W
+ void do_goto(unsigned bcI, unsigned target) { }
+ /// @brief called on JSR and JSR_W
+ void do_jsr(unsigned bcI, unsigned target) { }
+ /// @brief called on RET
+ void do_ret(unsigned bcI, unsigned index) { }
+ /// @brief called on TABLESWITCH and LOOKUPSWITCH
+ void do_switch(unsigned bcI,
+ unsigned defTarget,
+ const SwitchCases& sw) { }
+ /// @brief called on IRETURN, LRETURN, FRETURN, DRETURN and
+ /// ARETURN
+ void do_return(unsigned bcI) { }
+ /// @brief called on RETURN
+ void do_return_void(unsigned bcI) { }
+ /// @brief called on GETSTATIC
+ void do_getstatic(unsigned bcI, unsigned index) { }
+ /// @brief called on PUTSTATIC
+ void do_putstatic(unsigned bcI, unsigned index) { }
+ /// @brief called on GETFIELD
+ void do_getfield(unsigned bcI, unsigned index) { }
+ /// @brief called on PUTFIELD
+ void do_putfield(unsigned bcI, unsigned index) { }
+ /// @brief called on INVOKEVIRTUAL
+ void do_invokevirtual(unsigned bcI, unsigned index) { }
+ /// @brief called on INVOKESPECIAL
+ void do_invokespecial(unsigned bcI, unsigned index) { }
+ /// @brief called on INVOKESTATIC
+ void do_invokestatic(unsigned bcI, unsigned index) { }
+ /// @brief called on INVOKEINTERFACE
+ void do_invokeinterface(unsigned bcI, unsigned index) { }
+ /// @brief called on NEW
+ void do_new(unsigned bcI, unsigned index) { }
+ /// @brief called on NEWARRAY
+ void do_newarray(unsigned bcI, JType type) { }
+ /// @brief called on ANEWARRAY
+ void do_anewarray(unsigned bcI, unsigned index) { }
+ /// @brief called on ARRAYLENGTH
+ void do_arraylength(unsigned bcI) { }
+ /// @brief called on ATHROW
+ void do_athrow(unsigned bcI) { }
+ /// @brief called on CHECKCAST
+ void do_checkcast(unsigned bcI, unsigned index) { }
+ /// @brief called on INSTANCEOF
+ void do_instanceof(unsigned bcI, unsigned index) { }
+ /// @brief called on MONITORENTER
+ void do_monitorenter(unsigned bcI) { }
+ /// @brief called on MONITOREXIT
+ void do_monitorexit(unsigned bcI) { }
+ /// @brief called on MULTIANEWARRAY
+ void do_multianewarray(unsigned bcI,
+ unsigned index,
+ unsigned dims) { }
+ };
+
+ } } // namespace llvm::Java
+
+ #endif//LLVM_JAVA_BYTECODEPARSER_H
Index: llvm-java/include/llvm/Java/Compiler.h
diff -u llvm-java/include/llvm/Java/Compiler.h:1.4 llvm-java/include/llvm/Java/Compiler.h:1.5
--- llvm-java/include/llvm/Java/Compiler.h:1.4 Mon May 24 15:00:23 2004
+++ llvm-java/include/llvm/Java/Compiler.h Mon May 24 20:48:00 2004
@@ -15,34 +15,27 @@
#define LLVM_JAVA_COMPILER_H
#include <llvm/Module.h>
-#include <stack>
-#include <vector>
namespace llvm { namespace Java {
+ namespace {
+ class CompilerImpl;
+ }
+
class Compiler {
public:
+ Compiler();
+ ~Compiler();
+
Module* compile(const ClassFile& cf);
private:
- void compileMethodInit(Function& function,
- const ClassFile& cf,
- const CodeAttribute& codeAttr);
-
- Value* getOrCreateLocal(unsigned index, const Type* type);
-
- void compileMethod(Module& module,
- const ClassFile& cf,
- const Method& method);
+ // do not implement
+ Compiler(const Compiler&);
+ const Compiler& operator=(const Compiler&);
private:
- typedef std::stack<Value*, std::vector<Value*> > OperandStack;
- typedef std::vector<Value*> Locals;
- typedef std::vector<BasicBlock*> BC2BBMap;
-
- OperandStack opStack_;
- Locals locals_;
- BC2BBMap bc2bbMap_;
+ CompilerImpl* compilerImpl_;
};
} } // namespace llvm::Java
Index: llvm-java/include/llvm/Java/Bytecode.h
diff -u llvm-java/include/llvm/Java/Bytecode.h:1.6 llvm-java/include/llvm/Java/Bytecode.h:1.7
--- llvm-java/include/llvm/Java/Bytecode.h:1.6 Mon May 24 17:01:27 2004
+++ llvm-java/include/llvm/Java/Bytecode.h Mon May 24 20:48:00 2004
@@ -233,21 +233,6 @@
} // namespace Opcode
- namespace AType {
-
- enum {
- BOOLEAN = 4,
- CHAR = 5,
- FLOAT = 6,
- DOUBLE = 7,
- BYTE = 8,
- SHORT = 9,
- INT = 10,
- LONG = 11,
- };
-
- } // namespace AType
-
inline int readSByte(const uint8_t* code, unsigned& i) {
return code[++i];
}
More information about the llvm-commits
mailing list