31 
  32     /**
  33      * Returns the number of entries the constant pool.
  34      *
  35      * @return number of entries in the constant pool
  36      */
  37     int length();
  38 
  39     /**
  40      * Ensures that the type referenced by the specified constant pool entry is loaded and
  41      * initialized. This can be used to compile time resolve a type. It works for field, method, or
  42      * type constant pool entries.
  43      *
  44      * @param cpi the index of the constant pool entry that references the type
  45      * @param opcode the opcode of the instruction that references the type
  46      */
  47     void loadReferencedType(int cpi, int opcode);
  48 
  49     /**
  50      * Looks up a reference to a field. If {@code opcode} is non-negative, then resolution checks
  51      * specific to the bytecode it denotes are performed if the field is already resolved. Should

  52      * any of these checks fail, an unresolved field reference is returned.
  53      *
  54      * @param cpi the constant pool index
  55      * @param opcode the opcode of the instruction for which the lookup is being performed or
  56      *            {@code -1}

  57      * @return a reference to the field at {@code cpi} in this pool
  58      * @throws ClassFormatError if the entry at {@code cpi} is not a field
  59      */
  60     JavaField lookupField(int cpi, int opcode);
  61 
  62     /**
  63      * Looks up a reference to a method. If {@code opcode} is non-negative, then resolution checks
  64      * specific to the bytecode it denotes are performed if the method is already resolved. Should
  65      * any of these checks fail, an unresolved method reference is returned.
  66      *
  67      * @param cpi the constant pool index
  68      * @param opcode the opcode of the instruction for which the lookup is being performed or
  69      *            {@code -1}
  70      * @return a reference to the method at {@code cpi} in this pool
  71      * @throws ClassFormatError if the entry at {@code cpi} is not a method
  72      */
  73     JavaMethod lookupMethod(int cpi, int opcode);
  74 
  75     /**
  76      * Looks up a reference to a type. If {@code opcode} is non-negative, then resolution checks
  77      * specific to the bytecode it denotes are performed if the type is already resolved. Should any
  78      * of these checks fail, an unresolved type reference is returned.
  79      *
  80      * @param cpi the constant pool index

  31 
  32     /**
  33      * Returns the number of entries the constant pool.
  34      *
  35      * @return number of entries in the constant pool
  36      */
  37     int length();
  38 
  39     /**
  40      * Ensures that the type referenced by the specified constant pool entry is loaded and
  41      * initialized. This can be used to compile time resolve a type. It works for field, method, or
  42      * type constant pool entries.
  43      *
  44      * @param cpi the index of the constant pool entry that references the type
  45      * @param opcode the opcode of the instruction that references the type
  46      */
  47     void loadReferencedType(int cpi, int opcode);
  48 
  49     /**
  50      * Looks up a reference to a field. If {@code opcode} is non-negative, then resolution checks
  51      * specific to the bytecode it denotes are performed if the field is already resolved. Checks
  52      * for some bytecodes require the method that contains the bytecode to be specified. Should
  53      * any of these checks fail, an unresolved field reference is returned.
  54      *
  55      * @param cpi the constant pool index
  56      * @param opcode the opcode of the instruction for which the lookup is being performed or
  57      *            {@code -1}
  58      * @param method the method for which the lookup is being performed
  59      * @return a reference to the field at {@code cpi} in this pool
  60      * @throws ClassFormatError if the entry at {@code cpi} is not a field
  61      */
  62     JavaField lookupField(int cpi, ResolvedJavaMethod method, int opcode);
  63 
  64     /**
  65      * Looks up a reference to a method. If {@code opcode} is non-negative, then resolution checks
  66      * specific to the bytecode it denotes are performed if the method is already resolved. Should
  67      * any of these checks fail, an unresolved method reference is returned.
  68      *
  69      * @param cpi the constant pool index
  70      * @param opcode the opcode of the instruction for which the lookup is being performed or
  71      *            {@code -1}
  72      * @return a reference to the method at {@code cpi} in this pool
  73      * @throws ClassFormatError if the entry at {@code cpi} is not a method
  74      */
  75     JavaMethod lookupMethod(int cpi, int opcode);
  76 
  77     /**
  78      * Looks up a reference to a type. If {@code opcode} is non-negative, then resolution checks
  79      * specific to the bytecode it denotes are performed if the type is already resolved. Should any
  80      * of these checks fail, an unresolved type reference is returned.
  81      *
  82      * @param cpi the constant pool index