remove about 25 obsolete methods from constantPool.hpp, adjusting client code

Author: John Rose

src/hotspot/share/cds/aotConstantPoolResolver.cpp

@@ -64,10 +64,8 @@ bool AOTConstantPoolResolver::is_resolution_deterministic(ConstantPool* cp, int
     return resolved_klass != nullptr && is_class_resolution_deterministic(cp->pool_holder(), resolved_klass);
   } else if (cp->tag_at(cp_index).is_invoke_dynamic()) {
     return is_indy_resolution_deterministic(cp, cp_index);
-  } else if (cp->tag_at(cp_index).is_field() ||
-             cp->tag_at(cp_index).is_method() ||
-             cp->tag_at(cp_index).is_interface_method()) {
-    int klass_cp_index = cp->uncached_klass_ref_index_at(cp_index);
+  } else if (cp->tag_at(cp_index).is_field_or_method()) {
+    int klass_cp_index = cp->uncached_field_or_method_ref_at(cp_index).klass_index();
     if (!cp->tag_at(klass_cp_index).is_klass()) {
       // Not yet resolved
       return false;
@@ -283,13 +281,14 @@ void AOTConstantPoolResolver::maybe_resolve_fmi_ref(InstanceKlass* ik, Method* m
     return;
   }
 
-  int klass_cp_index = cp->uncached_klass_ref_index_at(cp_index);
+  int klass_cp_index = cp->uncached_field_or_method_ref_at(cp_index).klass_index();
   if (find_loaded_class(THREAD, cp(), klass_cp_index) == nullptr) {
     // Do not resolve any field/methods from a class that has not been loaded yet.
     return;
   }
 
-  Klass* resolved_klass = cp->klass_ref_at(raw_index, bc, CHECK);
+  auto fmiref = cp->from_bytecode_ref_at(raw_index, bc);
+  Klass* resolved_klass = fmiref.klass(cp, CHECK);
 
   switch (bc) {
   case Bytecodes::_getfield:
@@ -314,8 +313,8 @@ void AOTConstantPoolResolver::maybe_resolve_fmi_ref(InstanceKlass* ik, Method* m
   if (log_is_enabled(Trace, cds, resolve)) {
     ResourceMark rm(THREAD);
     bool resolved = cp->is_resolved(raw_index, bc);
-    Symbol* name = cp->name_ref_at(raw_index, bc);
-    Symbol* signature = cp->signature_ref_at(raw_index, bc);
+    Symbol* name      = fmiref.name(cp);
+    Symbol* signature = fmiref.signature(cp);
     log_trace(cds, resolve)("%s %s [%3d] %s -> %s.%s:%s",
                             (resolved ? "Resolved" : "Failed to resolve"),
                             Bytecodes::name(bc), cp_index, ik->external_name(),
@@ -410,14 +409,14 @@ bool AOTConstantPoolResolver::check_lambda_metafactory_signature(ConstantPool* c
   return !exclude;
 }
 
-bool AOTConstantPoolResolver::check_lambda_metafactory_methodtype_arg(ConstantPool* cp, int bsms_attribute_index, int arg_i) {
-  int mt_index = cp->bsm_attribute_entry(bsms_attribute_index)->argument_index(arg_i);
+bool AOTConstantPoolResolver::check_lambda_metafactory_methodtype_arg(ConstantPool* cp, BSMAttributeEntry* bsme, int arg_i) {
+  int mt_index = bsme->argument_index(arg_i);
   if (!cp->tag_at(mt_index).is_method_type()) {
     // malformed class?
     return false;
   }
 
-  Symbol* sig = cp->method_type_signature_at(mt_index);
+  Symbol* sig = cp->method_type_ref_at(mt_index).signature(cp);
   if (log_is_enabled(Debug, cds, resolve)) {
     ResourceMark rm;
     log_debug(cds, resolve)("Checking MethodType for LambdaMetafactory BSM arg %d: %s", arg_i, sig->as_C_string());
@@ -426,14 +425,14 @@ bool AOTConstantPoolResolver::check_lambda_metafactory_methodtype_arg(ConstantPo
   return check_methodtype_signature(cp, sig);
 }
 
-bool AOTConstantPoolResolver::check_lambda_metafactory_methodhandle_arg(ConstantPool* cp, int bsms_attribute_index, int arg_i) {
-  int mh_index = cp->bsm_attribute_entry(bsms_attribute_index)->argument_index(arg_i);
+bool AOTConstantPoolResolver::check_lambda_metafactory_methodhandle_arg(ConstantPool* cp, BSMAttributeEntry* bsme, int arg_i) {
+  int mh_index = bsme->argument_index(arg_i);
   if (!cp->tag_at(mh_index).is_method_handle()) {
     // malformed class?
     return false;
   }
 
-  Symbol* sig = cp->method_handle_signature_ref_at(mh_index);
+  Symbol* sig = cp->method_handle_ref_at(mh_index).signature(cp);
   if (log_is_enabled(Debug, cds, resolve)) {
     ResourceMark rm;
     log_debug(cds, resolve)("Checking MethodType of MethodHandle for LambdaMetafactory BSM arg %d: %s", arg_i, sig->as_C_string());
@@ -452,12 +451,13 @@ bool AOTConstantPoolResolver::is_indy_resolution_deterministic(ConstantPool* cp,
     return false;
   }
 
-  int bsms_attribute_index = cp->bootstrap_methods_attribute_index(cp_index);
-  int bsm = cp->bsm_attribute_entry(bsms_attribute_index)->bootstrap_method_index();
-  int bsm_ref = cp->method_handle_index_at(bsm);
-  Symbol* bsm_name = cp->uncached_name_ref_at(bsm_ref);
-  Symbol* bsm_signature = cp->uncached_signature_ref_at(bsm_ref);
-  Symbol* bsm_klass = cp->klass_name_at(cp->uncached_klass_ref_index_at(bsm_ref));
+  auto indy = cp->uncached_bootstrap_specifier_ref_at(cp_index);
+  auto bsme = indy.bsme(cp);
+  auto bsmh = bsme->bootstrap_method(cp);
+  Symbol* bsm_name      = bsmh.name(cp);
+  Symbol* bsm_signature = bsmh.signature(cp);
+  Symbol* bsm_klass     = bsmh.klass_name(cp);
+  Symbol* factory_type_sig = indy.signature(cp);
 
   // We currently support only StringConcatFactory::makeConcatWithConstants() and LambdaMetafactory::metafactory()
   // We should mark the allowed BSMs in the JDK code using a private annotation.
@@ -471,7 +471,6 @@ bool AOTConstantPoolResolver::is_indy_resolution_deterministic(ConstantPool* cp,
                              "Ljava/lang/String;"
                              "[Ljava/lang/Object;"
                             ")Ljava/lang/invoke/CallSite;")) {
-    Symbol* factory_type_sig = cp->uncached_signature_ref_at(cp_index);
     if (log_is_enabled(Debug, cds, resolve)) {
       ResourceMark rm;
       log_debug(cds, resolve)("Checking StringConcatFactory callsite signature [%d]: %s", cp_index, factory_type_sig->as_C_string());
@@ -523,7 +522,6 @@ bool AOTConstantPoolResolver::is_indy_resolution_deterministic(ConstantPool* cp,
      *                                In simple use cases this is the same as
      *                                {@code interfaceMethodType}.
      */
-    Symbol* factory_type_sig = cp->uncached_signature_ref_at(cp_index);
     if (log_is_enabled(Debug, cds, resolve)) {
       ResourceMark rm;
       log_debug(cds, resolve)("Checking indy callsite signature [%d]: %s", cp_index, factory_type_sig->as_C_string());
@@ -533,24 +531,24 @@ bool AOTConstantPoolResolver::is_indy_resolution_deterministic(ConstantPool* cp,
       return false;
     }
 
-    int arg_count = cp->bsm_attribute_entry(bsms_attribute_index)->argument_count();
+    int arg_count = bsme->argument_count();
     if (arg_count != 3) {
       // Malformed class?
       return false;
     }
 
     // interfaceMethodType
-    if (!check_lambda_metafactory_methodtype_arg(cp, bsms_attribute_index, 0)) {
+    if (!check_lambda_metafactory_methodtype_arg(cp, bsme, 0)) {
       return false;
     }
 
     // implementation
-    if (!check_lambda_metafactory_methodhandle_arg(cp, bsms_attribute_index, 1)) {
+    if (!check_lambda_metafactory_methodhandle_arg(cp, bsme, 1)) {
       return false;
     }
 
     // dynamicMethodType
-    if (!check_lambda_metafactory_methodtype_arg(cp, bsms_attribute_index, 2)) {
+    if (!check_lambda_metafactory_methodtype_arg(cp, bsme, 2)) {
       return false;
     }
 

src/hotspot/share/cds/aotConstantPoolResolver.hpp

@@ -34,6 +34,7 @@
 #include "utilities/macros.hpp"
 #include "utilities/resourceHash.hpp"
 
+class BSMAttributeEntry;
 class ConstantPool;
 class constantPoolHandle;
 class InstanceKlass;
@@ -76,8 +77,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, int bsms_attribute_index, int arg_i);
-  static bool check_lambda_metafactory_methodhandle_arg(ConstantPool* cp, int bsms_attribute_index, int arg_i);
+  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);
 
 public:
   static void initialize();

src/hotspot/share/cds/classListParser.cpp

@@ -535,26 +535,27 @@ 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.
-  int type_index = pool->bootstrap_name_and_type_ref_index_at(cp_index);
-  int name_index = pool->name_ref_index_at(type_index);
+  auto indy = pool->uncached_bootstrap_specifier_ref_at(cp_index);
+  int name_index = indy.name_index();
   cii->add_item(pool->symbol_at(name_index)->as_C_string());
-  int sig_index = pool->signature_ref_index_at(type_index);
+  int sig_index = indy.signature_index();
   cii->add_item(pool->symbol_at(sig_index)->as_C_string());
-  auto bsme = pool->bootstrap_methods_attribute_entry(cp_index);
+  auto bsme = indy.bsme(pool);
   int argc = bsme->argument_count();;
   if (argc > 0) {
     for (int arg_i = 0; arg_i < argc; arg_i++) {
       int arg = bsme->argument_index(arg_i);
       jbyte tag = pool->tag_at(arg).value();
       if (tag == JVM_CONSTANT_MethodType) {
-        cii->add_item(pool->method_type_signature_at(arg)->as_C_string());
+        auto ref = pool->method_type_ref_at(arg);
+        cii->add_item(ref.signature(pool)->as_C_string());
       } else if (tag == JVM_CONSTANT_MethodHandle) {
-        cii->add_ref_kind(pool->method_handle_ref_kind_at(arg));
-        int callee_index = pool->method_handle_klass_index_at(arg);
-        Klass* callee = pool->klass_at(callee_index, CHECK);
+        auto ref = pool->method_handle_ref_at(arg);
+        cii->add_ref_kind(ref.ref_kind());
+        Klass* callee = ref.klass(pool, CHECK);  // use ref.klass_name here?
         cii->add_item(callee->name()->as_C_string());
-        cii->add_item(pool->method_handle_name_ref_at(arg)->as_C_string());
-        cii->add_item(pool->method_handle_signature_ref_at(arg)->as_C_string());
+        cii->add_item(ref.name(pool)->as_C_string());
+        cii->add_item(ref.signature(pool)->as_C_string());
       } else {
         ShouldNotReachHere();
       }

src/hotspot/share/ci/ciEnv.cpp

@@ -701,18 +701,20 @@ ciConstant ciEnv::get_constant_by_index_impl(const constantPoolHandle& cpool,
   } else if (tag.is_method_type() || tag.is_method_type_in_error()) {
     // must execute Java code to link this CP entry into cache[i].f1
     assert(obj_index >= 0, "should have an object index");
-    ciSymbol* signature = get_symbol(cpool->method_type_signature_at(index));
+    SymbolicReference ref = cpool->method_type_ref_at(index);
+    ciSymbol* signature = get_symbol(ref.signature(cpool));
     ciObject* ciobj = get_unloaded_method_type_constant(signature);
     return ciConstant(T_OBJECT, ciobj);
   } else if (tag.is_method_handle() || tag.is_method_handle_in_error()) {
     // must execute Java code to link this CP entry into cache[i].f1
     assert(obj_index >= 0, "should have an object index");
+    auto ref            = cpool->method_handle_ref_at(index);
     bool ignore_will_link;
-    int ref_kind        = cpool->method_handle_ref_kind_at(index);
-    int callee_index    = cpool->method_handle_klass_index_at(index);
+    int ref_kind        = ref.ref_kind();
+    int callee_index    = ref.ref_index();
     ciKlass* callee     = get_klass_by_index_impl(cpool, callee_index, ignore_will_link, accessor);
-    ciSymbol* name      = get_symbol(cpool->method_handle_name_ref_at(index));
-    ciSymbol* signature = get_symbol(cpool->method_handle_signature_ref_at(index));
+    ciSymbol* name      = get_symbol(ref.name(cpool));
+    ciSymbol* signature = get_symbol(ref.signature(cpool));
     ciObject* ciobj     = get_unloaded_method_handle_constant(callee, name, signature, ref_kind);
     return ciConstant(T_OBJECT, ciobj);
   } else if (tag.is_dynamic_constant() || tag.is_dynamic_constant_in_error()) {
@@ -834,13 +836,14 @@ ciMethod* ciEnv::get_method_by_index_impl(const constantPoolHandle& cpool,
     ciSymbol*        signature = get_symbol(rie->signature(cpool()));
     return get_unloaded_method(holder, name, signature, accessor);
   } else {
-    const int holder_index = cpool->klass_ref_index_at(index, bc);
+    auto mref = cpool->from_bytecode_ref_at(index, bc);
+    const int holder_index = mref.klass_index();
     bool holder_is_accessible;
     ciKlass* holder = get_klass_by_index_impl(cpool, holder_index, holder_is_accessible, accessor);
 
     // Get the method's name and signature.
-    Symbol* name_sym = cpool->name_ref_at(index, bc);
-    Symbol* sig_sym  = cpool->signature_ref_at(index, bc);
+    Symbol* name_sym = mref.name(cpool);
+    Symbol* sig_sym  = mref.signature(cpool);
 
     if (cpool->has_preresolution()
         || ((holder == ciEnv::MethodHandle_klass() || holder == ciEnv::VarHandle_klass()) &&
@@ -1465,12 +1468,13 @@ void ciEnv::process_invokedynamic(const constantPoolHandle &cp, int indy_index,
 
 // Process an invokehandle call site and record any dynamic locations.
 void ciEnv::process_invokehandle(const constantPoolHandle &cp, int index, JavaThread* thread) {
-  const int holder_index = cp->klass_ref_index_at(index, Bytecodes::_invokehandle);
+  auto mref = cp->from_bytecode_ref_at(index, Bytecodes::_invokehandle);
+  const int holder_index = mref.klass_index();
   if (!cp->tag_at(holder_index).is_klass()) {
     return;  // not resolved
   }
   Klass* holder = ConstantPool::klass_at_if_loaded(cp, holder_index);
-  Symbol* name = cp->name_ref_at(index, Bytecodes::_invokehandle);
+  Symbol* name = mref.name(cp);
   if (MethodHandles::is_signature_polymorphic_name(holder, name)) {
     ResolvedMethodEntry* method_entry = cp->resolved_method_entry_at(index);
     if (method_entry->is_resolved(Bytecodes::_invokehandle)) {

src/hotspot/share/ci/ciField.cpp

@@ -79,14 +79,13 @@ ciField::ciField(ciInstanceKlass* klass, int index, Bytecodes::Code bc) :
   assert(klass->get_instanceKlass()->is_linked(), "must be linked before using its constant-pool");
 
   constantPoolHandle cpool(THREAD, klass->get_instanceKlass()->constants());
+  SymbolicReference  ref = cpool->from_bytecode_ref_at(index, bc);
 
   // Get the field's name, signature, and type.
-  Symbol* name  = cpool->name_ref_at(index, bc);
+  Symbol* name  = ref.name(cpool);
   _name = ciEnv::current(THREAD)->get_symbol(name);
 
-  int nt_index = cpool->name_and_type_ref_index_at(index, bc);
-  int sig_index = cpool->signature_ref_index_at(nt_index);
-  Symbol* signature = cpool->symbol_at(sig_index);
+  Symbol* signature = ref.signature(cpool);
   _signature = ciEnv::current(THREAD)->get_symbol(signature);
 
   BasicType field_type = Signature::basic_type(signature);
@@ -97,6 +96,7 @@ ciField::ciField(ciInstanceKlass* klass, int index, Bytecodes::Code bc) :
     bool ignore;
     // This is not really a class reference; the index always refers to the
     // field's type signature, as a symbol.  Linkage checks do not apply.
+    int sig_index = ref.signature_index();
     _type = ciEnv::current(THREAD)->get_klass_by_index(cpool, sig_index, ignore, klass);
   } else {
     _type = ciType::make(field_type);
@@ -108,7 +108,7 @@ ciField::ciField(ciInstanceKlass* klass, int index, Bytecodes::Code bc) :
   //
   // Note: we actually create a ciInstanceKlass for this klass,
   // even though we may not need to.
-  int holder_index = cpool->klass_ref_index_at(index, bc);
+  int holder_index = ref.klass_index();
   bool holder_is_accessible;
 
   ciKlass* generic_declared_holder = ciEnv::current(THREAD)->get_klass_by_index(cpool, holder_index,

src/hotspot/share/ci/ciReplay.cpp

@@ -419,8 +419,9 @@ class CompileReplay : public StackObj {
         pool_index = cp->resolved_indy_entry_at(index)->constant_pool_index();
       } else if (bytecode.is_invokehandle()) {
 #ifdef ASSERT
-        Klass* holder = cp->klass_ref_at(index, bytecode.code(), CHECK_NULL);
-        Symbol* name = cp->name_ref_at(index, bytecode.code());
+        auto ref = cp->from_bytecode_ref_at(index, bytecode.code());
+        Klass* holder = ref.klass(cp, CHECK_NULL);
+        Symbol* name  = ref.name(cp);
         assert(MethodHandles::is_signature_polymorphic_name(holder, name), "");
 #endif
         ResolvedMethodEntry* method_entry = cp->cache()->set_method_handle(index, callInfo);

src/hotspot/share/ci/ciStreams.cpp

@@ -342,7 +342,7 @@ ciInstanceKlass* ciBytecodeStream::get_declared_field_holder() {
 int ciBytecodeStream::get_field_holder_index() {
   GUARDED_VM_ENTRY(
     ConstantPool* cpool = _holder->get_instanceKlass()->constants();
-    return cpool->klass_ref_index_at(get_field_index(), _bc);
+    return cpool->from_bytecode_ref_at(get_field_index(), _bc).klass_index();
   )
 }
 
@@ -526,7 +526,7 @@ ciKlass* ciBytecodeStream::get_declared_method_holder() {
 // deoptimization information.
 int ciBytecodeStream::get_method_holder_index() {
   ConstantPool* cpool = _method->get_Method()->constants();
-  return cpool->klass_ref_index_at(get_method_index(), _bc);
+  return cpool->from_bytecode_ref_at(get_method_index(), _bc).klass_index();
 }
 
 // ------------------------------------------------------------------
@@ -537,8 +537,6 @@ int ciBytecodeStream::get_method_holder_index() {
 // deoptimization information.
 int ciBytecodeStream::get_method_signature_index(const constantPoolHandle& cpool) {
   GUARDED_VM_ENTRY(
-    const int method_index = get_method_index();
-    const int name_and_type_index = cpool->name_and_type_ref_index_at(method_index, _bc);
-    return cpool->signature_ref_index_at(name_and_type_index);
+    return cpool->from_bytecode_ref_at(get_method_index(), _bc).signature_index();
   )
 }

src/hotspot/share/classfile/bytecodeAssembler.cpp

@@ -44,10 +44,10 @@ void BytecodeConstantPool::init() {
       entry = BytecodeCPEntry::utf8(_orig->symbol_at(i));
       break;
     case JVM_CONSTANT_NameAndType:
-      entry = BytecodeCPEntry::name_and_type(_orig->name_ref_index_at(i), _orig->signature_ref_index_at(i));
+      entry = BytecodeCPEntry::name_and_type(_orig->name_and_type_pair_at(i));
       break;
     case JVM_CONSTANT_Methodref:
-      entry = BytecodeCPEntry::methodref(_orig->uncached_klass_ref_index_at(i), _orig->uncached_name_and_type_ref_index_at(i));
+      entry = BytecodeCPEntry::methodref(_orig->uncached_field_or_method_ref_at(i));
       break;
     case JVM_CONSTANT_String:
       entry = BytecodeCPEntry::string(_orig->unresolved_string_at(i));

src/hotspot/share/classfile/bytecodeAssembler.hpp

@@ -104,13 +104,20 @@ class BytecodeCPEntry {
     bcpe._u.name_and_type.type_index = type;
     return bcpe;
   }
+  static BytecodeCPEntry name_and_type(const SymbolicReference& ref) {
+    assert(ref.tag().is_name_and_type(), "");
+    return name_and_type(ref.name_index(), ref.signature_index());
+  }
 
   static BytecodeCPEntry methodref(u2 class_index, u2 nat) {
     BytecodeCPEntry bcpe(METHODREF);
     bcpe._u.methodref.class_index = class_index;
     bcpe._u.methodref.name_and_type_index = nat;
     return bcpe;
   }
+  static BytecodeCPEntry methodref(const SymbolicReference& ref) {
+    return methodref(ref.klass_index(), ref.nt_index());
+  }
 
   static bool equals(BytecodeCPEntry const& e0, BytecodeCPEntry const& e1) {
     // The hash is the "union trick" value of the information saved for the tag,