simplify bootstrap method logic (first cut)

Author: jdksjolen

src/hotspot/share/cds/aotConstantPoolResolver.cpp

@@ -411,7 +411,7 @@ bool AOTConstantPoolResolver::check_lambda_metafactory_signature(ConstantPool* c
 }
 
 bool AOTConstantPoolResolver::check_lambda_metafactory_methodtype_arg(ConstantPool* cp, int bsms_attribute_index, int arg_i) {
-  int mt_index = cp->operand_argument_index_at(bsms_attribute_index, arg_i);
+  int mt_index = cp->bsm_attribute_entry(bsms_attribute_index)->argument_index(arg_i);
   if (!cp->tag_at(mt_index).is_method_type()) {
     // malformed class?
     return false;
@@ -427,7 +427,7 @@ bool AOTConstantPoolResolver::check_lambda_metafactory_methodtype_arg(ConstantPo
 }
 
 bool AOTConstantPoolResolver::check_lambda_metafactory_methodhandle_arg(ConstantPool* cp, int bsms_attribute_index, int arg_i) {
-  int mh_index = cp->operand_argument_index_at(bsms_attribute_index, arg_i);
+  int mh_index = cp->bsm_attribute_entry(bsms_attribute_index)->argument_index(arg_i);
   if (!cp->tag_at(mh_index).is_method_handle()) {
     // malformed class?
     return false;
@@ -452,7 +452,8 @@ bool AOTConstantPoolResolver::is_indy_resolution_deterministic(ConstantPool* cp,
     return false;
   }
 
-  int bsm = cp->bootstrap_method_ref_index_at(cp_index);
+  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);
@@ -532,8 +533,7 @@ bool AOTConstantPoolResolver::is_indy_resolution_deterministic(ConstantPool* cp,
       return false;
     }
 
-    int bsms_attribute_index = cp->bootstrap_methods_attribute_index(cp_index);
-    int arg_count = cp->operand_argument_count_at(bsms_attribute_index);
+    int arg_count = cp->bsm_attribute_entry(bsms_attribute_index)->argument_count();
     if (arg_count != 3) {
       // Malformed class?
       return false;

src/hotspot/share/cds/classListParser.cpp

@@ -570,10 +570,11 @@ void ClassListParser::populate_cds_indy_info(const constantPoolHandle &pool, int
   cii->add_item(pool->symbol_at(name_index)->as_C_string());
   int sig_index = pool->signature_ref_index_at(type_index);
   cii->add_item(pool->symbol_at(sig_index)->as_C_string());
-  int argc = pool->bootstrap_argument_count_at(cp_index);
+  auto bsme = pool->bootstrap_methods_attribute_entry(cp_index);
+  int argc = bsme->argument_count();;
   if (argc > 0) {
     for (int arg_i = 0; arg_i < argc; arg_i++) {
-      int arg = pool->bootstrap_argument_index_at(cp_index, 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());

src/hotspot/share/ci/ciEnv.cpp

@@ -821,7 +821,8 @@ ciMethod* ciEnv::get_method_by_index_impl(const constantPoolHandle& cpool,
     // Patch the call site to the nmethod entry point of the static compiled lambda form.
     // As with other two-component call sites, both values must be independently verified.
     assert(index < cpool->cache()->resolved_indy_entries_length(), "impossible");
-    Method* adapter = cpool->resolved_indy_entry_at(index)->method();
+    auto rie = cpool->resolved_indy_entry_at(index);
+    Method* adapter = rie->method();
     // Resolved if the adapter is non null.
     if (adapter != nullptr) {
       return get_method(adapter);
@@ -830,7 +831,7 @@ ciMethod* ciEnv::get_method_by_index_impl(const constantPoolHandle& cpool,
     // Fake a method that is equivalent to a declared method.
     ciInstanceKlass* holder    = get_instance_klass(vmClasses::MethodHandle_klass());
     ciSymbol*        name      = ciSymbols::invokeBasic_name();
-    ciSymbol*        signature = get_symbol(cpool->signature_ref_at(index, bc));
+    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);

src/hotspot/share/classfile/classFileParser.cpp

@@ -2104,7 +2104,6 @@ void ClassFileParser::copy_method_annotations(ConstMethod* cm,
   }
 }
 
-
 // Note: the parse_method below is big and clunky because all parsing of the code and exceptions
 // attribute is inlined. This is cumbersome to avoid since we inline most of the parts in the
 // Method* to save footprint, so we only know the size of the resulting Method* when the
@@ -3280,38 +3279,35 @@ void ClassFileParser::parse_classfile_bootstrap_methods_attribute(const ClassFil
 
   cfs->guarantee_more(attribute_byte_length, CHECK);
 
-  const int attribute_array_length = cfs->get_u2_fast();
+  const int attribute_entry_count = cfs->get_u2_fast();
 
-  guarantee_property(_max_bootstrap_specifier_index < attribute_array_length,
+  guarantee_property(_max_bootstrap_specifier_index < attribute_entry_count,
                      "Short length on BootstrapMethods in class file %s",
                      CHECK);
 
-
   // The attribute contains a counted array of counted tuples of shorts,
   // represending bootstrap specifiers:
-  //    length*{bootstrap_method_index, argument_count*{argument_index}}
-  const unsigned int operand_count = (attribute_byte_length - (unsigned)sizeof(u2)) / (unsigned)sizeof(u2);
-  // operand_count = number of shorts in attr, except for leading length
-
-  // The attribute is copied into a short[] array.
-  // The array begins with a series of short[2] pairs, one for each tuple.
-  const int index_size = (attribute_array_length * 2);
+  //    length*{bootstrap_method_index, argument_count, argument_count*{argument_index}}
+  const unsigned int attribute_tail_length = attribute_byte_length - (unsigned)sizeof(u2);
 
-  Array<u2>* const operands =
-    MetadataFactory::new_array<u2>(_loader_data, index_size + operand_count, CHECK);
+  Array<u4>* const offsets =
+    MetadataFactory::new_array<u4>(_loader_data, attribute_entry_count, CHECK);
+  Array<u2>* const entries =  // u2 data holding all the BSM attribute entries
+    MetadataFactory::new_array<u2>(_loader_data, attribute_tail_length / sizeof(u2), CHECK);
 
-  // Eagerly assign operands so they will be deallocated with the constant
+  // Eagerly assign arrays so they will be deallocated with the constant
   // pool if there is an error.
-  cp->set_operands(operands);
+  cp->set_bsm_attribute_offsets(offsets);
+  cp->set_bsm_attribute_entries(entries);
 
-  int operand_fill_index = index_size;
+  int next_entry = 0;
   const int cp_size = cp->length();
 
-  for (int n = 0; n < attribute_array_length; n++) {
-    // Store a 32-bit offset into the header of the operand array.
-    ConstantPool::operand_offset_at_put(operands, n, operand_fill_index);
+  for (int n = 0; n < attribute_entry_count; n++) {
+    // Store a 32-bit offset into the array of BSM entry offsets.
+    offsets->at_put(n, next_entry);
 
-    // Read a bootstrap specifier.
+    // Read a bootstrap method attribute entry.
     cfs->guarantee_more(sizeof(u2) * 2, CHECK);  // bsm, argc
     const u2 bootstrap_method_index = cfs->get_u2_fast();
     const u2 argument_count = cfs->get_u2_fast();
@@ -3322,12 +3318,12 @@ void ClassFileParser::parse_classfile_bootstrap_methods_attribute(const ClassFil
       bootstrap_method_index,
       CHECK);
 
-    guarantee_property((operand_fill_index + 1 + argument_count) < operands->length(),
+    guarantee_property((next_entry + 2 + argument_count) <= entries->length(),
       "Invalid BootstrapMethods num_bootstrap_methods or num_bootstrap_arguments value in class file %s",
       CHECK);
 
-    operands->at_put(operand_fill_index++, bootstrap_method_index);
-    operands->at_put(operand_fill_index++, argument_count);
+    entries->at_put(next_entry++, bootstrap_method_index);
+    entries->at_put(next_entry++, argument_count);
 
     cfs->guarantee_more(sizeof(u2) * argument_count, CHECK);  // argv[argc]
     for (int j = 0; j < argument_count; j++) {
@@ -3338,12 +3334,35 @@ void ClassFileParser::parse_classfile_bootstrap_methods_attribute(const ClassFil
         "argument_index %u has bad constant type in class file %s",
         argument_index,
         CHECK);
-      operands->at_put(operand_fill_index++, argument_index);
+      entries->at_put(next_entry++, argument_index);
     }
   }
   guarantee_property(current_start + attribute_byte_length == cfs->current(),
                      "Bad length on BootstrapMethods in class file %s",
                      CHECK);
+  assert(next_entry == entries->length(), "");
+
+  // check access methods, for extra luck
+  if (attribute_entry_count > 0) {
+    auto bsme = cp->bsm_attribute_entry(0);
+    assert(bsme->bootstrap_method_index() == entries->at(0), "");
+    assert(bsme->argument_count()         == entries->at(1), "");
+    int nexti = (attribute_entry_count == 1) ? entries->length() : offsets->at(1);
+    assert(nexti == 2 + bsme->argument_count(), "");
+    if (attribute_entry_count > 1) {
+      bsme = cp->bsm_attribute_entry(1);
+      assert(bsme->bootstrap_method_index() == entries->at(nexti+0), "");
+      assert(bsme->argument_count()         == entries->at(nexti+1), "");
+    }
+    int lasti = offsets->at(offsets->length() - 1);
+    bsme = cp->bsm_attribute_entry(attribute_entry_count - 1);
+    assert(bsme->bootstrap_method_index() == entries->at(lasti+0), "");
+    assert(bsme->argument_count()         == entries->at(lasti+1), "");
+    int lastu2 = entries->at(entries->length() - 1);
+    int lastac = bsme->argument_count();
+    int expect_lastu2 = (lastac == 0) ? 0 : bsme->argument_index(lastac-1);
+    assert(lastu2 == expect_lastu2, "");
+  }
 }
 
 void ClassFileParser::parse_classfile_attributes(const ClassFileStream* const cfs,

src/hotspot/share/classfile/verifier.cpp

@@ -2808,9 +2808,9 @@ void ClassVerifier::verify_invoke_instructions(
     default:
       types = 1 << JVM_CONSTANT_Methodref;
   }
-  verify_cp_type(bcs->bci(), index, cp, types, CHECK_VERIFY(this));
 
   // Get method name and signature
+  verify_cp_type(bcs->bci(), index, cp, types, CHECK_VERIFY(this));
   Symbol* method_name = cp->uncached_name_ref_at(index);
   Symbol* method_sig = cp->uncached_signature_ref_at(index);
 

src/hotspot/share/interpreter/bootstrapInfo.cpp

@@ -48,15 +48,22 @@
 BootstrapInfo::BootstrapInfo(const constantPoolHandle& pool, int bss_index, int indy_index)
   : _pool(pool),
     _bss_index(bss_index),
-    _indy_index(indy_index),
-    // derived and eagerly cached:
-    _argc(      pool->bootstrap_argument_count_at(bss_index) ),
-    _name(      pool->uncached_name_ref_at(bss_index) ),
-    _signature( pool->uncached_signature_ref_at(bss_index) )
+    _indy_index(indy_index)
 {
-  _is_resolved = false;
+  assert(bss_index != 0, "");
+  _bsm_attr_index = _pool->bootstrap_methods_attribute_index(_bss_index);
+  _name = pool->uncached_name_ref_at(bss_index);
+  _signature = pool->uncached_signature_ref_at(bss_index);
   assert(pool->tag_at(bss_index).has_bootstrap(), "");
   assert(indy_index == -1 || pool->resolved_indy_entry_at(indy_index)->constant_pool_index() == bss_index, "invalid bootstrap specifier index");
+  _is_resolved = false;
+}
+
+ResolvedIndyEntry* BootstrapInfo::indy_entry() const {
+  if (_indy_index >= 0) {
+    return _pool->resolved_indy_entry_at(_indy_index);
+  }
+  return nullptr;
 }
 
 // If there is evidence this call site was already linked, set the
@@ -130,7 +137,9 @@ void BootstrapInfo::resolve_args(TRAPS) {
   assert(_bsm.not_null(), "resolve_bsm first");
 
   // if there are no static arguments, return leaving _arg_values as null
-  if (_argc == 0 && UseBootstrapCallInfo < 2) return;
+  BSMAttributeEntry* attr = bsm_attr();
+  int argc = attr->argument_count();
+  if (argc == 0 && UseBootstrapCallInfo < 2) return;
 
   bool use_BSCI;
   switch (UseBootstrapCallInfo) {
@@ -156,8 +165,8 @@ void BootstrapInfo::resolve_args(TRAPS) {
   // potentially cyclic cases from C to Java.
   if (!use_BSCI && _pool->tag_at(_bss_index).is_dynamic_constant()) {
     bool found_unresolved_condy = false;
-    for (int i = 0; i < _argc; i++) {
-      int arg_index = _pool->bootstrap_argument_index_at(_bss_index, i);
+    for (int i = 0; i < argc; i++) {
+      int arg_index = attr->argument_index(i);
       if (_pool->tag_at(arg_index).is_dynamic_constant()) {
         // potential recursion point condy -> condy
         bool found_it = false;
@@ -170,14 +179,14 @@ void BootstrapInfo::resolve_args(TRAPS) {
   }
 
   const int SMALL_ARITY = 5;
-  if (use_BSCI && _argc <= SMALL_ARITY && UseBootstrapCallInfo <= 2) {
+  if (use_BSCI && argc <= SMALL_ARITY && UseBootstrapCallInfo <= 2) {
     // If there are only a few arguments, and none of them need linking,
     // push them, instead of asking the JDK runtime to turn around and
     // pull them, saving a JVM/JDK transition in some simple cases.
     bool all_resolved = true;
-    for (int i = 0; i < _argc; i++) {
+    for (int i = 0; i < argc; i++) {
       bool found_it = false;
-      int arg_index = _pool->bootstrap_argument_index_at(_bss_index, i);
+      int arg_index = attr->argument_index(i);
       _pool->find_cached_constant_at(arg_index, found_it, CHECK);
       if (!found_it) { all_resolved = false; break; }
     }
@@ -187,10 +196,11 @@ void BootstrapInfo::resolve_args(TRAPS) {
 
   if (!use_BSCI) {
     // return {arg...}; resolution of arguments is done immediately, before JDK code is called
-    objArrayOop args_oop = oopFactory::new_objArray(vmClasses::Object_klass(), _argc, CHECK);
+    objArrayOop args_oop = oopFactory::new_objArray(vmClasses::Object_klass(), argc, CHECK);
     objArrayHandle args(THREAD, args_oop);
-    _pool->copy_bootstrap_arguments_at(_bss_index, 0, _argc, args, 0, true, Handle(), CHECK);
-    oop arg_oop = ((_argc == 1) ? args->obj_at(0) : (oop)nullptr);
+    _pool->copy_bootstrap_arguments_at(_bsm_attr_index,
+                                       0, argc, args, 0, true, Handle(), CHECK);
+    oop arg_oop = ((argc == 1) ? args->obj_at(0) : (oop)nullptr);
     // try to discard the singleton array
     if (arg_oop != nullptr && !arg_oop->is_array()) {
       // JVM treats arrays and nulls specially in this position,
@@ -200,10 +210,12 @@ void BootstrapInfo::resolve_args(TRAPS) {
       _arg_values = args;
     }
   } else {
-    // return {arg_count, pool_index}; JDK code must pull the arguments as needed
-    typeArrayOop ints_oop = oopFactory::new_typeArray(T_INT, 2, CHECK);
-    ints_oop->int_at_put(0, _argc);
+    // return {arg_count, pool_index, indy_index}
+    // JDK code must pull the arguments as needed
+    typeArrayOop ints_oop = oopFactory::new_typeArray(T_INT, 3, CHECK);
+    ints_oop->int_at_put(0, argc);
     ints_oop->int_at_put(1, _bss_index);
+    ints_oop->int_at_put(2, _indy_index);
     _arg_values = Handle(THREAD, ints_oop);
   }
 }
@@ -236,6 +248,7 @@ void BootstrapInfo::print_msg_on(outputStream* st, const char* msg) {
     os::snprintf_checked(what, sizeof(what), "condy");
   }
   bool have_msg = (msg != nullptr && strlen(msg) > 0);
+  int argc = arg_count();
   st->print_cr("%s%sBootstrap in %s %s@CP[%d] %s:%s%s BSMS[%d] BSM@CP[%d]%s argc=%d%s",
                 (have_msg ? msg : ""), (have_msg ? " " : ""),
                 caller()->name()->as_C_string(),
@@ -244,13 +257,13 @@ void BootstrapInfo::print_msg_on(outputStream* st, const char* msg) {
                 _name->as_C_string(),
                 _signature->as_C_string(),
                 (_type_arg.is_null() ? "" : "(resolved)"),
-                bsms_attr_index(),
+                bsm_attr_index(),
                 bsm_index(), (_bsm.is_null() ? "" : "(resolved)"),
-                _argc, (_arg_values.is_null() ? "" : "(resolved)"));
-  if (_argc > 0) {
+                argc, (_arg_values.is_null() ? "" : "(resolved)"));
+  if (argc > 0) {
     char argbuf[80];
     argbuf[0] = 0;
-    for (int i = 0; i < _argc; i++) {
+    for (int i = 0; i < argc; i++) {
       int pos = (int) strlen(argbuf);
       if (pos + 20 > (int)sizeof(argbuf)) {
         os::snprintf_checked(argbuf + pos, sizeof(argbuf) - pos, "...");
@@ -272,11 +285,11 @@ void BootstrapInfo::print_msg_on(outputStream* st, const char* msg) {
     // Find the static arguments within the first element of _arg_values.
     objArrayOop static_args = (objArrayOop)_arg_values();
     if (!static_args->is_array()) {
-      assert(_argc == 1, "Invalid BSM _arg_values for non-array");
+      assert(argc == 1, "Invalid BSM _arg_values for non-array");
       st->print("  resolved arg[0]: "); static_args->print_on(st);
     } else if (static_args->is_objArray()) {
       int lines = 0;
-      for (int i = 0; i < _argc; i++) {
+      for (int i = 0; i < argc; i++) {
         oop x = static_args->obj_at(i);
         if (x != nullptr) {
           if (++lines > 6) {

src/hotspot/share/interpreter/bootstrapInfo.hpp

@@ -34,7 +34,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)
   const int   _indy_index;      // internal index of indy call site, or -1 if a condy call
-  const int   _argc;            // number of static arguments
+  int         _bsm_attr_index;  // index in the BootstrapMethods attribute
   Symbol*     _name;            // extracted from JVM_CONSTANT_NameAndType
   Symbol*     _signature;
 
@@ -58,7 +58,7 @@ class BootstrapInfo : public StackObj {
   const constantPoolHandle& pool() const{ return _pool; }
   int bss_index() const                 { return _bss_index; }
   int indy_index() const                { return _indy_index; }
-  int argc() const                      { return _argc; }
+  int bsm_attr_index() const            { return _bsm_attr_index; }
   bool is_method_call() const           { return (_indy_index != -1); }
   Symbol* name() const                  { return _name; }
   Symbol* signature() const             { return _signature; }
@@ -76,10 +76,11 @@ class BootstrapInfo : public StackObj {
   // derived accessors
   InstanceKlass* caller() const         { return _pool->pool_holder(); }
   oop caller_mirror() const             { return caller()->java_mirror(); }
-  int bsms_attr_index() const           { return _pool->bootstrap_methods_attribute_index(_bss_index); }
-  int bsm_index() const                 { return _pool->bootstrap_method_ref_index_at(_bss_index); }
-  //int argc() is eagerly cached in _argc
-  int arg_index(int i) const            { return _pool->bootstrap_argument_index_at(_bss_index, i); }
+  BSMAttributeEntry* bsm_attr() const   { return _pool->bsm_attribute_entry(_bsm_attr_index); }
+  int bsm_index() const                 { return bsm_attr()->bootstrap_method_index(); }
+  int arg_count() const                 { return bsm_attr()->argument_count(); }
+  int arg_index(int j) const            { return bsm_attr()->argument_index(j); }
+  ResolvedIndyEntry* indy_entry() const;
 
   // If there is evidence this call site was already linked, set the
   // existing linkage data into result, or throw previous exception.