Fixing fixing

Author: jdksjolen

src/hotspot/share/cds/classListParser.cpp

@@ -570,24 +570,22 @@ 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());
-  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 = 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());
-      } 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);
-        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());
-      } else {
-        ShouldNotReachHere();
-      }
+  BSMAttributeEntry* bsme = pool->bootstrap_methods_attribute_entry(cp_index);
+  int argc = bsme->argument_count();
+  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());
+    } 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);
+      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());
+    } else {
+      ShouldNotReachHere();
     }
   }
 }

src/hotspot/share/ci/ciEnv.cpp

@@ -821,7 +821,7 @@ 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");
-    auto rie = cpool->resolved_indy_entry_at(index);
+    ResolvedIndyEntry* rie = cpool->resolved_indy_entry_at(index);
     Method* adapter = rie->method();
     // Resolved if the adapter is non null.
     if (adapter != nullptr) {

src/hotspot/share/classfile/classFileParser.cpp

@@ -3279,90 +3279,94 @@ void ClassFileParser::parse_classfile_bootstrap_methods_attribute(const ClassFil
 
   cfs->guarantee_more(attribute_byte_length, CHECK);
 
-  const int attribute_entry_count = cfs->get_u2_fast();
+  const u2 num_bootstrap_methods = cfs->get_u2_fast();
 
-  guarantee_property(_max_bootstrap_specifier_index < attribute_entry_count,
+  guarantee_property(_max_bootstrap_specifier_index < num_bootstrap_methods,
                      "Short length on BootstrapMethods in class file %s",
                      CHECK);
 
   // The attribute contains a counted array of counted tuples of shorts,
-  // represending bootstrap specifiers:
+  // representing bootstrap specifiers:
   //    length*{bootstrap_method_index, argument_count, argument_count*{argument_index}}
-  const unsigned int attribute_tail_length = attribute_byte_length - (unsigned)sizeof(u2);
-
+  const u4 attribute_tail_length = attribute_byte_length - static_cast<u4>(sizeof(u2));
+  assert(attribute_tail_length % sizeof(u2) == 0, "");
   Array<u4>* const offsets =
-    MetadataFactory::new_array<u4>(_loader_data, attribute_entry_count, CHECK);
+    MetadataFactory::new_array<u4>(_loader_data, num_bootstrap_methods, 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 arrays so they will be deallocated with the constant
-  // pool if there is an error.
+  // Eagerly assign arrays so they will be deallocated with
+  // the constant pool if there is an error.
   cp->set_bsm_attribute_offsets(offsets);
   cp->set_bsm_attribute_entries(entries);
 
   int next_entry = 0;
   const int cp_size = cp->length();
 
-  for (int n = 0; n < attribute_entry_count; n++) {
+  for (int n = 0; n < num_bootstrap_methods; n++) {
     // Store a 32-bit offset into the array of BSM entry offsets.
     offsets->at_put(n, next_entry);
 
     // 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();
+    const u2 bootstrap_method_ref = cfs->get_u2_fast();
+    const u2 num_bootstrap_arguments = cfs->get_u2_fast();
     guarantee_property(
-      valid_cp_range(bootstrap_method_index, cp_size) &&
-      cp->tag_at(bootstrap_method_index).is_method_handle(),
+      valid_cp_range(bootstrap_method_ref, cp_size) &&
+      cp->tag_at(bootstrap_method_ref).is_method_handle(),
       "bootstrap_method_index %u has bad constant type in class file %s",
-      bootstrap_method_index,
+      bootstrap_method_ref,
       CHECK);
 
-    guarantee_property((next_entry + 2 + argument_count) <= entries->length(),
+    guarantee_property((next_entry + 2 + num_bootstrap_arguments) <= entries->length(),
       "Invalid BootstrapMethods num_bootstrap_methods or num_bootstrap_arguments value in class file %s",
       CHECK);
 
-    entries->at_put(next_entry++, bootstrap_method_index);
-    entries->at_put(next_entry++, argument_count);
+    entries->at_put(next_entry, bootstrap_method_ref);
+    next_entry++;
+    entries->at_put(next_entry, num_bootstrap_arguments);
+    next_entry++;
 
-    cfs->guarantee_more(sizeof(u2) * argument_count, CHECK);  // argv[argc]
-    for (int j = 0; j < argument_count; j++) {
+    cfs->guarantee_more(sizeof(u2) * num_bootstrap_arguments, CHECK);  // argv[argc]
+    for (u2 j = 0; j < num_bootstrap_arguments; j++) {
       const u2 argument_index = cfs->get_u2_fast();
       guarantee_property(
         valid_cp_range(argument_index, cp_size) &&
         cp->tag_at(argument_index).is_loadable_constant(),
         "argument_index %u has bad constant type in class file %s",
         argument_index,
         CHECK);
-      entries->at_put(next_entry++, argument_index);
+      entries->at_put(next_entry, argument_index);
+      next_entry++;
     }
   }
   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);
+#ifdef ASSERT
+  if (num_bootstrap_methods > 0) {
+    BSMAttributeEntry* 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);
+    int nexti = (num_bootstrap_methods == 1) ? entries->length() : offsets->at(1);
     assert(nexti == 2 + bsme->argument_count(), "");
-    if (attribute_entry_count > 1) {
+    if (num_bootstrap_methods > 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);
+    bsme = cp->bsm_attribute_entry(num_bootstrap_methods - 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, "");
   }
+#endif
 }
 
 void ClassFileParser::parse_classfile_attributes(const ClassFileStream* const cfs,

src/hotspot/share/interpreter/bootstrapInfo.cpp

@@ -137,8 +137,8 @@ void BootstrapInfo::resolve_args(TRAPS) {
   assert(_bsm.not_null(), "resolve_bsm first");
 
   // if there are no static arguments, return leaving _arg_values as null
-  BSMAttributeEntry* attr = bsm_attr();
-  int argc = attr->argument_count();
+  BSMAttributeEntry& attr = bsm_attr();
+  int argc = attr.argument_count();
   if (argc == 0 && UseBootstrapCallInfo < 2) return;
 
   bool use_BSCI;
@@ -166,16 +166,20 @@ void BootstrapInfo::resolve_args(TRAPS) {
   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 = attr->argument_index(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;
         _pool->find_cached_constant_at(arg_index, found_it, CHECK);
-        if (!found_it) { found_unresolved_condy = true; break; }
+        if (!found_it) {
+          found_unresolved_condy = true;
+          break;
+        }
       }
     }
-    if (found_unresolved_condy)
+    if (found_unresolved_condy) {
       use_BSCI = true;
+    }
   }
 
   const int SMALL_ARITY = 5;
@@ -186,12 +190,16 @@ void BootstrapInfo::resolve_args(TRAPS) {
     bool all_resolved = true;
     for (int i = 0; i < argc; i++) {
       bool found_it = false;
-      int arg_index = attr->argument_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; }
+      if (!found_it) {
+        all_resolved = false;
+        break;
+      }
     }
-    if (all_resolved)
+    if (all_resolved) {
       use_BSCI = false;
+    }
   }
 
   if (!use_BSCI) {

src/hotspot/share/interpreter/bootstrapInfo.hpp

@@ -43,7 +43,7 @@ class BootstrapInfo : public StackObj {
   Handle      _name_arg;        // resolved String
   Handle      _type_arg;        // resolved Class or MethodType
   Handle      _arg_values;      // array of static arguments; null implies either
-                                // uresolved or zero static arguments are specified
+                                // unresolved or zero static arguments are specified
 
   // post-bootstrap resolution state:
   bool        _is_resolved;       // set true when any of the next fields are set
@@ -76,10 +76,10 @@ class BootstrapInfo : public StackObj {
   // derived accessors
   InstanceKlass* caller() const         { return _pool->pool_holder(); }
   oop caller_mirror() const             { return caller()->java_mirror(); }
-  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); }
+  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

src/hotspot/share/interpreter/bytecodeTracer.cpp

@@ -326,8 +326,8 @@ void BytecodePrinter::print_bsm(int cp_index, outputStream* st) {
   }
   st->print("  BSM: %s", ref_kind);
   print_field_or_method(constants()->method_handle_index_at(bsm), st);
-  auto bsme = constants()->bootstrap_methods_attribute_entry(cp_index);
-  int argc = bsme->argument_count();;
+  BSMAttributeEntry* bsme = constants()->bootstrap_methods_attribute_entry(cp_index);
+  int argc = bsme->argument_count();
   st->print("  arguments[%d] = {", argc);
   if (argc > 0) {
     st->cr();

src/hotspot/share/oops/array.hpp

@@ -126,6 +126,7 @@ class Array: public MetaspaceObj {
   T    at(int i) const                 { assert(i >= 0 && i< _length, "oob: 0 <= %d < %d", i, _length); return data()[i]; }
   void at_put(const int i, const T& x) { assert(i >= 0 && i< _length, "oob: 0 <= %d < %d", i, _length); data()[i] = x; }
   T*   adr_at(const int i)             { assert(i >= 0 && i< _length, "oob: 0 <= %d < %d", i, _length); return &data()[i]; }
+  const T* adr_at(const int i) const   { assert(i >= 0 && i< _length, "oob: 0 <= %d < %d", i, _length); return &data()[i]; }
   int  find(const T& x)                { return index_of(x); }
 
   T at_acquire(const int i)            { return Atomic::load_acquire(adr_at(i)); }