move CP indexing structs inside of ConstantPool; rename BSReference as BootstrapReference

Author: John Rose

src/hotspot/share/cds/aotConstantPoolResolver.cpp

@@ -411,7 +411,8 @@ bool AOTConstantPoolResolver::check_lambda_metafactory_signature(ConstantPool* c
   return !exclude;
 }
 
-bool AOTConstantPoolResolver::check_lambda_metafactory_methodtype_arg(ConstantPool* cp, BSMAttributeEntry* bsme, int arg_i) {
+bool AOTConstantPoolResolver::check_lambda_metafactory_methodtype_arg(ConstantPool* cp, int bsme_index, int arg_i) {
+  BSMAttributeEntry* bsme = cp->bsm_attribute_entry(bsme_index);
   int mt_index = bsme->argument_index(arg_i);
   if (!cp->tag_at(mt_index).is_method_type()) {
     // malformed class?
@@ -428,7 +429,8 @@ bool AOTConstantPoolResolver::check_lambda_metafactory_methodtype_arg(ConstantPo
   return check_methodtype_signature(cp, sig);
 }
 
-bool AOTConstantPoolResolver::check_lambda_metafactory_methodhandle_arg(ConstantPool* cp, BSMAttributeEntry* bsme, int arg_i) {
+bool AOTConstantPoolResolver::check_lambda_metafactory_methodhandle_arg(ConstantPool* cp, int bsme_index, int arg_i) {
+  BSMAttributeEntry* bsme = cp->bsm_attribute_entry(bsme_index);
   int mh_index = bsme->argument_index(arg_i);
   if (!cp->tag_at(mh_index).is_method_handle()) {
     // malformed class?
@@ -455,9 +457,10 @@ bool AOTConstantPoolResolver::is_indy_resolution_deterministic(ConstantPool* cp,
     return false;
   }
 
-  BSReference indy(cp, cp_index);
+  BootstrapReference indy(cp, cp_index);
   BSMAttributeEntry* bsme    = indy.bsme(cp);
   MethodHandleReference bsmh = bsme->bootstrap_method(cp);
+  int     bsme_index         = indy.bsme_index();
   Symbol* bsm_name           = bsmh.name(cp);
   Symbol* bsm_signature      = bsmh.signature(cp);
   Symbol* bsm_klass          = bsmh.klass_name(cp);
@@ -542,17 +545,17 @@ bool AOTConstantPoolResolver::is_indy_resolution_deterministic(ConstantPool* cp,
     }
 
     // interfaceMethodType
-    if (!check_lambda_metafactory_methodtype_arg(cp, bsme, 0)) {
+    if (!check_lambda_metafactory_methodtype_arg(cp, bsme_index, 0)) {
       return false;
     }
 
     // implementation
-    if (!check_lambda_metafactory_methodhandle_arg(cp, bsme, 1)) {
+    if (!check_lambda_metafactory_methodhandle_arg(cp, bsme_index, 1)) {
       return false;
     }
 
     // dynamicMethodType
-    if (!check_lambda_metafactory_methodtype_arg(cp, bsme, 2)) {
+    if (!check_lambda_metafactory_methodtype_arg(cp, bsme_index, 2)) {
       return false;
     }
 

src/hotspot/share/cds/aotConstantPoolResolver.hpp

@@ -34,7 +34,6 @@
 #include "utilities/macros.hpp"
 #include "utilities/resourceHash.hpp"
 
-class BSMAttributeEntry;
 class ConstantPool;
 class constantPoolHandle;
 class InstanceKlass;
@@ -77,8 +76,8 @@ class AOTConstantPoolResolver :  AllStatic {
 
   static bool check_methodtype_signature(ConstantPool* cp, Symbol* sig, Klass** return_type_ret = nullptr);
   static bool check_lambda_metafactory_signature(ConstantPool* cp, Symbol* sig);
-  static bool check_lambda_metafactory_methodtype_arg(ConstantPool* cp, BSMAttributeEntry* bsme, int arg_i);
-  static bool check_lambda_metafactory_methodhandle_arg(ConstantPool* cp, BSMAttributeEntry* bsme, int arg_i);
+  static bool check_lambda_metafactory_methodtype_arg(ConstantPool* cp, int bsme_index, int arg_i);
+  static bool check_lambda_metafactory_methodhandle_arg(ConstantPool* cp, int bsme_index, int arg_i);
 
 public:
   static void initialize();

src/hotspot/share/cds/classListParser.cpp

@@ -535,7 +535,7 @@ InstanceKlass* ClassListParser::load_class_from_source(Symbol* class_name, TRAPS
 
 void ClassListParser::populate_cds_indy_info(const constantPoolHandle &pool, int cp_index, CDSIndyInfo* cii, TRAPS) {
   // Caller needs to allocate ResourceMark.
-  BSReference indy(pool, cp_index);
+  BootstrapReference indy(pool, cp_index);
   int name_index = indy.name_index();
   cii->add_item(pool->symbol_at(name_index)->as_C_string());
   int sig_index = indy.signature_index();

src/hotspot/share/classfile/classFileParser.cpp

@@ -446,7 +446,7 @@ void ClassFileParser::parse_constant_pool(const ClassFileStream* const stream,
         if (!_need_verify) break;
         // Use RawReference because CP structure is not fully checked yet.
         // A real FMReference causes asserts to fire on some bad classfiles.
-        RawReference ref(/*allow_malformed*/ true, cp, index);
+        RawReference ref = cp->possibly_malformed_RawReference_at(index);
         const int klass_ref_index         = ref.third_index();
         const int name_and_type_ref_index = ref.nt_index();
         guarantee_property(valid_klass_reference_at(klass_ref_index),
@@ -576,8 +576,8 @@ void ClassFileParser::parse_constant_pool(const ClassFileStream* const stream,
       case JVM_CONSTANT_InvokeDynamic:
       case JVM_CONSTANT_Dynamic: {
         // Use RawReference because CP structure is not fully checked yet.
-        // A real BSReference causes asserts to fire on some bad classfiles.
-        RawReference bsref(/*allow_malformed*/ true, cp, index);
+        // A real BootstrapReference causes asserts to fire on some bad classfiles.
+        RawReference bsref = cp->possibly_malformed_RawReference_at(index);
         const int name_and_type_ref_index = bsref.nt_index();
 
         guarantee_property(valid_cp_range(name_and_type_ref_index, length) &&
@@ -646,7 +646,7 @@ void ClassFileParser::parse_constant_pool(const ClassFileStream* const stream,
         if (_need_verify) {
           // CONSTANT_Dynamic's name and signature are verified above, when iterating NameAndType_info.
           // Need only to be sure signature is the right type.
-          BSReference bsref(cp, index);
+          BootstrapReference bsref(cp, index);
           // name, signature are already verified to be utf8
           if (Signature::is_method(bsref.signature(cp))) {
             throwIllegalSignature("CONSTANT_Dynamic", bsref.name(cp), bsref.signature(cp), CHECK);

src/hotspot/share/classfile/verifier.cpp

@@ -2193,7 +2193,7 @@ void ClassVerifier::verify_ldc(
       VerificationType::reference_type(
         vmSymbols::java_lang_invoke_MethodType()), CHECK_VERIFY(this));
   } else if (tag.is_dynamic_constant()) {
-    BSReference condy(cp, index);
+    BootstrapReference condy(cp, index);
     Symbol* constant_type = condy.signature(cp);
     // Field signature was checked in ClassFileParser.
     assert(SignatureVerifier::is_valid_type_signature(constant_type),

src/hotspot/share/interpreter/bootstrapInfo.hpp

@@ -33,7 +33,7 @@
 class BootstrapInfo : public StackObj {
   constantPoolHandle _pool;     // constant pool containing the bootstrap specifier
   const int   _bss_index;       // index of bootstrap specifier in CP (condy or indy)
-  BSReference _bss_data;        // indexes unpacked from the _bss_index
+  BootstrapReference _bss_data; // indexes unpacked from the _bss_index
   const int   _indy_index;      // internal index of indy call site, or -1 if a condy call
   Symbol*     _name;            // extracted from JVM_CONSTANT_NameAndType
   Symbol*     _signature;

src/hotspot/share/interpreter/bytecodeTracer.cpp

@@ -282,7 +282,7 @@ void BytecodePrinter::print_dynamic(int cp_index, outputStream* st) {
     return;
   }
 
-  BSReference ref(constants, cp_index);
+  BootstrapReference ref(constants, cp_index);
   st->print(" bsm=%d", ref.bsme(constants)->bootstrap_method_index());
 
   Symbol* name = ref.name(constants);
@@ -307,7 +307,7 @@ void BytecodePrinter::print_invokedynamic(int indy_index, int cp_index, outputSt
 
 // cp_index: must be the cp_index of a JVM_CONSTANT_{Dynamic, DynamicInError, InvokeDynamic}
 void BytecodePrinter::print_bsm(int cp_index, outputStream* st) {
-  BSReference indy(constants(), cp_index);
+  BootstrapReference indy(constants(), cp_index);
   BSMAttributeEntry* bsme = indy.bsme(constants());
   MethodHandleReference bsmh = bsme->bootstrap_method(constants());
   const char* ref_kind = "";

src/hotspot/share/interpreter/linkResolver.cpp

@@ -651,7 +651,7 @@ Method* LinkResolver::resolve_method_statically(Bytecodes::Code code,
   // FIXME: Remove this method and ciMethod::check_call; refactor to use the other LinkResolver entry points.
   // resolve klass
   if (code == Bytecodes::_invokedynamic) {
-    BSReference indy(pool, index, code);
+    BootstrapReference indy(pool, index, code);
     Klass* resolved_klass = vmClasses::MethodHandle_klass();
     Symbol* method_name = vmSymbols::invoke_name();
     Symbol* method_signature = indy.signature(pool);

src/hotspot/share/interpreter/rewriter.cpp

@@ -357,7 +357,7 @@ void Rewriter::maybe_rewrite_ldc(address bcp, int offset, bool is_wide,
         (tag.is_dynamic_constant() &&
          // keep regular ldc interpreter logic for condy primitives
          is_reference_type(Signature::basic_type(
-           BSReference(_pool, cp_index).signature(_pool)
+           BootstrapReference(_pool, cp_index).signature(_pool)
          )))
         ) {
       int ref_index = cp_entry_to_resolved_references(cp_index);

src/hotspot/share/jvmci/jvmciCompilerToVM.cpp

@@ -748,7 +748,7 @@ C2V_VMENTRY_NULL(jobject, lookupConstantInPool, (JNIEnv* env, jobject, ARGUMENT_
     if (obj == nullptr) {
       return JVMCIENV->get_jobject(JVMCIENV->get_JavaConstant_NULL_POINTER());
     }
-    BSReference condy(cp, cp_index);
+    BootstrapReference condy(cp, cp_index);
     BasicType bt = Signature::basic_type(condy.signature(cp));
     if (!is_reference_type(bt)) {
       if (!is_java_primitive(bt)) {
@@ -891,7 +891,7 @@ C2V_END
 
 C2V_VMENTRY_0(jint, bootstrapArgumentIndexAt, (JNIEnv* env, jobject, ARGUMENT_PAIR(cp), jint cpi, jint index))
   constantPoolHandle cp(THREAD, UNPACK_PAIR(ConstantPool, cp));
-  BSReference indy(cp, cpi);  // indy or condy
+  BootstrapReference indy(cp, cpi);  // indy or condy
   BSMAttributeEntry* bsme = indy.bsme(cp);
   return bsme->argument_index(index);
 C2V_END