< prev index next >

src/hotspot/share/classfile/classFileParser.cpp

Print this page

   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */

  24 #include "cds/cdsConfig.hpp"
  25 #include "classfile/classFileParser.hpp"
  26 #include "classfile/classFileStream.hpp"
  27 #include "classfile/classLoader.hpp"
  28 #include "classfile/classLoaderData.inline.hpp"
  29 #include "classfile/classLoadInfo.hpp"
  30 #include "classfile/defaultMethods.hpp"
  31 #include "classfile/fieldLayoutBuilder.hpp"
  32 #include "classfile/javaClasses.inline.hpp"
  33 #include "classfile/moduleEntry.hpp"
  34 #include "classfile/packageEntry.hpp"
  35 #include "classfile/symbolTable.hpp"
  36 #include "classfile/systemDictionary.hpp"
  37 #include "classfile/verificationType.hpp"
  38 #include "classfile/verifier.hpp"
  39 #include "classfile/vmClasses.hpp"
  40 #include "classfile/vmSymbols.hpp"
  41 #include "jvm.h"
  42 #include "logging/log.hpp"
  43 #include "logging/logStream.hpp"
  44 #include "memory/allocation.hpp"
  45 #include "memory/metadataFactory.hpp"
  46 #include "memory/oopFactory.hpp"
  47 #include "memory/resourceArea.hpp"
  48 #include "memory/universe.hpp"
  49 #include "oops/annotations.hpp"
  50 #include "oops/constantPool.inline.hpp"
  51 #include "oops/fieldInfo.hpp"
  52 #include "oops/fieldStreams.inline.hpp"

  53 #include "oops/instanceKlass.inline.hpp"
  54 #include "oops/instanceMirrorKlass.hpp"
  55 #include "oops/klass.inline.hpp"
  56 #include "oops/klassVtable.hpp"
  57 #include "oops/metadata.hpp"
  58 #include "oops/method.inline.hpp"
  59 #include "oops/oop.inline.hpp"
  60 #include "oops/recordComponent.hpp"
  61 #include "oops/symbol.hpp"
  62 #include "prims/jvmtiExport.hpp"
  63 #include "prims/jvmtiThreadState.hpp"
  64 #include "runtime/arguments.hpp"
  65 #include "runtime/fieldDescriptor.inline.hpp"
  66 #include "runtime/handles.inline.hpp"
  67 #include "runtime/javaCalls.hpp"
  68 #include "runtime/os.hpp"
  69 #include "runtime/perfData.hpp"
  70 #include "runtime/reflection.hpp"
  71 #include "runtime/safepointVerifiers.hpp"
  72 #include "runtime/signature.hpp"
  73 #include "runtime/timer.hpp"
  74 #include "services/classLoadingService.hpp"
  75 #include "services/threadService.hpp"
  76 #include "utilities/align.hpp"
  77 #include "utilities/bitMap.inline.hpp"
  78 #include "utilities/checkedCast.hpp"
  79 #include "utilities/copy.hpp"
  80 #include "utilities/exceptions.hpp"
  81 #include "utilities/formatBuffer.hpp"
  82 #include "utilities/globalDefinitions.hpp"
  83 #include "utilities/growableArray.hpp"
  84 #include "utilities/hashTable.hpp"
  85 #include "utilities/macros.hpp"
  86 #include "utilities/ostream.hpp"

  87 #include "utilities/utf8.hpp"
  88 #if INCLUDE_CDS
  89 #include "classfile/systemDictionaryShared.hpp"
  90 #endif
  91 #if INCLUDE_JFR
  92 #include "jfr/support/jfrTraceIdExtension.hpp"
  93 #endif
  94 
  95 // We generally try to create the oops directly when parsing, rather than
  96 // allocating temporary data structures and copying the bytes twice. A
  97 // temporary area is only needed when parsing utf8 entries in the constant
  98 // pool and when parsing line number tables.
  99 
 100 // We add assert in debug mode when class format is not checked.
 101 
 102 #define JAVA_CLASSFILE_MAGIC              0xCAFEBABE
 103 #define JAVA_MIN_SUPPORTED_VERSION        45
 104 #define JAVA_PREVIEW_MINOR_VERSION        65535
 105 
 106 // Used for two backward compatibility reasons:

 139 #define JAVA_17_VERSION                   61
 140 
 141 #define JAVA_18_VERSION                   62
 142 
 143 #define JAVA_19_VERSION                   63
 144 
 145 #define JAVA_20_VERSION                   64
 146 
 147 #define JAVA_21_VERSION                   65
 148 
 149 #define JAVA_22_VERSION                   66
 150 
 151 #define JAVA_23_VERSION                   67
 152 
 153 #define JAVA_24_VERSION                   68
 154 
 155 #define JAVA_25_VERSION                   69
 156 
 157 #define JAVA_26_VERSION                   70
 158 


 159 void ClassFileParser::set_class_bad_constant_seen(short bad_constant) {
 160   assert((bad_constant == JVM_CONSTANT_Module ||
 161           bad_constant == JVM_CONSTANT_Package) && _major_version >= JAVA_9_VERSION,
 162          "Unexpected bad constant pool entry");
 163   if (_bad_constant_seen == 0) _bad_constant_seen = bad_constant;
 164 }
 165 
 166 void ClassFileParser::parse_constant_pool_entries(const ClassFileStream* const stream,
 167                                                   ConstantPool* cp,
 168                                                   const int length,
 169                                                   TRAPS) {
 170   assert(stream != nullptr, "invariant");
 171   assert(cp != nullptr, "invariant");
 172 
 173   // Use a local copy of ClassFileStream. It helps the C++ compiler to optimize
 174   // this function (_current can be allocated in a register, with scalar
 175   // replacement of aggregates). The _current pointer is copied back to
 176   // stream() when this function returns. DON'T call another method within
 177   // this method that uses stream().
 178   const ClassFileStream cfs1 = *stream;
 179   const ClassFileStream* const cfs = &cfs1;
 180 
 181   DEBUG_ONLY(const u1* const old_current = stream->current();)
 182 
 183   // Used for batching symbol allocations.
 184   const char* names[SymbolTable::symbol_alloc_batch_size];
 185   int lengths[SymbolTable::symbol_alloc_batch_size];
 186   int indices[SymbolTable::symbol_alloc_batch_size];
 187   unsigned int hashValues[SymbolTable::symbol_alloc_batch_size];
 188   int names_count = 0;
 189 
 190   // parsing  Index 0 is unused
 191   for (int index = 1; index < length; index++) {
 192     // Each of the following case guarantees one more byte in the stream
 193     // for the following tag or the access_flags following constant pool,
 194     // so we don't need bounds-check for reading tag.
 195     const u1 tag = cfs->get_u1_fast();
 196     switch (tag) {
 197       case JVM_CONSTANT_Class : {
 198         cfs->guarantee_more(3, CHECK);  // name_index, tag/access_flags
 199         const u2 name_index = cfs->get_u2_fast();
 200         cp->klass_index_at_put(index, name_index);
 201         break;
 202       }
 203       case JVM_CONSTANT_Fieldref: {
 204         cfs->guarantee_more(5, CHECK);  // class_index, name_and_type_index, tag/access_flags
 205         const u2 class_index = cfs->get_u2_fast();
 206         const u2 name_and_type_index = cfs->get_u2_fast();
 207         cp->field_at_put(index, class_index, name_and_type_index);
 208         break;
 209       }
 210       case JVM_CONSTANT_Methodref: {
 211         cfs->guarantee_more(5, CHECK);  // class_index, name_and_type_index, tag/access_flags
 212         const u2 class_index = cfs->get_u2_fast();
 213         const u2 name_and_type_index = cfs->get_u2_fast();
 214         cp->method_at_put(index, class_index, name_and_type_index);
 215         break;
 216       }
 217       case JVM_CONSTANT_InterfaceMethodref: {

 481         guarantee_property(valid_symbol_at(name_ref_index),
 482           "Invalid constant pool index %u in class file %s",
 483           name_ref_index, CHECK);
 484         guarantee_property(valid_symbol_at(signature_ref_index),
 485           "Invalid constant pool index %u in class file %s",
 486           signature_ref_index, CHECK);
 487         break;
 488       }
 489       case JVM_CONSTANT_Utf8:
 490         break;
 491       case JVM_CONSTANT_UnresolvedClass:         // fall-through
 492       case JVM_CONSTANT_UnresolvedClassInError: {
 493         ShouldNotReachHere();     // Only JVM_CONSTANT_ClassIndex should be present
 494         break;
 495       }
 496       case JVM_CONSTANT_ClassIndex: {
 497         const int class_index = cp->klass_index_at(index);
 498         guarantee_property(valid_symbol_at(class_index),
 499           "Invalid constant pool index %u in class file %s",
 500           class_index, CHECK);



 501         cp->unresolved_klass_at_put(index, class_index, num_klasses++);
 502         break;
 503       }
 504       case JVM_CONSTANT_StringIndex: {
 505         const int string_index = cp->string_index_at(index);
 506         guarantee_property(valid_symbol_at(string_index),
 507           "Invalid constant pool index %u in class file %s",
 508           string_index, CHECK);
 509         Symbol* const sym = cp->symbol_at(string_index);
 510         cp->unresolved_string_at_put(index, sym);
 511         break;
 512       }
 513       case JVM_CONSTANT_MethodHandle: {
 514         const int ref_index = cp->method_handle_index_at(index);
 515         guarantee_property(valid_cp_range(ref_index, length),
 516           "Invalid constant pool index %u in class file %s",
 517           ref_index, CHECK);
 518         const constantTag tag = cp->tag_at(ref_index);
 519         const int ref_kind = cp->method_handle_ref_kind_at(index);
 520 

 690             }
 691           }
 692         } else {
 693           if (_need_verify) {
 694             // Method name and signature are individually verified above, when iterating
 695             // NameAndType_info.  Need to check here that signature is non-zero length and
 696             // the right type.
 697             if (!Signature::is_method(signature)) {
 698               throwIllegalSignature("Method", name, signature, CHECK);
 699             }
 700           }
 701           // If a class method name begins with '<', it must be "<init>" and have void signature.
 702           const unsigned int name_len = name->utf8_length();
 703           if (tag == JVM_CONSTANT_Methodref && name_len != 0 &&
 704               name->char_at(0) == JVM_SIGNATURE_SPECIAL) {
 705             if (name != vmSymbols::object_initializer_name()) {
 706               classfile_parse_error(
 707                 "Bad method name at constant pool index %u in class file %s",
 708                 name_ref_index, THREAD);
 709               return;
 710             } else if (!Signature::is_void_method(signature)) { // must have void signature.
 711               throwIllegalSignature("Method", name, signature, CHECK);
 712             }
 713           }
 714         }
 715         break;
 716       }
 717       case JVM_CONSTANT_MethodHandle: {
 718         const int ref_index = cp->method_handle_index_at(index);
 719         const int ref_kind = cp->method_handle_ref_kind_at(index);
 720         switch (ref_kind) {
 721           case JVM_REF_invokeVirtual:
 722           case JVM_REF_invokeStatic:
 723           case JVM_REF_invokeSpecial:
 724           case JVM_REF_newInvokeSpecial: {
 725             const int name_and_type_ref_index =
 726               cp->uncached_name_and_type_ref_index_at(ref_index);
 727             const int name_ref_index =
 728               cp->name_ref_index_at(name_and_type_ref_index);
 729             const Symbol* const name = cp->symbol_at(name_ref_index);
 730             if (ref_kind == JVM_REF_newInvokeSpecial) {
 731               if (name != vmSymbols::object_initializer_name()) {

 732                 classfile_parse_error(
 733                   "Bad constructor name at constant pool index %u in class file %s",
 734                     name_ref_index, THREAD);
 735                 return;
 736               }
 737             } else {
 738               if (name == vmSymbols::object_initializer_name()) {








 739                 classfile_parse_error(
 740                   "Bad method name at constant pool index %u in class file %s",
 741                   name_ref_index, THREAD);
 742                 return;
 743               }
 744             }
 745             break;
 746           }
 747           // Other ref_kinds are already fully checked in previous pass.
 748         } // switch(ref_kind)
 749         break;
 750       }
 751       case JVM_CONSTANT_MethodType: {
 752         const Symbol* const no_name = vmSymbols::type_name(); // place holder
 753         const Symbol* const signature = cp->method_type_signature_at(index);
 754         verify_legal_method_signature(no_name, signature, CHECK);
 755         break;
 756       }
 757       case JVM_CONSTANT_Utf8: {
 758         assert(cp->symbol_at(index)->refcount() != 0, "count corrupted");

 770 
 771   NameSigHash(Symbol* name, Symbol* sig) :
 772     _name(name),
 773     _sig(sig) {}
 774 
 775   static unsigned int hash(NameSigHash const& namesig) {
 776     return namesig._name->identity_hash() ^ namesig._sig->identity_hash();
 777   }
 778 
 779   static bool equals(NameSigHash const& e0, NameSigHash const& e1) {
 780     return (e0._name == e1._name) &&
 781           (e0._sig  == e1._sig);
 782   }
 783 };
 784 
 785 using NameSigHashtable = HashTable<NameSigHash, int,
 786                                            NameSigHash::HASH_ROW_SIZE,
 787                                            AnyObj::RESOURCE_AREA, mtInternal,
 788                                            &NameSigHash::hash, &NameSigHash::equals>;
 789 
 790 // Side-effects: populates the _local_interfaces field
 791 void ClassFileParser::parse_interfaces(const ClassFileStream* const stream,
 792                                        const int itfs_len,
 793                                        ConstantPool* const cp,









 794                                        bool* const has_nonstatic_concrete_methods,






 795                                        TRAPS) {
 796   assert(stream != nullptr, "invariant");
 797   assert(cp != nullptr, "invariant");
 798   assert(has_nonstatic_concrete_methods != nullptr, "invariant");
 799 
 800   if (itfs_len == 0) {
 801     _local_interfaces = Universe::the_empty_instance_klass_array();

 802   } else {
 803     assert(itfs_len > 0, "only called for len>0");
 804     _local_interfaces = MetadataFactory::new_array<InstanceKlass*>(_loader_data, itfs_len, nullptr, CHECK);
 805 
 806     int index;
 807     for (index = 0; index < itfs_len; index++) {
 808       const u2 interface_index = stream->get_u2(CHECK);
 809       Klass* interf;
 810       guarantee_property(
 811         valid_klass_reference_at(interface_index),
 812         "Interface name has bad constant pool index %u in class file %s",
 813         interface_index, CHECK);
 814       if (cp->tag_at(interface_index).is_klass()) {
 815         interf = cp->resolved_klass_at(interface_index);
 816       } else {
 817         Symbol* const unresolved_klass  = cp->klass_name_at(interface_index);
 818 
 819         // Don't need to check legal name because it's checked when parsing constant pool.
 820         // But need to make sure it's not an array type.
 821         guarantee_property(unresolved_klass->char_at(0) != JVM_SIGNATURE_ARRAY,
 822                            "Bad interface name in class file %s", CHECK);
 823 
 824         // Call resolve on the interface class name with class circularity checking
 825         interf = SystemDictionary::resolve_super_or_fail(_class_name,
 826                                                          unresolved_klass,
 827                                                          Handle(THREAD, _loader_data->class_loader()),
 828                                                          false, CHECK);
 829       }
 830 
 831       if (!interf->is_interface()) {
 832         THROW_MSG(vmSymbols::java_lang_IncompatibleClassChangeError(),
 833                   err_msg("class %s can not implement %s, because it is not an interface (%s)",
 834                           _class_name->as_klass_external_name(),
 835                           interf->external_name(),
 836                           interf->class_in_module_of_loader()));
 837       }
 838 
 839       if (InstanceKlass::cast(interf)->has_nonstatic_concrete_methods()) {
 840         *has_nonstatic_concrete_methods = true;
 841       }
 842       _local_interfaces->at_put(index, InstanceKlass::cast(interf));
 843     }
 844 
 845     if (!_need_verify || itfs_len <= 1) {
 846       return;
 847     }
 848 
 849     // Check if there's any duplicates in interfaces
 850     ResourceMark rm(THREAD);
 851     // Set containing interface names
 852     HashTable<Symbol*, int>* interface_names = new HashTable<Symbol*, int>();
 853     for (index = 0; index < itfs_len; index++) {
 854       const InstanceKlass* const k = _local_interfaces->at(index);
 855       Symbol* interface_name = k->name();
 856       // If no duplicates, add (name, nullptr) in hashtable interface_names.
 857       if (!interface_names->put(interface_name, 0)) {
 858         classfile_parse_error("Duplicate interface name \"%s\" in class file %s",
 859                                interface_name->as_C_string(), THREAD);
 860         return;
 861       }
 862     }
 863   }
 864 }
 865 
 866 void ClassFileParser::verify_constantvalue(const ConstantPool* const cp,
 867                                            int constantvalue_index,
 868                                            int signature_index,
 869                                            TRAPS) const {
 870   // Make sure the constant pool entry is of a type appropriate to this field
 871   guarantee_property(
 872     (constantvalue_index > 0 &&
 873       constantvalue_index < cp->length()),
 874     "Bad initial value index %u in ConstantValue attribute in class file %s",
 875     constantvalue_index, CHECK);

 922 class AnnotationCollector : public ResourceObj{
 923 public:
 924   enum Location { _in_field, _in_method, _in_class };
 925   enum ID {
 926     _unknown = 0,
 927     _method_CallerSensitive,
 928     _method_ForceInline,
 929     _method_DontInline,
 930     _method_ChangesCurrentThread,
 931     _method_JvmtiHideEvents,
 932     _method_JvmtiMountTransition,
 933     _method_InjectedProfile,
 934     _method_LambdaForm_Compiled,
 935     _method_Hidden,
 936     _method_Scoped,
 937     _method_IntrinsicCandidate,
 938     _jdk_internal_vm_annotation_Contended,
 939     _field_Stable,
 940     _jdk_internal_vm_annotation_ReservedStackAccess,
 941     _jdk_internal_ValueBased,


 942     _java_lang_Deprecated,
 943     _java_lang_Deprecated_for_removal,
 944     _jdk_internal_vm_annotation_AOTSafeClassInitializer,
 945     _method_AOTRuntimeSetup,
 946     _annotation_LIMIT
 947   };
 948   const Location _location;
 949   int _annotations_present;
 950   u2 _contended_group;
 951 
 952   AnnotationCollector(Location location)
 953     : _location(location), _annotations_present(0), _contended_group(0)
 954   {
 955     assert((int)_annotation_LIMIT <= (int)sizeof(_annotations_present) * BitsPerByte, "");
 956   }
 957   // If this annotation name has an ID, report it (or _none).
 958   ID annotation_index(const ClassLoaderData* loader_data, const Symbol* name, bool can_access_vm_annotations);
 959   // Set the annotation name:
 960   void set_annotation(ID id) {
 961     assert((int)id >= 0 && (int)id < (int)_annotation_LIMIT, "oob");

1348   }
1349 
1350   *constantvalue_index_addr = constantvalue_index;
1351   *is_synthetic_addr = is_synthetic;
1352   *generic_signature_index_addr = generic_signature_index;
1353   AnnotationArray* a = allocate_annotations(runtime_visible_annotations,
1354                                             runtime_visible_annotations_length,
1355                                             CHECK);
1356   parsed_annotations->set_field_annotations(a);
1357   a = allocate_annotations(runtime_visible_type_annotations,
1358                            runtime_visible_type_annotations_length,
1359                            CHECK);
1360   parsed_annotations->set_field_type_annotations(a);
1361   return;
1362 }
1363 
1364 
1365 // Side-effects: populates the _fields, _fields_annotations,
1366 // _fields_type_annotations fields
1367 void ClassFileParser::parse_fields(const ClassFileStream* const cfs,
1368                                    bool is_interface,
1369                                    ConstantPool* cp,
1370                                    const int cp_size,
1371                                    u2* const java_fields_count_ptr,
1372                                    TRAPS) {
1373 
1374   assert(cfs != nullptr, "invariant");
1375   assert(cp != nullptr, "invariant");
1376   assert(java_fields_count_ptr != nullptr, "invariant");
1377 
1378   assert(nullptr == _fields_annotations, "invariant");
1379   assert(nullptr == _fields_type_annotations, "invariant");
1380 

1381   cfs->guarantee_more(2, CHECK);  // length
1382   const u2 length = cfs->get_u2_fast();
1383   *java_fields_count_ptr = length;
1384 
1385   int num_injected = 0;
1386   const InjectedField* const injected = JavaClasses::get_injected(_class_name,
1387                                                                   &num_injected);
1388   const int total_fields = length + num_injected;




1389 
1390   // Allocate a temporary resource array to collect field data.
1391   // After parsing all fields, data are stored in a UNSIGNED5 compressed stream.
1392   _temp_field_info = new GrowableArray<FieldInfo>(total_fields);
1393 

1394   ResourceMark rm(THREAD);
1395   for (int n = 0; n < length; n++) {
1396     // access_flags, name_index, descriptor_index, attributes_count
1397     cfs->guarantee_more(8, CHECK);
1398 







1399     AccessFlags access_flags;
1400     const jint flags = cfs->get_u2_fast() & JVM_RECOGNIZED_FIELD_MODIFIERS;
1401     verify_legal_field_modifiers(flags, is_interface, CHECK);
1402     access_flags.set_flags(flags);
1403     FieldInfo::FieldFlags fieldFlags(0);
1404 
1405     const u2 name_index = cfs->get_u2_fast();
1406     guarantee_property(valid_symbol_at(name_index),
1407       "Invalid constant pool index %u for field name in class file %s",
1408       name_index, CHECK);
1409     const Symbol* const name = cp->symbol_at(name_index);
1410     verify_legal_field_name(name, CHECK);
1411 
1412     const u2 signature_index = cfs->get_u2_fast();
1413     guarantee_property(valid_symbol_at(signature_index),
1414       "Invalid constant pool index %u for field signature in class file %s",
1415       signature_index, CHECK);
1416     const Symbol* const sig = cp->symbol_at(signature_index);
1417     verify_legal_field_signature(name, sig, CHECK);

1418 
1419     u2 constantvalue_index = 0;
1420     bool is_synthetic = false;
1421     u2 generic_signature_index = 0;
1422     const bool is_static = access_flags.is_static();
1423     FieldAnnotationCollector parsed_annotations(_loader_data);
1424 


1425     const u2 attributes_count = cfs->get_u2_fast();
1426     if (attributes_count > 0) {
1427       parse_field_attributes(cfs,
1428                              attributes_count,
1429                              is_static,
1430                              signature_index,
1431                              &constantvalue_index,
1432                              &is_synthetic,
1433                              &generic_signature_index,
1434                              &parsed_annotations,
1435                              CHECK);
1436 
1437       if (parsed_annotations.field_annotations() != nullptr) {
1438         if (_fields_annotations == nullptr) {
1439           _fields_annotations = MetadataFactory::new_array<AnnotationArray*>(
1440                                              _loader_data, length, nullptr,
1441                                              CHECK);
1442         }
1443         _fields_annotations->at_put(n, parsed_annotations.field_annotations());


















1444         parsed_annotations.set_field_annotations(nullptr);
1445       }
1446       if (parsed_annotations.field_type_annotations() != nullptr) {
1447         if (_fields_type_annotations == nullptr) {
1448           _fields_type_annotations =
1449             MetadataFactory::new_array<AnnotationArray*>(_loader_data,
1450                                                          length,
1451                                                          nullptr,
1452                                                          CHECK);
1453         }
1454         _fields_type_annotations->at_put(n, parsed_annotations.field_type_annotations());
1455         parsed_annotations.set_field_type_annotations(nullptr);
1456       }
1457 
1458       if (is_synthetic) {
1459         access_flags.set_is_synthetic();
1460       }
1461       if (generic_signature_index != 0) {
1462         fieldFlags.update_generic(true);
1463       }
1464     }
1465 




1466     const BasicType type = cp->basic_type_for_signature_at(signature_index);
1467 
1468     // Update number of static oop fields.
1469     if (is_static && is_reference_type(type)) {
1470       _static_oop_count++;
1471     }
1472 
1473     FieldInfo fi(access_flags, name_index, signature_index, constantvalue_index, fieldFlags);
1474     fi.set_index(n);
1475     if (fieldFlags.is_generic()) {
1476       fi.set_generic_signature_index(generic_signature_index);
1477     }
1478     parsed_annotations.apply_to(&fi);
1479     if (fi.field_flags().is_contended()) {
1480       _has_contended_fields = true;
1481     }



1482     _temp_field_info->append(fi);
1483   }
1484   assert(_temp_field_info->length() == length, "Must be");
1485 
1486   int index = length;
1487   if (num_injected != 0) {
1488     for (int n = 0; n < num_injected; n++) {
1489       // Check for duplicates
1490       if (injected[n].may_be_java) {
1491         const Symbol* const name      = injected[n].name();
1492         const Symbol* const signature = injected[n].signature();
1493         bool duplicate = false;
1494         for (int i = 0; i < length; i++) {
1495           const FieldInfo* const f = _temp_field_info->adr_at(i);
1496           if (name      == cp->symbol_at(f->name_index()) &&
1497               signature == cp->symbol_at(f->signature_index())) {
1498             // Symbol is desclared in Java so skip this one
1499             duplicate = true;
1500             break;
1501           }
1502         }
1503         if (duplicate) {
1504           // These will be removed from the field array at the end
1505           continue;
1506         }
1507       }
1508 
1509       // Injected field
1510       FieldInfo::FieldFlags fflags(0);
1511       fflags.update_injected(true);
1512       AccessFlags aflags;
1513       FieldInfo fi(aflags, (u2)(injected[n].name_index), (u2)(injected[n].signature_index), 0, fflags);
1514       fi.set_index(index);
1515       _temp_field_info->append(fi);
1516       index++;
1517     }
1518   }
1519 
1520   assert(_temp_field_info->length() == index, "Must be");
















1521 
1522   if (_need_verify && length > 1) {
1523     // Check duplicated fields
1524     ResourceMark rm(THREAD);
1525     // Set containing name-signature pairs
1526     NameSigHashtable* names_and_sigs = new NameSigHashtable();
1527     for (int i = 0; i < _temp_field_info->length(); i++) {
1528       NameSigHash name_and_sig(_temp_field_info->adr_at(i)->name(_cp),
1529                                _temp_field_info->adr_at(i)->signature(_cp));
1530       // If no duplicates, add name/signature in hashtable names_and_sigs.
1531       if(!names_and_sigs->put(name_and_sig, 0)) {
1532         classfile_parse_error("Duplicate field name \"%s\" with signature \"%s\" in class file %s",
1533                                name_and_sig._name->as_C_string(), name_and_sig._sig->as_klass_external_name(), THREAD);
1534         return;
1535       }
1536     }
1537   }
1538 }
1539 
1540 

1880     }
1881     case VM_SYMBOL_ENUM_NAME(jdk_internal_vm_annotation_Contended_signature): {
1882       if (_location != _in_field && _location != _in_class) {
1883         break;  // only allow for fields and classes
1884       }
1885       if (!EnableContended || (RestrictContended && !privileged)) {
1886         break;  // honor privileges
1887       }
1888       return _jdk_internal_vm_annotation_Contended;
1889     }
1890     case VM_SYMBOL_ENUM_NAME(jdk_internal_vm_annotation_ReservedStackAccess_signature): {
1891       if (_location != _in_method)  break;  // only allow for methods
1892       if (RestrictReservedStack && !privileged) break; // honor privileges
1893       return _jdk_internal_vm_annotation_ReservedStackAccess;
1894     }
1895     case VM_SYMBOL_ENUM_NAME(jdk_internal_ValueBased_signature): {
1896       if (_location != _in_class)   break;  // only allow for classes
1897       if (!privileged)              break;  // only allow in privileged code
1898       return _jdk_internal_ValueBased;
1899     }








1900     case VM_SYMBOL_ENUM_NAME(java_lang_Deprecated): {
1901       return _java_lang_Deprecated;
1902     }
1903     case VM_SYMBOL_ENUM_NAME(jdk_internal_vm_annotation_AOTSafeClassInitializer_signature): {
1904       if (_location != _in_class)   break;  // only allow for classes
1905       if (!privileged)              break;  // only allow in privileged code
1906       return _jdk_internal_vm_annotation_AOTSafeClassInitializer;
1907     }
1908     case VM_SYMBOL_ENUM_NAME(jdk_internal_vm_annotation_AOTRuntimeSetup_signature): {
1909       if (_location != _in_method)  break;  // only allow for methods
1910       if (!privileged)              break;  // only allow in privileged code
1911       return _method_AOTRuntimeSetup;
1912     }
1913     default: {
1914       break;
1915     }
1916   }
1917   return AnnotationCollector::_unknown;
1918 }
1919 

2116   }
2117 
2118   if (runtime_visible_type_annotations_length > 0) {
2119     a = allocate_annotations(runtime_visible_type_annotations,
2120                              runtime_visible_type_annotations_length,
2121                              CHECK);
2122     cm->set_type_annotations(a);
2123   }
2124 }
2125 
2126 
2127 // Note: the parse_method below is big and clunky because all parsing of the code and exceptions
2128 // attribute is inlined. This is cumbersome to avoid since we inline most of the parts in the
2129 // Method* to save footprint, so we only know the size of the resulting Method* when the
2130 // entire method attribute is parsed.
2131 //
2132 // The has_localvariable_table parameter is used to pass up the value to InstanceKlass.
2133 
2134 Method* ClassFileParser::parse_method(const ClassFileStream* const cfs,
2135                                       bool is_interface,


2136                                       const ConstantPool* cp,
2137                                       bool* const has_localvariable_table,
2138                                       TRAPS) {
2139   assert(cfs != nullptr, "invariant");
2140   assert(cp != nullptr, "invariant");
2141   assert(has_localvariable_table != nullptr, "invariant");
2142 
2143   ResourceMark rm(THREAD);
2144   // Parse fixed parts:
2145   // access_flags, name_index, descriptor_index, attributes_count
2146   cfs->guarantee_more(8, CHECK_NULL);
2147 
2148   u2 flags = cfs->get_u2_fast();
2149   const u2 name_index = cfs->get_u2_fast();
2150   const int cp_size = cp->length();
2151   guarantee_property(
2152     valid_symbol_at(name_index),
2153     "Illegal constant pool index %u for method name in class file %s",
2154     name_index, CHECK_NULL);
2155   const Symbol* const name = cp->symbol_at(name_index);

2157 
2158   const u2 signature_index = cfs->get_u2_fast();
2159   guarantee_property(
2160     valid_symbol_at(signature_index),
2161     "Illegal constant pool index %u for method signature in class file %s",
2162     signature_index, CHECK_NULL);
2163   const Symbol* const signature = cp->symbol_at(signature_index);
2164 
2165   if (name == vmSymbols::class_initializer_name()) {
2166     // We ignore the other access flags for a valid class initializer.
2167     // (JVM Spec 2nd ed., chapter 4.6)
2168     if (_major_version < 51) { // backward compatibility
2169       flags = JVM_ACC_STATIC;
2170     } else if ((flags & JVM_ACC_STATIC) == JVM_ACC_STATIC) {
2171       flags &= JVM_ACC_STATIC | (_major_version <= JAVA_16_VERSION ? JVM_ACC_STRICT : 0);
2172     } else {
2173       classfile_parse_error("Method <clinit> is not static in class file %s", THREAD);
2174       return nullptr;
2175     }
2176   } else {
2177     verify_legal_method_modifiers(flags, is_interface, name, CHECK_NULL);
2178   }
2179 
2180   if (name == vmSymbols::object_initializer_name() && is_interface) {
2181     classfile_parse_error("Interface cannot have a method named <init>, class file %s", THREAD);
2182     return nullptr;
2183   }
2184 









2185   int args_size = -1;  // only used when _need_verify is true
2186   if (_need_verify) {
2187     verify_legal_name_with_signature(name, signature, CHECK_NULL);
2188     args_size = ((flags & JVM_ACC_STATIC) ? 0 : 1) +
2189                  verify_legal_method_signature(name, signature, CHECK_NULL);
2190     if (args_size > MAX_ARGS_SIZE) {
2191       classfile_parse_error("Too many arguments in method signature in class file %s", THREAD);
2192       return nullptr;
2193     }
2194   }
2195 
2196   AccessFlags access_flags(flags & JVM_RECOGNIZED_METHOD_MODIFIERS);
2197 
2198   // Default values for code and exceptions attribute elements
2199   u2 max_stack = 0;
2200   u2 max_locals = 0;
2201   u4 code_length = 0;
2202   const u1* code_start = nullptr;
2203   u2 exception_table_length = 0;
2204   const unsafe_u2* exception_table_start = nullptr; // (potentially unaligned) pointer to array of u2 elements

2699                           CHECK_NULL);
2700 
2701   if (InstanceKlass::is_finalization_enabled() &&
2702       name == vmSymbols::finalize_method_name() &&
2703       signature == vmSymbols::void_method_signature()) {
2704     if (m->is_empty_method()) {
2705       _has_empty_finalizer = true;
2706     } else {
2707       _has_finalizer = true;
2708     }
2709   }
2710 
2711   NOT_PRODUCT(m->verify());
2712   return m;
2713 }
2714 
2715 
2716 // Side-effects: populates the _methods field in the parser
2717 void ClassFileParser::parse_methods(const ClassFileStream* const cfs,
2718                                     bool is_interface,


2719                                     bool* const has_localvariable_table,
2720                                     bool* has_final_method,
2721                                     bool* declares_nonstatic_concrete_methods,
2722                                     TRAPS) {
2723   assert(cfs != nullptr, "invariant");
2724   assert(has_localvariable_table != nullptr, "invariant");
2725   assert(has_final_method != nullptr, "invariant");
2726   assert(declares_nonstatic_concrete_methods != nullptr, "invariant");
2727 
2728   assert(nullptr == _methods, "invariant");
2729 
2730   cfs->guarantee_more(2, CHECK);  // length
2731   const u2 length = cfs->get_u2_fast();
2732   if (length == 0) {
2733     _methods = Universe::the_empty_method_array();
2734   } else {
2735     _methods = MetadataFactory::new_array<Method*>(_loader_data,
2736                                                    length,
2737                                                    nullptr,
2738                                                    CHECK);
2739 
2740     for (int index = 0; index < length; index++) {
2741       Method* method = parse_method(cfs,
2742                                     is_interface,


2743                                     _cp,
2744                                     has_localvariable_table,
2745                                     CHECK);
2746 
2747       if (method->is_final()) {
2748         *has_final_method = true;
2749       }
2750       // declares_nonstatic_concrete_methods: declares concrete instance methods, any access flags
2751       // used for interface initialization, and default method inheritance analysis
2752       if (is_interface && !(*declares_nonstatic_concrete_methods)
2753         && !method->is_abstract() && !method->is_static()) {
2754         *declares_nonstatic_concrete_methods = true;
2755       }
2756       _methods->at_put(index, method);
2757     }
2758 
2759     if (_need_verify && length > 1) {
2760       // Check duplicated methods
2761       ResourceMark rm(THREAD);
2762       // Set containing name-signature pairs

2988         valid_klass_reference_at(outer_class_info_index),
2989       "outer_class_info_index %u has bad constant type in class file %s",
2990       outer_class_info_index, CHECK_0);
2991 
2992     if (outer_class_info_index != 0) {
2993       const Symbol* const outer_class_name = cp->klass_name_at(outer_class_info_index);
2994       char* bytes = (char*)outer_class_name->bytes();
2995       guarantee_property(bytes[0] != JVM_SIGNATURE_ARRAY,
2996                          "Outer class is an array class in class file %s", CHECK_0);
2997     }
2998     // Inner class name
2999     const u2 inner_name_index = cfs->get_u2_fast();
3000     guarantee_property(
3001       inner_name_index == 0 || valid_symbol_at(inner_name_index),
3002       "inner_name_index %u has bad constant type in class file %s",
3003       inner_name_index, CHECK_0);
3004     if (_need_verify) {
3005       guarantee_property(inner_class_info_index != outer_class_info_index,
3006                          "Class is both outer and inner class in class file %s", CHECK_0);
3007     }

3008     // Access flags
3009     u2 flags;
3010     // JVM_ACC_MODULE is defined in JDK-9 and later.
3011     if (_major_version >= JAVA_9_VERSION) {
3012       flags = cfs->get_u2_fast() & (RECOGNIZED_INNER_CLASS_MODIFIERS | JVM_ACC_MODULE);
3013     } else {
3014       flags = cfs->get_u2_fast() & RECOGNIZED_INNER_CLASS_MODIFIERS;
3015     }

3016     if ((flags & JVM_ACC_INTERFACE) && _major_version < JAVA_6_VERSION) {
3017       // Set abstract bit for old class files for backward compatibility
3018       flags |= JVM_ACC_ABSTRACT;
3019     }
3020 








3021     Symbol* inner_name_symbol = inner_name_index == 0 ? nullptr : cp->symbol_at(inner_name_index);
3022     verify_legal_class_modifiers(flags, inner_name_symbol, inner_name_index == 0, CHECK_0);
3023     AccessFlags inner_access_flags(flags);
3024 
3025     inner_classes->at_put(index++, inner_class_info_index);
3026     inner_classes->at_put(index++, outer_class_info_index);
3027     inner_classes->at_put(index++, inner_name_index);
3028     inner_classes->at_put(index++, inner_access_flags.as_unsigned_short());
3029   }
3030 
3031   // Check for circular and duplicate entries.
3032   bool has_circularity = false;
3033   if (_need_verify) {
3034     has_circularity = check_inner_classes_circularity(cp, length * 4, CHECK_0);
3035     if (has_circularity) {
3036       // If circularity check failed then ignore InnerClasses attribute.
3037       MetadataFactory::free_array<u2>(_loader_data, _inner_classes);
3038       index = 0;
3039       if (parsed_enclosingmethod_attribute) {
3040         inner_classes = MetadataFactory::new_array<u2>(_loader_data, 2, CHECK_0);

3106   if (length > 0) {
3107     int index = 0;
3108     cfs->guarantee_more(2 * length, CHECK_0);
3109     for (int n = 0; n < length; n++) {
3110       const u2 class_info_index = cfs->get_u2_fast();
3111       guarantee_property(
3112         valid_klass_reference_at(class_info_index),
3113         "Permitted subclass class_info_index %u has bad constant type in class file %s",
3114         class_info_index, CHECK_0);
3115       permitted_subclasses->at_put(index++, class_info_index);
3116     }
3117     assert(index == size, "wrong size");
3118   }
3119 
3120   // Restore buffer's current position.
3121   cfs->set_current(current_mark);
3122 
3123   return length;
3124 }
3125 











































3126 //  Record {
3127 //    u2 attribute_name_index;
3128 //    u4 attribute_length;
3129 //    u2 components_count;
3130 //    component_info components[components_count];
3131 //  }
3132 //  component_info {
3133 //    u2 name_index;
3134 //    u2 descriptor_index
3135 //    u2 attributes_count;
3136 //    attribute_info_attributes[attributes_count];
3137 //  }
3138 u4 ClassFileParser::parse_classfile_record_attribute(const ClassFileStream* const cfs,
3139                                                      const ConstantPool* cp,
3140                                                      const u1* const record_attribute_start,
3141                                                      TRAPS) {
3142   const u1* const current_mark = cfs->current();
3143   int components_count = 0;
3144   unsigned int calculate_attr_size = 0;
3145   if (record_attribute_start != nullptr) {

3371   }
3372   guarantee_property(current_start + attribute_byte_length == cfs->current(),
3373                      "Bad length on BootstrapMethods in class file %s",
3374                      CHECK);
3375 }
3376 
3377 void ClassFileParser::parse_classfile_attributes(const ClassFileStream* const cfs,
3378                                                  ConstantPool* cp,
3379                  ClassFileParser::ClassAnnotationCollector* parsed_annotations,
3380                                                  TRAPS) {
3381   assert(cfs != nullptr, "invariant");
3382   assert(cp != nullptr, "invariant");
3383   assert(parsed_annotations != nullptr, "invariant");
3384 
3385   // Set inner classes attribute to default sentinel
3386   _inner_classes = Universe::the_empty_short_array();
3387   // Set nest members attribute to default sentinel
3388   _nest_members = Universe::the_empty_short_array();
3389   // Set _permitted_subclasses attribute to default sentinel
3390   _permitted_subclasses = Universe::the_empty_short_array();


3391   cfs->guarantee_more(2, CHECK);  // attributes_count
3392   u2 attributes_count = cfs->get_u2_fast();
3393   bool parsed_sourcefile_attribute = false;
3394   bool parsed_innerclasses_attribute = false;
3395   bool parsed_nest_members_attribute = false;
3396   bool parsed_permitted_subclasses_attribute = false;

3397   bool parsed_nest_host_attribute = false;
3398   bool parsed_record_attribute = false;
3399   bool parsed_enclosingmethod_attribute = false;
3400   bool parsed_bootstrap_methods_attribute = false;
3401   const u1* runtime_visible_annotations = nullptr;
3402   int runtime_visible_annotations_length = 0;
3403   const u1* runtime_visible_type_annotations = nullptr;
3404   int runtime_visible_type_annotations_length = 0;
3405   bool runtime_invisible_type_annotations_exists = false;
3406   bool runtime_invisible_annotations_exists = false;
3407   bool parsed_source_debug_ext_annotations_exist = false;
3408   const u1* inner_classes_attribute_start = nullptr;
3409   u4  inner_classes_attribute_length = 0;
3410   u2  enclosing_method_class_index = 0;
3411   u2  enclosing_method_method_index = 0;
3412   const u1* nest_members_attribute_start = nullptr;
3413   u4  nest_members_attribute_length = 0;
3414   const u1* record_attribute_start = nullptr;
3415   u4  record_attribute_length = 0;
3416   const u1* permitted_subclasses_attribute_start = nullptr;
3417   u4  permitted_subclasses_attribute_length = 0;


3418 
3419   // Iterate over attributes
3420   while (attributes_count--) {
3421     cfs->guarantee_more(6, CHECK);  // attribute_name_index, attribute_length
3422     const u2 attribute_name_index = cfs->get_u2_fast();
3423     const u4 attribute_length = cfs->get_u4_fast();
3424     guarantee_property(
3425       valid_symbol_at(attribute_name_index),
3426       "Attribute name has bad constant pool index %u in class file %s",
3427       attribute_name_index, CHECK);
3428     const Symbol* const tag = cp->symbol_at(attribute_name_index);
3429     if (tag == vmSymbols::tag_source_file()) {
3430       // Check for SourceFile tag
3431       if (_need_verify) {
3432         guarantee_property(attribute_length == 2, "Wrong SourceFile attribute length in class file %s", CHECK);
3433       }
3434       if (parsed_sourcefile_attribute) {
3435         classfile_parse_error("Multiple SourceFile attributes in class file %s", THREAD);
3436         return;
3437       } else {

3613               return;
3614             }
3615             parsed_record_attribute = true;
3616             record_attribute_start = cfs->current();
3617             record_attribute_length = attribute_length;
3618           } else if (_major_version >= JAVA_17_VERSION) {
3619             if (tag == vmSymbols::tag_permitted_subclasses()) {
3620               if (parsed_permitted_subclasses_attribute) {
3621                 classfile_parse_error("Multiple PermittedSubclasses attributes in class file %s", CHECK);
3622                 return;
3623               }
3624               // Classes marked ACC_FINAL cannot have a PermittedSubclasses attribute.
3625               if (_access_flags.is_final()) {
3626                 classfile_parse_error("PermittedSubclasses attribute in final class file %s", CHECK);
3627                 return;
3628               }
3629               parsed_permitted_subclasses_attribute = true;
3630               permitted_subclasses_attribute_start = cfs->current();
3631               permitted_subclasses_attribute_length = attribute_length;
3632             }









3633           }
3634           // Skip attribute_length for any attribute where major_verson >= JAVA_17_VERSION
3635           cfs->skip_u1(attribute_length, CHECK);
3636         } else {
3637           // Unknown attribute
3638           cfs->skip_u1(attribute_length, CHECK);
3639         }
3640       } else {
3641         // Unknown attribute
3642         cfs->skip_u1(attribute_length, CHECK);
3643       }
3644     } else {
3645       // Unknown attribute
3646       cfs->skip_u1(attribute_length, CHECK);
3647     }
3648   }
3649   _class_annotations = allocate_annotations(runtime_visible_annotations,
3650                                             runtime_visible_annotations_length,
3651                                             CHECK);
3652   _class_type_annotations = allocate_annotations(runtime_visible_type_annotations,

3689                             CHECK);
3690     if (_need_verify) {
3691       guarantee_property(record_attribute_length == calculated_attr_length,
3692                          "Record attribute has wrong length in class file %s",
3693                          CHECK);
3694     }
3695   }
3696 
3697   if (parsed_permitted_subclasses_attribute) {
3698     const u2 num_subclasses = parse_classfile_permitted_subclasses_attribute(
3699                             cfs,
3700                             permitted_subclasses_attribute_start,
3701                             CHECK);
3702     if (_need_verify) {
3703       guarantee_property(
3704         permitted_subclasses_attribute_length == sizeof(num_subclasses) + sizeof(u2) * num_subclasses,
3705         "Wrong PermittedSubclasses attribute length in class file %s", CHECK);
3706     }
3707   }
3708 












3709   if (_max_bootstrap_specifier_index >= 0) {
3710     guarantee_property(parsed_bootstrap_methods_attribute,
3711                        "Missing BootstrapMethods attribute in class file %s", CHECK);
3712   }
3713 }
3714 
3715 void ClassFileParser::apply_parsed_class_attributes(InstanceKlass* k) {
3716   assert(k != nullptr, "invariant");
3717 
3718   if (_synthetic_flag)
3719     k->set_is_synthetic();
3720   if (_sourcefile_index != 0) {
3721     k->set_source_file_name_index(_sourcefile_index);
3722   }
3723   if (_generic_signature_index != 0) {
3724     k->set_generic_signature_index(_generic_signature_index);
3725   }
3726   if (_sde_buffer != nullptr) {
3727     k->set_source_debug_extension(_sde_buffer, _sde_length);
3728   }

3755     _class_type_annotations  = nullptr;
3756     _fields_annotations      = nullptr;
3757     _fields_type_annotations = nullptr;
3758 }
3759 
3760 // Transfer ownership of metadata allocated to the InstanceKlass.
3761 void ClassFileParser::apply_parsed_class_metadata(
3762                                             InstanceKlass* this_klass,
3763                                             int java_fields_count) {
3764   assert(this_klass != nullptr, "invariant");
3765 
3766   _cp->set_pool_holder(this_klass);
3767   this_klass->set_constants(_cp);
3768   this_klass->set_fieldinfo_stream(_fieldinfo_stream);
3769   this_klass->set_fieldinfo_search_table(_fieldinfo_search_table);
3770   this_klass->set_fields_status(_fields_status);
3771   this_klass->set_methods(_methods);
3772   this_klass->set_inner_classes(_inner_classes);
3773   this_klass->set_nest_members(_nest_members);
3774   this_klass->set_nest_host_index(_nest_host);

3775   this_klass->set_annotations(_combined_annotations);
3776   this_klass->set_permitted_subclasses(_permitted_subclasses);
3777   this_klass->set_record_components(_record_components);

3778 
3779   DEBUG_ONLY(FieldInfoStream::validate_search_table(_cp, _fieldinfo_stream, _fieldinfo_search_table));
3780 
3781   // Delay the setting of _local_interfaces and _transitive_interfaces until after
3782   // initialize_supers() in fill_instance_klass(). It is because the _local_interfaces could
3783   // be shared with _transitive_interfaces and _transitive_interfaces may be shared with
3784   // its _super. If an OOM occurs while loading the current klass, its _super field
3785   // may not have been set. When GC tries to free the klass, the _transitive_interfaces
3786   // may be deallocated mistakenly in InstanceKlass::deallocate_interfaces(). Subsequent
3787   // dereferences to the deallocated _transitive_interfaces will result in a crash.
3788 
3789   // Clear out these fields so they don't get deallocated by the destructor
3790   clear_class_metadata();
3791 }
3792 
3793 AnnotationArray* ClassFileParser::allocate_annotations(const u1* const anno,
3794                                                        int anno_length,
3795                                                        TRAPS) {
3796   AnnotationArray* annotations = nullptr;
3797   if (anno != nullptr) {
3798     annotations = MetadataFactory::new_array<u1>(_loader_data,
3799                                                  anno_length,
3800                                                  CHECK_(annotations));
3801     for (int i = 0; i < anno_length; i++) {
3802       annotations->at_put(i, anno[i]);
3803     }
3804   }
3805   return annotations;
3806 }
3807 
3808 void ClassFileParser::check_super_class(ConstantPool* const cp,
3809                                         const int super_class_index,
3810                                         const bool need_verify,
3811                                         TRAPS) {
3812   assert(cp != nullptr, "invariant");
3813 
3814   if (super_class_index == 0) {
3815     guarantee_property(_class_name == vmSymbols::java_lang_Object(),
3816                        "Invalid superclass index %u in class file %s",
3817                        super_class_index,
3818                        CHECK);
3819   } else {
3820     guarantee_property(valid_klass_reference_at(super_class_index),
3821                        "Invalid superclass index %u in class file %s",
3822                        super_class_index,
3823                        CHECK);
3824 
3825     // The class name should be legal because it is checked when parsing constant pool.
3826     // However, make sure it is not an array type.
3827     if (need_verify) {
3828       guarantee_property(cp->klass_name_at(super_class_index)->char_at(0) != JVM_SIGNATURE_ARRAY,
3829                         "Bad superclass name in class file %s", CHECK);
3830     }
3831   }
3832 }
3833 
3834 OopMapBlocksBuilder::OopMapBlocksBuilder(unsigned int max_blocks) {
3835   _max_nonstatic_oop_maps = max_blocks;
3836   _nonstatic_oop_map_count = 0;
3837   if (max_blocks == 0) {

3989   // See documentation of InstanceKlass::can_be_fastpath_allocated().
3990   assert(ik->size_helper() > 0, "layout_helper is initialized");
3991   if (ik->is_abstract() || ik->is_interface()
3992       || (ik->name() == vmSymbols::java_lang_Class() && ik->class_loader() == nullptr)
3993       || ik->size_helper() >= FastAllocateSizeLimit) {
3994     // Forbid fast-path allocation.
3995     const jint lh = Klass::instance_layout_helper(ik->size_helper(), true);
3996     ik->set_layout_helper(lh);
3997   }
3998 
3999   // Propagate the AOT runtimeSetup method discovery
4000   if (_has_aot_runtime_setup_method) {
4001     ik->set_is_runtime_setup_required();
4002     if (log_is_enabled(Info, aot, init)) {
4003       ResourceMark rm;
4004       log_info(aot, init)("Found @AOTRuntimeSetup class %s", ik->external_name());
4005     }
4006   }
4007 }
4008 






4009 // utility methods for appending an array with check for duplicates
4010 
4011 static void append_interfaces(GrowableArray<InstanceKlass*>* result,
4012                               const Array<InstanceKlass*>* const ifs) {
4013   // iterate over new interfaces
4014   for (int i = 0; i < ifs->length(); i++) {
4015     InstanceKlass* const e = ifs->at(i);
4016     assert(e->is_klass() && e->is_interface(), "just checking");
4017     // add new interface
4018     result->append_if_missing(e);
4019   }
4020 }
4021 
4022 static Array<InstanceKlass*>* compute_transitive_interfaces(const InstanceKlass* super,
4023                                                             Array<InstanceKlass*>* local_ifs,
4024                                                             ClassLoaderData* loader_data,
4025                                                             TRAPS) {
4026   assert(local_ifs != nullptr, "invariant");
4027   assert(loader_data != nullptr, "invariant");
4028 

4032   // Add superclass transitive interfaces size
4033   if (super != nullptr) {
4034     super_size = super->transitive_interfaces()->length();
4035     max_transitive_size += super_size;
4036   }
4037   // Add local interfaces' super interfaces
4038   const int local_size = local_ifs->length();
4039   for (int i = 0; i < local_size; i++) {
4040     InstanceKlass* const l = local_ifs->at(i);
4041     max_transitive_size += l->transitive_interfaces()->length();
4042   }
4043   // Finally add local interfaces
4044   max_transitive_size += local_size;
4045   // Construct array
4046   if (max_transitive_size == 0) {
4047     // no interfaces, use canonicalized array
4048     return Universe::the_empty_instance_klass_array();
4049   } else if (max_transitive_size == super_size) {
4050     // no new local interfaces added, share superklass' transitive interface array
4051     return super->transitive_interfaces();
4052   } else if (max_transitive_size == local_size) {
4053     // only local interfaces added, share local interface array
4054     return local_ifs;

4055   } else {
4056     ResourceMark rm;
4057     GrowableArray<InstanceKlass*>* const result = new GrowableArray<InstanceKlass*>(max_transitive_size);
4058 
4059     // Copy down from superclass
4060     if (super != nullptr) {
4061       append_interfaces(result, super->transitive_interfaces());
4062     }
4063 
4064     // Copy down from local interfaces' superinterfaces
4065     for (int i = 0; i < local_size; i++) {
4066       InstanceKlass* const l = local_ifs->at(i);
4067       append_interfaces(result, l->transitive_interfaces());
4068     }
4069     // Finally add local interfaces
4070     append_interfaces(result, local_ifs);
4071 
4072     // length will be less than the max_transitive_size if duplicates were removed
4073     const int length = result->length();
4074     assert(length <= max_transitive_size, "just checking");

4075     Array<InstanceKlass*>* const new_result =
4076       MetadataFactory::new_array<InstanceKlass*>(loader_data, length, CHECK_NULL);
4077     for (int i = 0; i < length; i++) {
4078       InstanceKlass* const e = result->at(i);
4079       assert(e != nullptr, "just checking");
4080       new_result->at_put(i, e);
4081     }
4082     return new_result;
4083   }
4084 }
4085 
4086 void ClassFileParser::check_super_class_access(const InstanceKlass* this_klass, TRAPS) {
4087   assert(this_klass != nullptr, "invariant");
4088   const InstanceKlass* const super = this_klass->super();
4089 
4090   if (super != nullptr) {
4091     if (super->is_final()) {
4092       classfile_icce_error("class %s cannot inherit from final class %s", super, THREAD);
4093       return;
4094     }
4095 
4096     if (super->is_sealed()) {
4097       stringStream ss;
4098       ResourceMark rm(THREAD);
4099       if (!super->has_as_permitted_subclass(this_klass, ss)) {
4100         classfile_icce_error(ss.as_string(), THREAD);
4101         return;
4102       }
4103     }
4104 










4105     Reflection::VerifyClassAccessResults vca_result =
4106       Reflection::verify_class_access(this_klass, super, false);
4107     if (vca_result != Reflection::ACCESS_OK) {
4108       ResourceMark rm(THREAD);
4109       char* msg = Reflection::verify_class_access_msg(this_klass,
4110                                                       super,
4111                                                       vca_result);
4112 
4113       // Names are all known to be < 64k so we know this formatted message is not excessively large.
4114       if (msg == nullptr) {
4115         bool same_module = (this_klass->module() == super->module());
4116         Exceptions::fthrow(
4117           THREAD_AND_LOCATION,
4118           vmSymbols::java_lang_IllegalAccessError(),
4119           "class %s cannot access its %ssuperclass %s (%s%s%s)",
4120           this_klass->external_name(),
4121           super->is_abstract() ? "abstract " : "",
4122           super->external_name(),
4123           (same_module) ? this_klass->joint_in_module_of_loader(super) : this_klass->class_in_module_of_loader(),
4124           (same_module) ? "" : "; ",

4277 // Verify the class modifiers for the current class, or an inner class if inner_name is non-null.
4278 void ClassFileParser::verify_legal_class_modifiers(jint flags, Symbol* inner_name, bool is_anonymous_inner_class, TRAPS) const {
4279   const bool is_module = (flags & JVM_ACC_MODULE) != 0;
4280   assert(_major_version >= JAVA_9_VERSION || !is_module, "JVM_ACC_MODULE should not be set");
4281   if (is_module) {
4282     ResourceMark rm(THREAD);
4283     // Names are all known to be < 64k so we know this formatted message is not excessively large.
4284     Exceptions::fthrow(
4285       THREAD_AND_LOCATION,
4286       vmSymbols::java_lang_NoClassDefFoundError(),
4287       "%s is not a class because access_flag ACC_MODULE is set",
4288       _class_name->as_C_string());
4289     return;
4290   }
4291 
4292   if (!_need_verify) { return; }
4293 
4294   const bool is_interface  = (flags & JVM_ACC_INTERFACE)  != 0;
4295   const bool is_abstract   = (flags & JVM_ACC_ABSTRACT)   != 0;
4296   const bool is_final      = (flags & JVM_ACC_FINAL)      != 0;
4297   const bool is_super      = (flags & JVM_ACC_SUPER)      != 0;
4298   const bool is_enum       = (flags & JVM_ACC_ENUM)       != 0;
4299   const bool is_annotation = (flags & JVM_ACC_ANNOTATION) != 0;
4300   const bool major_gte_1_5 = _major_version >= JAVA_1_5_VERSION;


4301 
4302   if ((is_abstract && is_final) ||
4303       (is_interface && !is_abstract) ||
4304       (is_interface && major_gte_1_5 && (is_super || is_enum)) ||
4305       (!is_interface && major_gte_1_5 && is_annotation)) {

4306     ResourceMark rm(THREAD);




4307     // Names are all known to be < 64k so we know this formatted message is not excessively large.
4308     if (inner_name == nullptr && !is_anonymous_inner_class) {
4309       Exceptions::fthrow(
4310         THREAD_AND_LOCATION,
4311         vmSymbols::java_lang_ClassFormatError(),
4312         "Illegal class modifiers in class %s: 0x%X",
4313         _class_name->as_C_string(), flags
4314       );
4315     } else {
4316       if (is_anonymous_inner_class) {
4317         Exceptions::fthrow(
4318           THREAD_AND_LOCATION,
4319           vmSymbols::java_lang_ClassFormatError(),
4320           "Illegal class modifiers in anonymous inner class of class %s: 0x%X",
4321           _class_name->as_C_string(), flags
4322         );
4323       } else {
4324         Exceptions::fthrow(
4325           THREAD_AND_LOCATION,
4326           vmSymbols::java_lang_ClassFormatError(),

4380         THREAD_AND_LOCATION,
4381         vmSymbols::java_lang_UnsupportedClassVersionError(),
4382         "%s (class file version %u.%u) was compiled with preview features that are unsupported. "
4383         "This version of the Java Runtime only recognizes preview features for class file version %u.%u",
4384         class_name->as_C_string(), major, minor, JVM_CLASSFILE_MAJOR_VERSION, JAVA_PREVIEW_MINOR_VERSION);
4385       return;
4386     }
4387 
4388     if (!Arguments::enable_preview()) {
4389       classfile_ucve_error("Preview features are not enabled for %s (class file version %u.%u). Try running with '--enable-preview'",
4390                            class_name, major, minor, THREAD);
4391       return;
4392     }
4393 
4394   } else { // minor != JAVA_PREVIEW_MINOR_VERSION
4395     classfile_ucve_error("%s (class file version %u.%u) was compiled with an invalid non-zero minor version",
4396                          class_name, major, minor, THREAD);
4397   }
4398 }
4399 
4400 void ClassFileParser::verify_legal_field_modifiers(jint flags,
4401                                                    bool is_interface,
4402                                                    TRAPS) const {
4403   if (!_need_verify) { return; }
4404 
4405   const bool is_public    = (flags & JVM_ACC_PUBLIC)    != 0;
4406   const bool is_protected = (flags & JVM_ACC_PROTECTED) != 0;
4407   const bool is_private   = (flags & JVM_ACC_PRIVATE)   != 0;
4408   const bool is_static    = (flags & JVM_ACC_STATIC)    != 0;
4409   const bool is_final     = (flags & JVM_ACC_FINAL)     != 0;
4410   const bool is_volatile  = (flags & JVM_ACC_VOLATILE)  != 0;
4411   const bool is_transient = (flags & JVM_ACC_TRANSIENT) != 0;
4412   const bool is_enum      = (flags & JVM_ACC_ENUM)      != 0;

4413   const bool major_gte_1_5 = _major_version >= JAVA_1_5_VERSION;
4414 
4415   bool is_illegal = false;

4416 
4417   if (is_interface) {
4418     if (!is_public || !is_static || !is_final || is_private ||
4419         is_protected || is_volatile || is_transient ||
4420         (major_gte_1_5 && is_enum)) {
4421       is_illegal = true;
4422     }
4423   } else { // not interface
4424     if (has_illegal_visibility(flags) || (is_final && is_volatile)) {
4425       is_illegal = true;





















4426     }
4427   }
4428 
4429   if (is_illegal) {
4430     ResourceMark rm(THREAD);
4431     // Names are all known to be < 64k so we know this formatted message is not excessively large.
4432     Exceptions::fthrow(
4433       THREAD_AND_LOCATION,
4434       vmSymbols::java_lang_ClassFormatError(),
4435       "Illegal field modifiers in class %s: 0x%X",
4436       _class_name->as_C_string(), flags);
4437     return;
4438   }
4439 }
4440 
4441 void ClassFileParser::verify_legal_method_modifiers(jint flags,
4442                                                     bool is_interface,
4443                                                     const Symbol* name,
4444                                                     TRAPS) const {
4445   if (!_need_verify) { return; }
4446 
4447   const bool is_public       = (flags & JVM_ACC_PUBLIC)       != 0;
4448   const bool is_private      = (flags & JVM_ACC_PRIVATE)      != 0;
4449   const bool is_static       = (flags & JVM_ACC_STATIC)       != 0;
4450   const bool is_final        = (flags & JVM_ACC_FINAL)        != 0;
4451   const bool is_native       = (flags & JVM_ACC_NATIVE)       != 0;
4452   const bool is_abstract     = (flags & JVM_ACC_ABSTRACT)     != 0;
4453   const bool is_bridge       = (flags & JVM_ACC_BRIDGE)       != 0;
4454   const bool is_strict       = (flags & JVM_ACC_STRICT)       != 0;
4455   const bool is_synchronized = (flags & JVM_ACC_SYNCHRONIZED) != 0;
4456   const bool is_protected    = (flags & JVM_ACC_PROTECTED)    != 0;
4457   const bool major_gte_1_5   = _major_version >= JAVA_1_5_VERSION;
4458   const bool major_gte_8     = _major_version >= JAVA_8_VERSION;
4459   const bool major_gte_17    = _major_version >= JAVA_17_VERSION;
4460   const bool is_initializer  = (name == vmSymbols::object_initializer_name());




4461 
4462   bool is_illegal = false;
4463 

4464   if (is_interface) {
4465     if (major_gte_8) {
4466       // Class file version is JAVA_8_VERSION or later Methods of
4467       // interfaces may set any of the flags except ACC_PROTECTED,
4468       // ACC_FINAL, ACC_NATIVE, and ACC_SYNCHRONIZED; they must
4469       // have exactly one of the ACC_PUBLIC or ACC_PRIVATE flags set.
4470       if ((is_public == is_private) || /* Only one of private and public should be true - XNOR */
4471           (is_native || is_protected || is_final || is_synchronized) ||
4472           // If a specific method of a class or interface has its
4473           // ACC_ABSTRACT flag set, it must not have any of its
4474           // ACC_FINAL, ACC_NATIVE, ACC_PRIVATE, ACC_STATIC,
4475           // ACC_STRICT, or ACC_SYNCHRONIZED flags set.  No need to
4476           // check for ACC_FINAL, ACC_NATIVE or ACC_SYNCHRONIZED as
4477           // those flags are illegal irrespective of ACC_ABSTRACT being set or not.
4478           (is_abstract && (is_private || is_static || (!major_gte_17 && is_strict)))) {
4479         is_illegal = true;
4480       }
4481     } else if (major_gte_1_5) {
4482       // Class file version in the interval [JAVA_1_5_VERSION, JAVA_8_VERSION)
4483       if (!is_public || is_private || is_protected || is_static || is_final ||
4484           is_synchronized || is_native || !is_abstract || is_strict) {
4485         is_illegal = true;
4486       }
4487     } else {
4488       // Class file version is pre-JAVA_1_5_VERSION
4489       if (!is_public || is_static || is_final || is_native || !is_abstract) {
4490         is_illegal = true;
4491       }
4492     }
4493   } else { // not interface
4494     if (has_illegal_visibility(flags)) {
4495       is_illegal = true;
4496     } else {
4497       if (is_initializer) {
4498         if (is_static || is_final || is_synchronized || is_native ||
4499             is_abstract || (major_gte_1_5 && is_bridge)) {
4500           is_illegal = true;
4501         }
4502       } else { // not initializer
4503         if (is_abstract) {
4504           if ((is_final || is_native || is_private || is_static ||
4505               (major_gte_1_5 && (is_synchronized || (!major_gte_17 && is_strict))))) {
4506             is_illegal = true;





4507           }
4508         }
4509       }
4510     }
4511   }
4512 
4513   if (is_illegal) {
4514     ResourceMark rm(THREAD);
4515     // Names are all known to be < 64k so we know this formatted message is not excessively large.
4516     Exceptions::fthrow(
4517       THREAD_AND_LOCATION,
4518       vmSymbols::java_lang_ClassFormatError(),
4519       "Method %s in class %s has illegal modifiers: 0x%X",
4520       name->as_C_string(), _class_name->as_C_string(), flags);

4521     return;
4522   }
4523 }
4524 
4525 void ClassFileParser::verify_legal_utf8(const unsigned char* buffer,
4526                                         int length,
4527                                         TRAPS) const {
4528   assert(_need_verify, "only called when _need_verify is true");
4529   // Note: 0 <= length < 64K, as it comes from a u2 entry in the CP.
4530   if (!UTF8::is_legal_utf8(buffer, static_cast<size_t>(length), _major_version <= 47)) {
4531     classfile_parse_error("Illegal UTF8 string in constant pool in class file %s", THREAD);
4532   }
4533 }
4534 
4535 // Unqualified names may not contain the characters '.', ';', '[', or '/'.
4536 // In class names, '/' separates unqualified names.  This is verified in this function also.
4537 // Method names also may not contain the characters '<' or '>', unless <init>
4538 // or <clinit>.  Note that method names may not be <init> or <clinit> in this
4539 // method.  Because these names have been checked as special cases before
4540 // calling this method in verify_legal_method_name.

4558         if (type == ClassFileParser::LegalClass) {
4559           if (p == name || p+1 >= name+length ||
4560               *(p+1) == JVM_SIGNATURE_SLASH) {
4561             return false;
4562           }
4563         } else {
4564           return false;   // do not permit '/' unless it's class name
4565         }
4566         break;
4567       case JVM_SIGNATURE_SPECIAL:
4568       case JVM_SIGNATURE_ENDSPECIAL:
4569         // do not permit '<' or '>' in method names
4570         if (type == ClassFileParser::LegalMethod) {
4571           return false;
4572         }
4573     }
4574   }
4575   return true;
4576 }
4577 









4578 // Take pointer to a UTF8 byte string (not NUL-terminated).
4579 // Skip over the longest part of the string that could
4580 // be taken as a fieldname. Allow non-trailing '/'s if slash_ok is true.
4581 // Return a pointer to just past the fieldname.
4582 // Return null if no fieldname at all was found, or in the case of slash_ok
4583 // being true, we saw consecutive slashes (meaning we were looking for a
4584 // qualified path but found something that was badly-formed).
4585 static const char* skip_over_field_name(const char* const name,
4586                                         bool slash_ok,
4587                                         unsigned int length) {
4588   const char* p;
4589   jboolean last_is_slash = false;
4590   jboolean not_first_ch = false;
4591 
4592   for (p = name; p != name + length; not_first_ch = true) {
4593     const char* old_p = p;
4594     jchar ch = *p;
4595     if (ch < 128) {
4596       p++;
4597       // quick check for ascii

4659 // be taken as a field signature. Allow "void" if void_ok.
4660 // Return a pointer to just past the signature.
4661 // Return null if no legal signature is found.
4662 const char* ClassFileParser::skip_over_field_signature(const char* signature,
4663                                                        bool void_ok,
4664                                                        unsigned int length,
4665                                                        TRAPS) const {
4666   unsigned int array_dim = 0;
4667   while (length > 0) {
4668     switch (signature[0]) {
4669     case JVM_SIGNATURE_VOID: if (!void_ok) { return nullptr; }
4670     case JVM_SIGNATURE_BOOLEAN:
4671     case JVM_SIGNATURE_BYTE:
4672     case JVM_SIGNATURE_CHAR:
4673     case JVM_SIGNATURE_SHORT:
4674     case JVM_SIGNATURE_INT:
4675     case JVM_SIGNATURE_FLOAT:
4676     case JVM_SIGNATURE_LONG:
4677     case JVM_SIGNATURE_DOUBLE:
4678       return signature + 1;
4679     case JVM_SIGNATURE_CLASS: {

4680       if (_major_version < JAVA_1_5_VERSION) {
4681         signature++;
4682         length--;
4683         // Skip over the class name if one is there
4684         const char* const p = skip_over_field_name(signature, true, length);
4685         assert(p == nullptr || p > signature, "must parse one character at least");
4686         // The next character better be a semicolon
4687         if (p != nullptr                             && // Parse of field name succeeded.
4688             p - signature < static_cast<int>(length) && // There is at least one character left to parse.
4689             p[0] == JVM_SIGNATURE_ENDCLASS) {
4690           return p + 1;
4691         }
4692       }
4693       else {
4694         // Skip leading 'L' and ignore first appearance of ';'
4695         signature++;
4696         const char* c = (const char*) memchr(signature, JVM_SIGNATURE_ENDCLASS, length - 1);
4697         // Format check signature
4698         if (c != nullptr) {
4699           int newlen = pointer_delta_as_int(c, (char*) signature);
4700           bool legal = verify_unqualified_name(signature, newlen, LegalClass);
4701           if (!legal) {
4702             classfile_parse_error("Class name is empty or contains illegal character "
4703                                   "in descriptor in class file %s",
4704                                   THREAD);
4705             return nullptr;
4706           }
4707           return signature + newlen + 1;
4708         }
4709       }
4710       return nullptr;
4711     }
4712     case JVM_SIGNATURE_ARRAY:
4713       array_dim++;
4714       if (array_dim > 255) {

4730 
4731 // Checks if name is a legal class name.
4732 void ClassFileParser::verify_legal_class_name(const Symbol* name, TRAPS) const {
4733   if (!_need_verify) { return; }
4734 
4735   assert(name->refcount() > 0, "symbol must be kept alive");
4736   char* bytes = (char*)name->bytes();
4737   unsigned int length = name->utf8_length();
4738   bool legal = false;
4739 
4740   if (length > 0) {
4741     const char* p;
4742     if (bytes[0] == JVM_SIGNATURE_ARRAY) {
4743       p = skip_over_field_signature(bytes, false, length, CHECK);
4744       legal = (p != nullptr) && ((p - bytes) == (int)length);
4745     } else if (_major_version < JAVA_1_5_VERSION) {
4746       if (bytes[0] != JVM_SIGNATURE_SPECIAL) {
4747         p = skip_over_field_name(bytes, true, length);
4748         legal = (p != nullptr) && ((p - bytes) == (int)length);
4749       }




4750     } else {
4751       // 4900761: relax the constraints based on JSR202 spec
4752       // Class names may be drawn from the entire Unicode character set.
4753       // Identifiers between '/' must be unqualified names.
4754       // The utf8 string has been verified when parsing cpool entries.
4755       legal = verify_unqualified_name(bytes, length, LegalClass);
4756     }
4757   }
4758   if (!legal) {
4759     ResourceMark rm(THREAD);
4760     assert(_class_name != nullptr, "invariant");
4761     // Names are all known to be < 64k so we know this formatted message is not excessively large.
4762     Exceptions::fthrow(
4763       THREAD_AND_LOCATION,
4764       vmSymbols::java_lang_ClassFormatError(),
4765       "Illegal class name \"%.*s\" in class file %s", length, bytes,
4766       _class_name->as_C_string()
4767     );
4768     return;
4769   }

4797       THREAD_AND_LOCATION,
4798       vmSymbols::java_lang_ClassFormatError(),
4799       "Illegal field name \"%.*s\" in class %s", length, bytes,
4800       _class_name->as_C_string()
4801     );
4802     return;
4803   }
4804 }
4805 
4806 // Checks if name is a legal method name.
4807 void ClassFileParser::verify_legal_method_name(const Symbol* name, TRAPS) const {
4808   if (!_need_verify) { return; }
4809 
4810   assert(name != nullptr, "method name is null");
4811   char* bytes = (char*)name->bytes();
4812   unsigned int length = name->utf8_length();
4813   bool legal = false;
4814 
4815   if (length > 0) {
4816     if (bytes[0] == JVM_SIGNATURE_SPECIAL) {
4817       if (name == vmSymbols::object_initializer_name() || name == vmSymbols::class_initializer_name()) {

4818         legal = true;
4819       }
4820     } else if (_major_version < JAVA_1_5_VERSION) {
4821       const char* p;
4822       p = skip_over_field_name(bytes, false, length);
4823       legal = (p != nullptr) && ((p - bytes) == (int)length);
4824     } else {
4825       // 4881221: relax the constraints based on JSR202 spec
4826       legal = verify_unqualified_name(bytes, length, LegalMethod);
4827     }
4828   }
4829 
4830   if (!legal) {
4831     ResourceMark rm(THREAD);
4832     assert(_class_name != nullptr, "invariant");
4833     // Names are all known to be < 64k so we know this formatted message is not excessively large.
4834     Exceptions::fthrow(
4835       THREAD_AND_LOCATION,
4836       vmSymbols::java_lang_ClassFormatError(),
4837       "Illegal method name \"%.*s\" in class %s", length, bytes,
4838       _class_name->as_C_string()
4839     );
4840     return;
4841   }
4842 }
4843 










4844 
4845 // Checks if signature is a legal field signature.
4846 void ClassFileParser::verify_legal_field_signature(const Symbol* name,
4847                                                    const Symbol* signature,
4848                                                    TRAPS) const {
4849   if (!_need_verify) { return; }
4850 
4851   const char* const bytes = (const char*)signature->bytes();
4852   const unsigned int length = signature->utf8_length();
4853   const char* const p = skip_over_field_signature(bytes, false, length, CHECK);
4854 
4855   if (p == nullptr || (p - bytes) != (int)length) {
4856     throwIllegalSignature("Field", name, signature, CHECK);
4857   }
4858 }
4859 
4860 // Check that the signature is compatible with the method name.  For example,
4861 // check that <init> has a void signature.
4862 void ClassFileParser::verify_legal_name_with_signature(const Symbol* name,
4863                                                        const Symbol* signature,
4864                                                        TRAPS) const {
4865   if (!_need_verify) {
4866     return;
4867   }
4868 
4869   // Class initializers cannot have args for class format version >= 51.
4870   if (name == vmSymbols::class_initializer_name() &&
4871       signature != vmSymbols::void_method_signature() &&
4872       _major_version >= JAVA_7_VERSION) {
4873     throwIllegalSignature("Method", name, signature, THREAD);
4874     return;
4875   }
4876 
4877   int sig_length = signature->utf8_length();
4878   if (name->utf8_length() > 0 &&
4879       name->char_at(0) == JVM_SIGNATURE_SPECIAL &&
4880       sig_length > 0 &&
4881       signature->char_at(sig_length - 1) != JVM_SIGNATURE_VOID) {
4882     throwIllegalSignature("Method", name, signature, THREAD);
4883   }
4884 }
4885 
4886 // Checks if signature is a legal method signature.
4887 // Returns number of parameters
4888 int ClassFileParser::verify_legal_method_signature(const Symbol* name,
4889                                                    const Symbol* signature,
4890                                                    TRAPS) const {
4891   if (!_need_verify) {
4892     // make sure caller's args_size will be less than 0 even for non-static
4893     // method so it will be recomputed in compute_size_of_parameters().
4894     return -2;
4895   }
4896 
4897   unsigned int args_size = 0;
4898   const char* p = (const char*)signature->bytes();
4899   unsigned int length = signature->utf8_length();
4900   const char* nextp;
4901 

4912       length -= pointer_delta_as_int(nextp, p);
4913       p = nextp;
4914       nextp = skip_over_field_signature(p, false, length, CHECK_0);
4915     }
4916     // The first non-signature thing better be a ')'
4917     if ((length > 0) && (*p++ == JVM_SIGNATURE_ENDFUNC)) {
4918       length--;
4919       // Now we better just have a return value
4920       nextp = skip_over_field_signature(p, true, length, CHECK_0);
4921       if (nextp && ((int)length == (nextp - p))) {
4922         return args_size;
4923       }
4924     }
4925   }
4926   // Report error
4927   throwIllegalSignature("Method", name, signature, THREAD);
4928   return 0;
4929 }
4930 
4931 int ClassFileParser::static_field_size() const {
4932   assert(_field_info != nullptr, "invariant");
4933   return _field_info->_static_field_size;
4934 }
4935 
4936 int ClassFileParser::total_oop_map_count() const {
4937   assert(_field_info != nullptr, "invariant");
4938   return _field_info->oop_map_blocks->_nonstatic_oop_map_count;
4939 }
4940 
4941 jint ClassFileParser::layout_size() const {
4942   assert(_field_info != nullptr, "invariant");
4943   return _field_info->_instance_size;
4944 }
4945 
4946 static void check_methods_for_intrinsics(const InstanceKlass* ik,
4947                                          const Array<Method*>* methods) {
4948   assert(ik != nullptr, "invariant");
4949   assert(methods != nullptr, "invariant");
4950 
4951   // Set up Method*::intrinsic_id as soon as we know the names of methods.
4952   // (We used to do this lazily, but now we query it in Rewriter,
4953   // which is eagerly done for every method, so we might as well do it now,
4954   // when everything is fresh in memory.)
4955   const vmSymbolID klass_id = Method::klass_id_for_intrinsics(ik);
4956 
4957   if (klass_id != vmSymbolID::NO_SID) {
4958     for (int j = 0; j < methods->length(); ++j) {
4959       Method* method = methods->at(j);
4960       method->init_intrinsic_id(klass_id);
4961 
4962       if (CheckIntrinsics) {
4963         // Check if an intrinsic is defined for method 'method',

5038   }
5039 }
5040 
5041 InstanceKlass* ClassFileParser::create_instance_klass(bool changed_by_loadhook,
5042                                                       const ClassInstanceInfo& cl_inst_info,
5043                                                       TRAPS) {
5044   if (_klass != nullptr) {
5045     return _klass;
5046   }
5047 
5048   InstanceKlass* const ik =
5049     InstanceKlass::allocate_instance_klass(*this, CHECK_NULL);
5050 
5051   if (is_hidden()) {
5052     mangle_hidden_class_name(ik);
5053   }
5054 
5055   fill_instance_klass(ik, changed_by_loadhook, cl_inst_info, CHECK_NULL);
5056 
5057   assert(_klass == ik, "invariant");
5058 
5059   return ik;
5060 }
5061 
5062 void ClassFileParser::fill_instance_klass(InstanceKlass* ik,
5063                                           bool changed_by_loadhook,
5064                                           const ClassInstanceInfo& cl_inst_info,
5065                                           TRAPS) {
5066   assert(ik != nullptr, "invariant");
5067 
5068   // Set name and CLD before adding to CLD
5069   ik->set_class_loader_data(_loader_data);
5070   ik->set_class_loader_type();
5071   ik->set_name(_class_name);
5072 
5073   // Add all classes to our internal class loader list here,
5074   // including classes in the bootstrap (null) class loader.
5075   const bool publicize = !is_internal();
5076 
5077   _loader_data->add_class(ik, publicize);
5078 
5079   set_klass_to_deallocate(ik);
5080 
5081   assert(_field_info != nullptr, "invariant");
5082   assert(ik->static_field_size() == _field_info->_static_field_size, "sanity");
5083   assert(ik->nonstatic_oop_map_count() == _field_info->oop_map_blocks->_nonstatic_oop_map_count,
5084          "sanity");
5085 
5086   assert(ik->is_instance_klass(), "sanity");
5087   assert(ik->size_helper() == _field_info->_instance_size, "sanity");
5088 
5089   // Fill in information already parsed
5090   ik->set_should_verify_class(_need_verify);
5091 
5092   // Not yet: supers are done below to support the new subtype-checking fields
5093   ik->set_nonstatic_field_size(_field_info->_nonstatic_field_size);
5094   ik->set_has_nonstatic_fields(_field_info->_has_nonstatic_fields);










5095   ik->set_static_oop_field_count(_static_oop_count);
5096 
5097   // this transfers ownership of a lot of arrays from
5098   // the parser onto the InstanceKlass*
5099   apply_parsed_class_metadata(ik, _java_fields_count);



5100 
5101   // can only set dynamic nest-host after static nest information is set
5102   if (cl_inst_info.dynamic_nest_host() != nullptr) {
5103     ik->set_nest_host(cl_inst_info.dynamic_nest_host());
5104   }
5105 
5106   // note that is not safe to use the fields in the parser from this point on
5107   assert(nullptr == _cp, "invariant");
5108   assert(nullptr == _fieldinfo_stream, "invariant");
5109   assert(nullptr == _fieldinfo_search_table, "invariant");
5110   assert(nullptr == _fields_status, "invariant");
5111   assert(nullptr == _methods, "invariant");
5112   assert(nullptr == _inner_classes, "invariant");
5113   assert(nullptr == _nest_members, "invariant");

5114   assert(nullptr == _combined_annotations, "invariant");
5115   assert(nullptr == _record_components, "invariant");
5116   assert(nullptr == _permitted_subclasses, "invariant");

5117 
5118   if (_has_localvariable_table) {
5119     ik->set_has_localvariable_table(true);
5120   }
5121 
5122   if (_has_final_method) {
5123     ik->set_has_final_method();
5124   }
5125 
5126   ik->copy_method_ordering(_method_ordering, CHECK);
5127   // The InstanceKlass::_methods_jmethod_ids cache
5128   // is managed on the assumption that the initial cache
5129   // size is equal to the number of methods in the class. If
5130   // that changes, then InstanceKlass::idnum_can_increment()
5131   // has to be changed accordingly.
5132   ik->set_initial_method_idnum(checked_cast<u2>(ik->methods()->length()));
5133 
5134   ik->set_this_class_index(_this_class_index);
5135 
5136   if (_is_hidden) {

5173   if ((_num_miranda_methods > 0) ||
5174       // if this class introduced new miranda methods or
5175       (_super_klass != nullptr && _super_klass->has_miranda_methods())
5176         // super class exists and this class inherited miranda methods
5177      ) {
5178        ik->set_has_miranda_methods(); // then set a flag
5179   }
5180 
5181   // Fill in information needed to compute superclasses.
5182   ik->initialize_supers(const_cast<InstanceKlass*>(_super_klass), _transitive_interfaces, CHECK);
5183   ik->set_transitive_interfaces(_transitive_interfaces);
5184   ik->set_local_interfaces(_local_interfaces);
5185   _transitive_interfaces = nullptr;
5186   _local_interfaces = nullptr;
5187 
5188   // Initialize itable offset tables
5189   klassItable::setup_itable_offset_table(ik);
5190 
5191   // Compute transitive closure of interfaces this class implements
5192   // Do final class setup
5193   OopMapBlocksBuilder* oop_map_blocks = _field_info->oop_map_blocks;
5194   if (oop_map_blocks->_nonstatic_oop_map_count > 0) {
5195     oop_map_blocks->copy(ik->start_of_nonstatic_oop_maps());
5196   }
5197 
5198   if (_has_contended_fields || _parsed_annotations->is_contended() ||
5199       ( _super_klass != nullptr && _super_klass->has_contended_annotations())) {
5200     ik->set_has_contended_annotations(true);
5201   }
5202 
5203   // Fill in has_finalizer and layout_helper
5204   set_precomputed_flags(ik);
5205 
5206   // check if this class can access its super class
5207   check_super_class_access(ik, CHECK);
5208 
5209   // check if this class can access its superinterfaces
5210   check_super_interface_access(ik, CHECK);
5211 
5212   // check if this class overrides any final method
5213   check_final_method_override(ik, CHECK);

5234 
5235   assert(_all_mirandas != nullptr, "invariant");
5236 
5237   // Generate any default methods - default methods are public interface methods
5238   // that have a default implementation.  This is new with Java 8.
5239   if (_has_nonstatic_concrete_methods) {
5240     DefaultMethods::generate_default_methods(ik,
5241                                              _all_mirandas,
5242                                              CHECK);
5243   }
5244 
5245   // Add read edges to the unnamed modules of the bootstrap and app class loaders.
5246   if (changed_by_loadhook && !module_handle.is_null() && module_entry->is_named() &&
5247       !module_entry->has_default_read_edges()) {
5248     if (!module_entry->set_has_default_read_edges()) {
5249       // We won a potential race
5250       JvmtiExport::add_default_read_edges(module_handle, THREAD);
5251     }
5252   }
5253 















5254   ClassLoadingService::notify_class_loaded(ik, false /* not shared class */);
5255 
5256   if (!is_internal()) {
5257     ik->print_class_load_logging(_loader_data, module_entry, _stream);
5258 
5259     if (ik->minor_version() == JAVA_PREVIEW_MINOR_VERSION &&
5260         ik->major_version() == JVM_CLASSFILE_MAJOR_VERSION &&
5261         log_is_enabled(Info, class, preview)) {
5262       ResourceMark rm;
5263       log_info(class, preview)("Loading class %s that depends on preview features (class file version %d.65535)",
5264                                ik->external_name(), JVM_CLASSFILE_MAJOR_VERSION);
5265     }
5266 
5267     if (log_is_enabled(Debug, class, resolve))  {
5268       ResourceMark rm;
5269       // print out the superclass.
5270       const char * from = ik->external_name();
5271       if (ik->super() != nullptr) {
5272         log_debug(class, resolve)("%s %s (super)",
5273                    from,

5316                                  const ClassLoadInfo* cl_info,
5317                                  Publicity pub_level,
5318                                  TRAPS) :
5319   _stream(stream),
5320   _class_name(nullptr),
5321   _loader_data(loader_data),
5322   _is_hidden(cl_info->is_hidden()),
5323   _can_access_vm_annotations(cl_info->can_access_vm_annotations()),
5324   _orig_cp_size(0),
5325   _static_oop_count(0),
5326   _super_klass(),
5327   _cp(nullptr),
5328   _fieldinfo_stream(nullptr),
5329   _fieldinfo_search_table(nullptr),
5330   _fields_status(nullptr),
5331   _methods(nullptr),
5332   _inner_classes(nullptr),
5333   _nest_members(nullptr),
5334   _nest_host(0),
5335   _permitted_subclasses(nullptr),

5336   _record_components(nullptr),
5337   _local_interfaces(nullptr),

5338   _transitive_interfaces(nullptr),
5339   _combined_annotations(nullptr),
5340   _class_annotations(nullptr),
5341   _class_type_annotations(nullptr),
5342   _fields_annotations(nullptr),
5343   _fields_type_annotations(nullptr),
5344   _klass(nullptr),
5345   _klass_to_deallocate(nullptr),
5346   _parsed_annotations(nullptr),
5347   _field_info(nullptr),

5348   _temp_field_info(nullptr),
5349   _method_ordering(nullptr),
5350   _all_mirandas(nullptr),
5351   _vtable_size(0),
5352   _itable_size(0),
5353   _num_miranda_methods(0),
5354   _protection_domain(cl_info->protection_domain()),
5355   _access_flags(),
5356   _pub_level(pub_level),
5357   _bad_constant_seen(0),
5358   _synthetic_flag(false),
5359   _sde_length(false),
5360   _sde_buffer(nullptr),
5361   _sourcefile_index(0),
5362   _generic_signature_index(0),
5363   _major_version(0),
5364   _minor_version(0),
5365   _this_class_index(0),
5366   _super_class_index(0),
5367   _itfs_len(0),
5368   _java_fields_count(0),
5369   _need_verify(false),
5370   _has_nonstatic_concrete_methods(false),
5371   _declares_nonstatic_concrete_methods(false),
5372   _has_localvariable_table(false),
5373   _has_final_method(false),
5374   _has_contended_fields(false),
5375   _has_aot_runtime_setup_method(false),





5376   _has_finalizer(false),
5377   _has_empty_finalizer(false),
5378   _max_bootstrap_specifier_index(-1) {
5379 
5380   _class_name = name != nullptr ? name : vmSymbols::unknown_class_name();
5381   _class_name->increment_refcount();
5382 
5383   assert(_loader_data != nullptr, "invariant");
5384   assert(stream != nullptr, "invariant");
5385   assert(_stream != nullptr, "invariant");
5386   assert(_stream->buffer() == _stream->current(), "invariant");
5387   assert(_class_name != nullptr, "invariant");
5388   assert(0 == _access_flags.as_unsigned_short(), "invariant");
5389 
5390   // Figure out whether we can skip format checking (matching classic VM behavior)
5391   // Always verify CFLH bytes from the user agents.
5392   _need_verify = stream->from_class_file_load_hook() ? true : Verifier::should_verify_for(_loader_data->class_loader());
5393 
5394   // synch back verification state to stream to check for truncation.
5395   stream->set_need_verify(_need_verify);
5396 
5397   parse_stream(stream, CHECK);
5398 
5399   post_process_parsed_stream(stream, _cp, CHECK);
5400 }
5401 
5402 void ClassFileParser::clear_class_metadata() {
5403   // metadata created before the instance klass is created.  Must be
5404   // deallocated if classfile parsing returns an error.
5405   _cp = nullptr;
5406   _fieldinfo_stream = nullptr;
5407   _fieldinfo_search_table = nullptr;
5408   _fields_status = nullptr;
5409   _methods = nullptr;
5410   _inner_classes = nullptr;
5411   _nest_members = nullptr;
5412   _permitted_subclasses = nullptr;

5413   _combined_annotations = nullptr;
5414   _class_annotations = _class_type_annotations = nullptr;
5415   _fields_annotations = _fields_type_annotations = nullptr;
5416   _record_components = nullptr;

5417 }
5418 
5419 // Destructor to clean up
5420 ClassFileParser::~ClassFileParser() {
5421   _class_name->decrement_refcount();
5422 
5423   if (_cp != nullptr) {
5424     MetadataFactory::free_metadata(_loader_data, _cp);
5425   }
5426 
5427   if (_fieldinfo_stream != nullptr) {
5428     MetadataFactory::free_array<u1>(_loader_data, _fieldinfo_stream);
5429   }
5430   MetadataFactory::free_array<u1>(_loader_data, _fieldinfo_search_table);
5431 
5432   if (_fields_status != nullptr) {
5433     MetadataFactory::free_array<FieldStatus>(_loader_data, _fields_status);
5434   }
5435 




5436   if (_methods != nullptr) {
5437     // Free methods
5438     InstanceKlass::deallocate_methods(_loader_data, _methods);
5439   }
5440 
5441   // beware of the Universe::empty_blah_array!!
5442   if (_inner_classes != nullptr && _inner_classes != Universe::the_empty_short_array()) {
5443     MetadataFactory::free_array<u2>(_loader_data, _inner_classes);
5444   }
5445 
5446   if (_nest_members != nullptr && _nest_members != Universe::the_empty_short_array()) {
5447     MetadataFactory::free_array<u2>(_loader_data, _nest_members);
5448   }
5449 
5450   if (_record_components != nullptr) {
5451     InstanceKlass::deallocate_record_components(_loader_data, _record_components);
5452   }
5453 
5454   if (_permitted_subclasses != nullptr && _permitted_subclasses != Universe::the_empty_short_array()) {
5455     MetadataFactory::free_array<u2>(_loader_data, _permitted_subclasses);
5456   }
5457 




5458   // Free interfaces
5459   InstanceKlass::deallocate_interfaces(_loader_data, _super_klass,
5460                                        _local_interfaces, _transitive_interfaces);
5461 
5462   if (_combined_annotations != nullptr) {
5463     // After all annotations arrays have been created, they are installed into the
5464     // Annotations object that will be assigned to the InstanceKlass being created.
5465 
5466     // Deallocate the Annotations object and the installed annotations arrays.
5467     _combined_annotations->deallocate_contents(_loader_data);
5468 
5469     // If the _combined_annotations pointer is non-null,
5470     // then the other annotations fields should have been cleared.
5471     assert(_class_annotations       == nullptr, "Should have been cleared");
5472     assert(_class_type_annotations  == nullptr, "Should have been cleared");
5473     assert(_fields_annotations      == nullptr, "Should have been cleared");
5474     assert(_fields_type_annotations == nullptr, "Should have been cleared");
5475   } else {
5476     // If the annotations arrays were not installed into the Annotations object,
5477     // then they have to be deallocated explicitly.

5536 
5537   assert(cp_size == (u2)cp->length(), "invariant");
5538 
5539   // ACCESS FLAGS
5540   stream->guarantee_more(8, CHECK);  // flags, this_class, super_class, infs_len
5541 
5542   // Access flags
5543   u2 flags;
5544   // JVM_ACC_MODULE is defined in JDK-9 and later.
5545   if (_major_version >= JAVA_9_VERSION) {
5546     flags = stream->get_u2_fast() & (JVM_RECOGNIZED_CLASS_MODIFIERS | JVM_ACC_MODULE);
5547   } else {
5548     flags = stream->get_u2_fast() & JVM_RECOGNIZED_CLASS_MODIFIERS;
5549   }
5550 
5551   if ((flags & JVM_ACC_INTERFACE) && _major_version < JAVA_6_VERSION) {
5552     // Set abstract bit for old class files for backward compatibility
5553     flags |= JVM_ACC_ABSTRACT;
5554   }
5555 









5556   verify_legal_class_modifiers(flags, nullptr, false, CHECK);
5557 
5558   short bad_constant = class_bad_constant_seen();
5559   if (bad_constant != 0) {
5560     // Do not throw CFE until after the access_flags are checked because if
5561     // ACC_MODULE is set in the access flags, then NCDFE must be thrown, not CFE.
5562     classfile_parse_error("Unknown constant tag %u in class file %s", bad_constant, THREAD);
5563     return;
5564   }
5565 
5566   _access_flags.set_flags(flags);
5567 
5568   // This class and superclass
5569   _this_class_index = stream->get_u2_fast();
5570   guarantee_property(
5571     valid_cp_range(_this_class_index, cp_size) &&
5572       cp->tag_at(_this_class_index).is_unresolved_klass(),
5573     "Invalid this class index %u in constant pool in class file %s",
5574     _this_class_index, CHECK);
5575 

5639       }
5640       ls.cr();
5641     }
5642   }
5643 
5644   // SUPERKLASS
5645   _super_class_index = stream->get_u2_fast();
5646   check_super_class(cp,
5647                     _super_class_index,
5648                     _need_verify,
5649                     CHECK);
5650 
5651   // Interfaces
5652   _itfs_len = stream->get_u2_fast();
5653   parse_interfaces(stream,
5654                    _itfs_len,
5655                    cp,
5656                    &_has_nonstatic_concrete_methods,
5657                    CHECK);
5658 
5659   assert(_local_interfaces != nullptr, "invariant");
5660 
5661   // Fields (offsets are filled in later)
5662   parse_fields(stream,
5663                _access_flags.is_interface(),
5664                cp,
5665                cp_size,
5666                &_java_fields_count,
5667                CHECK);
5668 
5669   assert(_temp_field_info != nullptr, "invariant");
5670 
5671   // Methods
5672   parse_methods(stream,
5673                 _access_flags.is_interface(),


5674                 &_has_localvariable_table,
5675                 &_has_final_method,
5676                 &_declares_nonstatic_concrete_methods,
5677                 CHECK);
5678 
5679   assert(_methods != nullptr, "invariant");
5680 
5681   if (_declares_nonstatic_concrete_methods) {
5682     _has_nonstatic_concrete_methods = true;
5683   }
5684 
5685   // Additional attributes/annotations
5686   _parsed_annotations = new ClassAnnotationCollector();
5687   parse_classfile_attributes(stream, cp, _parsed_annotations, CHECK);
5688 
5689   assert(_inner_classes != nullptr, "invariant");
5690 
5691   // Finalize the Annotations metadata object,
5692   // now that all annotation arrays have been created.
5693   create_combined_annotations(CHECK);

5741 }
5742 
5743 void ClassFileParser::post_process_parsed_stream(const ClassFileStream* const stream,
5744                                                  ConstantPool* cp,
5745                                                  TRAPS) {
5746   assert(stream != nullptr, "invariant");
5747   assert(stream->at_eos(), "invariant");
5748   assert(cp != nullptr, "invariant");
5749   assert(_loader_data != nullptr, "invariant");
5750 
5751   if (_class_name == vmSymbols::java_lang_Object()) {
5752     precond(_super_class_index == 0);
5753     precond(_super_klass == nullptr);
5754     guarantee_property(_local_interfaces == Universe::the_empty_instance_klass_array(),
5755                        "java.lang.Object cannot implement an interface in class file %s",
5756                        CHECK);
5757   } else {
5758     // Set _super_klass after class file is parsed and format is checked
5759     assert(_super_class_index > 0, "any class other than Object must have a super class");
5760     Symbol* const super_class_name = cp->klass_name_at(_super_class_index);
5761     if (_access_flags.is_interface()) {
5762       // Before attempting to resolve the superclass, check for class format
5763       // errors not checked yet.
5764       guarantee_property(super_class_name == vmSymbols::java_lang_Object(),
5765         "Interfaces must have java.lang.Object as superclass in class file %s",
5766         CHECK);
5767     }
5768     Handle loader(THREAD, _loader_data->class_loader());
5769     if (loader.is_null() && super_class_name == vmSymbols::java_lang_Object()) {
5770       // fast path to avoid lookup
5771       _super_klass = vmClasses::Object_klass();
5772     } else {
5773       _super_klass = (const InstanceKlass*)
5774                        SystemDictionary::resolve_super_or_fail(_class_name,
5775                                                                super_class_name,
5776                                                                loader,
5777                                                                true,
5778                                                                CHECK);
5779     }
5780   }
5781 
5782   if (_super_klass != nullptr) {














5783     if (_super_klass->has_nonstatic_concrete_methods()) {
5784       _has_nonstatic_concrete_methods = true;
5785     }

5786 
5787     if (_super_klass->is_interface()) {
5788       classfile_icce_error("class %s has interface %s as super class", _super_klass, THREAD);
5789       return;


































































5790     }
5791   }

5792 
5793   // Compute the transitive list of all unique interfaces implemented by this class
5794   _transitive_interfaces =
5795     compute_transitive_interfaces(_super_klass,
5796                                   _local_interfaces,
5797                                   _loader_data,
5798                                   CHECK);
5799 
5800   assert(_transitive_interfaces != nullptr, "invariant");
5801 
5802   // sort methods
5803   _method_ordering = sort_methods(_methods);
5804 
5805   _all_mirandas = new GrowableArray<Method*>(20);
5806 
5807   Handle loader(THREAD, _loader_data->class_loader());
5808   klassVtable::compute_vtable_size_and_num_mirandas(&_vtable_size,
5809                                                     &_num_miranda_methods,
5810                                                     _all_mirandas,
5811                                                     _super_klass,
5812                                                     _methods,
5813                                                     _access_flags,
5814                                                     _major_version,
5815                                                     loader,
5816                                                     _class_name,
5817                                                     _local_interfaces);
5818 
5819   // Size of Java itable (in words)
5820   _itable_size = _access_flags.is_interface() ? 0 :
5821     klassItable::compute_itable_size(_transitive_interfaces);
5822 
5823   assert(_parsed_annotations != nullptr, "invariant");
5824 
5825   _field_info = new FieldLayoutInfo();
5826   FieldLayoutBuilder lb(class_name(), super_klass(), _cp, /*_fields*/ _temp_field_info,
5827                         _parsed_annotations->is_contended(), _field_info);

























































































5828   lb.build_layout();

5829 
5830   int injected_fields_count = _temp_field_info->length() - _java_fields_count;
5831   _fieldinfo_stream =
5832     FieldInfoStream::create_FieldInfoStream(_temp_field_info, _java_fields_count,
5833                                             injected_fields_count, loader_data(), CHECK);
5834   _fieldinfo_search_table = FieldInfoStream::create_search_table(_cp, _fieldinfo_stream, _loader_data, CHECK);
5835   _fields_status =
5836     MetadataFactory::new_array<FieldStatus>(_loader_data, _temp_field_info->length(),
5837                                             FieldStatus(0), CHECK);





















5838 }
5839 
5840 void ClassFileParser::set_klass(InstanceKlass* klass) {
5841 
5842 #ifdef ASSERT
5843   if (klass != nullptr) {
5844     assert(nullptr == _klass, "leaking?");
5845   }
5846 #endif
5847 
5848   _klass = klass;
5849 }
5850 
5851 void ClassFileParser::set_klass_to_deallocate(InstanceKlass* klass) {
5852 
5853 #ifdef ASSERT
5854   if (klass != nullptr) {
5855     assert(nullptr == _klass_to_deallocate, "leaking?");
5856   }
5857 #endif

   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 #include "cds/cdsConfig.hpp"
  26 #include "classfile/classFileParser.hpp"
  27 #include "classfile/classFileStream.hpp"
  28 #include "classfile/classLoader.hpp"
  29 #include "classfile/classLoaderData.inline.hpp"
  30 #include "classfile/classLoadInfo.hpp"
  31 #include "classfile/defaultMethods.hpp"
  32 #include "classfile/fieldLayoutBuilder.hpp"
  33 #include "classfile/javaClasses.inline.hpp"
  34 #include "classfile/moduleEntry.hpp"
  35 #include "classfile/packageEntry.hpp"
  36 #include "classfile/symbolTable.hpp"
  37 #include "classfile/systemDictionary.hpp"
  38 #include "classfile/verificationType.hpp"
  39 #include "classfile/verifier.hpp"
  40 #include "classfile/vmClasses.hpp"
  41 #include "classfile/vmSymbols.hpp"
  42 #include "jvm.h"
  43 #include "logging/log.hpp"
  44 #include "logging/logStream.hpp"
  45 #include "memory/allocation.hpp"
  46 #include "memory/metadataFactory.hpp"
  47 #include "memory/oopFactory.hpp"
  48 #include "memory/resourceArea.hpp"
  49 #include "memory/universe.hpp"
  50 #include "oops/annotations.hpp"
  51 #include "oops/constantPool.inline.hpp"
  52 #include "oops/fieldInfo.hpp"
  53 #include "oops/fieldStreams.inline.hpp"
  54 #include "oops/inlineKlass.inline.hpp"
  55 #include "oops/instanceKlass.inline.hpp"
  56 #include "oops/instanceMirrorKlass.hpp"
  57 #include "oops/klass.inline.hpp"
  58 #include "oops/klassVtable.hpp"
  59 #include "oops/metadata.hpp"
  60 #include "oops/method.inline.hpp"
  61 #include "oops/oop.inline.hpp"
  62 #include "oops/recordComponent.hpp"
  63 #include "oops/symbol.hpp"
  64 #include "prims/jvmtiExport.hpp"
  65 #include "prims/jvmtiThreadState.hpp"
  66 #include "runtime/arguments.hpp"
  67 #include "runtime/fieldDescriptor.inline.hpp"
  68 #include "runtime/handles.inline.hpp"
  69 #include "runtime/javaCalls.hpp"
  70 #include "runtime/os.hpp"
  71 #include "runtime/perfData.hpp"
  72 #include "runtime/reflection.hpp"
  73 #include "runtime/safepointVerifiers.hpp"
  74 #include "runtime/signature.hpp"
  75 #include "runtime/timer.hpp"
  76 #include "services/classLoadingService.hpp"
  77 #include "services/threadService.hpp"
  78 #include "utilities/align.hpp"
  79 #include "utilities/bitMap.inline.hpp"
  80 #include "utilities/checkedCast.hpp"
  81 #include "utilities/copy.hpp"
  82 #include "utilities/exceptions.hpp"
  83 #include "utilities/formatBuffer.hpp"
  84 #include "utilities/globalDefinitions.hpp"
  85 #include "utilities/growableArray.hpp"
  86 #include "utilities/hashTable.hpp"
  87 #include "utilities/macros.hpp"
  88 #include "utilities/ostream.hpp"
  89 #include "utilities/stringUtils.hpp"
  90 #include "utilities/utf8.hpp"
  91 #if INCLUDE_CDS
  92 #include "classfile/systemDictionaryShared.hpp"
  93 #endif
  94 #if INCLUDE_JFR
  95 #include "jfr/support/jfrTraceIdExtension.hpp"
  96 #endif
  97 
  98 // We generally try to create the oops directly when parsing, rather than
  99 // allocating temporary data structures and copying the bytes twice. A
 100 // temporary area is only needed when parsing utf8 entries in the constant
 101 // pool and when parsing line number tables.
 102 
 103 // We add assert in debug mode when class format is not checked.
 104 
 105 #define JAVA_CLASSFILE_MAGIC              0xCAFEBABE
 106 #define JAVA_MIN_SUPPORTED_VERSION        45
 107 #define JAVA_PREVIEW_MINOR_VERSION        65535
 108 
 109 // Used for two backward compatibility reasons:

 142 #define JAVA_17_VERSION                   61
 143 
 144 #define JAVA_18_VERSION                   62
 145 
 146 #define JAVA_19_VERSION                   63
 147 
 148 #define JAVA_20_VERSION                   64
 149 
 150 #define JAVA_21_VERSION                   65
 151 
 152 #define JAVA_22_VERSION                   66
 153 
 154 #define JAVA_23_VERSION                   67
 155 
 156 #define JAVA_24_VERSION                   68
 157 
 158 #define JAVA_25_VERSION                   69
 159 
 160 #define JAVA_26_VERSION                   70
 161 
 162 #define CONSTANT_CLASS_DESCRIPTORS        70
 163 
 164 void ClassFileParser::set_class_bad_constant_seen(short bad_constant) {
 165   assert((bad_constant == JVM_CONSTANT_Module ||
 166           bad_constant == JVM_CONSTANT_Package) && _major_version >= JAVA_9_VERSION,
 167          "Unexpected bad constant pool entry");
 168   if (_bad_constant_seen == 0) _bad_constant_seen = bad_constant;
 169 }
 170 
 171 void ClassFileParser::parse_constant_pool_entries(const ClassFileStream* const stream,
 172                                                   ConstantPool* cp,
 173                                                   const int length,
 174                                                   TRAPS) {
 175   assert(stream != nullptr, "invariant");
 176   assert(cp != nullptr, "invariant");
 177 
 178   // Use a local copy of ClassFileStream. It helps the C++ compiler to optimize
 179   // this function (_current can be allocated in a register, with scalar
 180   // replacement of aggregates). The _current pointer is copied back to
 181   // stream() when this function returns. DON'T call another method within
 182   // this method that uses stream().
 183   const ClassFileStream cfs1 = *stream;
 184   const ClassFileStream* const cfs = &cfs1;
 185 
 186   DEBUG_ONLY(const u1* const old_current = stream->current();)
 187 
 188   // Used for batching symbol allocations.
 189   const char* names[SymbolTable::symbol_alloc_batch_size];
 190   int lengths[SymbolTable::symbol_alloc_batch_size];
 191   int indices[SymbolTable::symbol_alloc_batch_size];
 192   unsigned int hashValues[SymbolTable::symbol_alloc_batch_size];
 193   int names_count = 0;
 194 
 195   // parsing  Index 0 is unused
 196   for (int index = 1; index < length; index++) {
 197     // Each of the following case guarantees one more byte in the stream
 198     // for the following tag or the access_flags following constant pool,
 199     // so we don't need bounds-check for reading tag.
 200     const u1 tag = cfs->get_u1_fast();
 201     switch (tag) {
 202       case JVM_CONSTANT_Class: {
 203         cfs->guarantee_more(3, CHECK);  // name_index, tag/access_flags
 204         const u2 name_index = cfs->get_u2_fast();
 205         cp->klass_index_at_put(index, name_index);
 206         break;
 207       }
 208       case JVM_CONSTANT_Fieldref: {
 209         cfs->guarantee_more(5, CHECK);  // class_index, name_and_type_index, tag/access_flags
 210         const u2 class_index = cfs->get_u2_fast();
 211         const u2 name_and_type_index = cfs->get_u2_fast();
 212         cp->field_at_put(index, class_index, name_and_type_index);
 213         break;
 214       }
 215       case JVM_CONSTANT_Methodref: {
 216         cfs->guarantee_more(5, CHECK);  // class_index, name_and_type_index, tag/access_flags
 217         const u2 class_index = cfs->get_u2_fast();
 218         const u2 name_and_type_index = cfs->get_u2_fast();
 219         cp->method_at_put(index, class_index, name_and_type_index);
 220         break;
 221       }
 222       case JVM_CONSTANT_InterfaceMethodref: {

 486         guarantee_property(valid_symbol_at(name_ref_index),
 487           "Invalid constant pool index %u in class file %s",
 488           name_ref_index, CHECK);
 489         guarantee_property(valid_symbol_at(signature_ref_index),
 490           "Invalid constant pool index %u in class file %s",
 491           signature_ref_index, CHECK);
 492         break;
 493       }
 494       case JVM_CONSTANT_Utf8:
 495         break;
 496       case JVM_CONSTANT_UnresolvedClass:         // fall-through
 497       case JVM_CONSTANT_UnresolvedClassInError: {
 498         ShouldNotReachHere();     // Only JVM_CONSTANT_ClassIndex should be present
 499         break;
 500       }
 501       case JVM_CONSTANT_ClassIndex: {
 502         const int class_index = cp->klass_index_at(index);
 503         guarantee_property(valid_symbol_at(class_index),
 504           "Invalid constant pool index %u in class file %s",
 505           class_index, CHECK);
 506 
 507         Symbol* const name = cp->symbol_at(class_index);
 508         const unsigned int name_len = name->utf8_length();
 509         cp->unresolved_klass_at_put(index, class_index, num_klasses++);
 510         break;
 511       }
 512       case JVM_CONSTANT_StringIndex: {
 513         const int string_index = cp->string_index_at(index);
 514         guarantee_property(valid_symbol_at(string_index),
 515           "Invalid constant pool index %u in class file %s",
 516           string_index, CHECK);
 517         Symbol* const sym = cp->symbol_at(string_index);
 518         cp->unresolved_string_at_put(index, sym);
 519         break;
 520       }
 521       case JVM_CONSTANT_MethodHandle: {
 522         const int ref_index = cp->method_handle_index_at(index);
 523         guarantee_property(valid_cp_range(ref_index, length),
 524           "Invalid constant pool index %u in class file %s",
 525           ref_index, CHECK);
 526         const constantTag tag = cp->tag_at(ref_index);
 527         const int ref_kind = cp->method_handle_ref_kind_at(index);
 528 

 698             }
 699           }
 700         } else {
 701           if (_need_verify) {
 702             // Method name and signature are individually verified above, when iterating
 703             // NameAndType_info.  Need to check here that signature is non-zero length and
 704             // the right type.
 705             if (!Signature::is_method(signature)) {
 706               throwIllegalSignature("Method", name, signature, CHECK);
 707             }
 708           }
 709           // If a class method name begins with '<', it must be "<init>" and have void signature.
 710           const unsigned int name_len = name->utf8_length();
 711           if (tag == JVM_CONSTANT_Methodref && name_len != 0 &&
 712               name->char_at(0) == JVM_SIGNATURE_SPECIAL) {
 713             if (name != vmSymbols::object_initializer_name()) {
 714               classfile_parse_error(
 715                 "Bad method name at constant pool index %u in class file %s",
 716                 name_ref_index, THREAD);
 717               return;
 718             } else if (!Signature::is_void_method(signature)) {  // must have void signature.
 719               throwIllegalSignature("Method", name, signature, CHECK);
 720             }
 721           }
 722         }
 723         break;
 724       }
 725       case JVM_CONSTANT_MethodHandle: {
 726         const int ref_index = cp->method_handle_index_at(index);
 727         const int ref_kind = cp->method_handle_ref_kind_at(index);
 728         switch (ref_kind) {
 729           case JVM_REF_invokeVirtual:
 730           case JVM_REF_invokeStatic:
 731           case JVM_REF_invokeSpecial:
 732           case JVM_REF_newInvokeSpecial: {
 733             const int name_and_type_ref_index =
 734               cp->uncached_name_and_type_ref_index_at(ref_index);
 735             const int name_ref_index =
 736               cp->name_ref_index_at(name_and_type_ref_index);
 737             const Symbol* const name = cp->symbol_at(name_ref_index);
 738 
 739             if (name != vmSymbols::object_initializer_name()) { // !<init>
 740               if (ref_kind == JVM_REF_newInvokeSpecial) {
 741                 classfile_parse_error(
 742                   "Bad constructor name at constant pool index %u in class file %s",
 743                     name_ref_index, THREAD);
 744                 return;
 745               }
 746             } else { // <init>
 747               // The allowed invocation mode of <init> depends on its signature.
 748               // This test corresponds to verify_invoke_instructions in the verifier.
 749               const int signature_ref_index =
 750                 cp->signature_ref_index_at(name_and_type_ref_index);
 751               const Symbol* const signature = cp->symbol_at(signature_ref_index);
 752               if (signature->is_void_method_signature()
 753                   && ref_kind == JVM_REF_newInvokeSpecial) {
 754                 // OK, could be a constructor call
 755               } else {
 756                 classfile_parse_error(
 757                   "Bad method name at constant pool index %u in class file %s",
 758                   name_ref_index, THREAD);
 759                 return;
 760               }
 761             }
 762             break;
 763           }
 764           // Other ref_kinds are already fully checked in previous pass.
 765         } // switch(ref_kind)
 766         break;
 767       }
 768       case JVM_CONSTANT_MethodType: {
 769         const Symbol* const no_name = vmSymbols::type_name(); // place holder
 770         const Symbol* const signature = cp->method_type_signature_at(index);
 771         verify_legal_method_signature(no_name, signature, CHECK);
 772         break;
 773       }
 774       case JVM_CONSTANT_Utf8: {
 775         assert(cp->symbol_at(index)->refcount() != 0, "count corrupted");

 787 
 788   NameSigHash(Symbol* name, Symbol* sig) :
 789     _name(name),
 790     _sig(sig) {}
 791 
 792   static unsigned int hash(NameSigHash const& namesig) {
 793     return namesig._name->identity_hash() ^ namesig._sig->identity_hash();
 794   }
 795 
 796   static bool equals(NameSigHash const& e0, NameSigHash const& e1) {
 797     return (e0._name == e1._name) &&
 798           (e0._sig  == e1._sig);
 799   }
 800 };
 801 
 802 using NameSigHashtable = HashTable<NameSigHash, int,
 803                                            NameSigHash::HASH_ROW_SIZE,
 804                                            AnyObj::RESOURCE_AREA, mtInternal,
 805                                            &NameSigHash::hash, &NameSigHash::equals>;
 806 
 807 static void check_identity_and_value_modifiers(ClassFileParser* current, const InstanceKlass* super_type, TRAPS) {
 808   assert(super_type != nullptr,"Method doesn't support null super type");
 809   if (super_type->access_flags().is_identity_class() && !current->access_flags().is_identity_class()
 810       && super_type->name() != vmSymbols::java_lang_Object()) {
 811       THROW_MSG(vmSymbols::java_lang_IncompatibleClassChangeError(),
 812                 err_msg("Value type %s has an identity type as supertype",
 813                 current->class_name()->as_klass_external_name()));
 814   }
 815 }
 816 
 817 void ClassFileParser::parse_interfaces(const ClassFileStream* stream,
 818                                        int itfs_len,
 819                                        ConstantPool* cp,
 820                                        bool* const has_nonstatic_concrete_methods,
 821                                        // FIXME: lots of these functions
 822                                        // declare their parameters as const,
 823                                        // which adds only noise to the code.
 824                                        // Remove the spurious const modifiers.
 825                                        // Many are of the form "const int x"
 826                                        // or "T* const x".
 827                                        TRAPS) {
 828   assert(stream != nullptr, "invariant");
 829   assert(cp != nullptr, "invariant");
 830   assert(has_nonstatic_concrete_methods != nullptr, "invariant");
 831 
 832   if (itfs_len == 0) {
 833     _local_interfaces = Universe::the_empty_instance_klass_array();
 834 
 835   } else {
 836     assert(itfs_len > 0, "only called for len>0");
 837     _local_interface_indexes = new GrowableArray<u2>(itfs_len);
 838     int index = 0;

 839     for (index = 0; index < itfs_len; index++) {
 840       const u2 interface_index = stream->get_u2(CHECK);

 841       guarantee_property(
 842         valid_klass_reference_at(interface_index),
 843         "Interface name has bad constant pool index %u in class file %s",
 844         interface_index, CHECK);
 845       _local_interface_indexes->at_put_grow(index, interface_index);




























 846     }
 847 
 848     if (!_need_verify || itfs_len <= 1) {
 849       return;
 850     }
 851 
 852     // Check if there's any duplicates in interfaces
 853     ResourceMark rm(THREAD);
 854     // Set containing interface names
 855     HashTable<Symbol*, int>* interface_names = new HashTable<Symbol*, int>();
 856     for (index = 0; index < itfs_len; index++) {
 857       Symbol* interface_name = cp->klass_name_at(_local_interface_indexes->at(index));

 858       // If no duplicates, add (name, nullptr) in hashtable interface_names.
 859       if (!interface_names->put(interface_name, 0)) {
 860         classfile_parse_error("Duplicate interface name \"%s\" in class file %s",
 861                                interface_name->as_C_string(), THREAD);
 862         return;
 863       }
 864     }
 865   }
 866 }
 867 
 868 void ClassFileParser::verify_constantvalue(const ConstantPool* const cp,
 869                                            int constantvalue_index,
 870                                            int signature_index,
 871                                            TRAPS) const {
 872   // Make sure the constant pool entry is of a type appropriate to this field
 873   guarantee_property(
 874     (constantvalue_index > 0 &&
 875       constantvalue_index < cp->length()),
 876     "Bad initial value index %u in ConstantValue attribute in class file %s",
 877     constantvalue_index, CHECK);

 924 class AnnotationCollector : public ResourceObj{
 925 public:
 926   enum Location { _in_field, _in_method, _in_class };
 927   enum ID {
 928     _unknown = 0,
 929     _method_CallerSensitive,
 930     _method_ForceInline,
 931     _method_DontInline,
 932     _method_ChangesCurrentThread,
 933     _method_JvmtiHideEvents,
 934     _method_JvmtiMountTransition,
 935     _method_InjectedProfile,
 936     _method_LambdaForm_Compiled,
 937     _method_Hidden,
 938     _method_Scoped,
 939     _method_IntrinsicCandidate,
 940     _jdk_internal_vm_annotation_Contended,
 941     _field_Stable,
 942     _jdk_internal_vm_annotation_ReservedStackAccess,
 943     _jdk_internal_ValueBased,
 944     _jdk_internal_LooselyConsistentValue,
 945     _jdk_internal_NullRestricted,
 946     _java_lang_Deprecated,
 947     _java_lang_Deprecated_for_removal,
 948     _jdk_internal_vm_annotation_AOTSafeClassInitializer,
 949     _method_AOTRuntimeSetup,
 950     _annotation_LIMIT
 951   };
 952   const Location _location;
 953   int _annotations_present;
 954   u2 _contended_group;
 955 
 956   AnnotationCollector(Location location)
 957     : _location(location), _annotations_present(0), _contended_group(0)
 958   {
 959     assert((int)_annotation_LIMIT <= (int)sizeof(_annotations_present) * BitsPerByte, "");
 960   }
 961   // If this annotation name has an ID, report it (or _none).
 962   ID annotation_index(const ClassLoaderData* loader_data, const Symbol* name, bool can_access_vm_annotations);
 963   // Set the annotation name:
 964   void set_annotation(ID id) {
 965     assert((int)id >= 0 && (int)id < (int)_annotation_LIMIT, "oob");

1352   }
1353 
1354   *constantvalue_index_addr = constantvalue_index;
1355   *is_synthetic_addr = is_synthetic;
1356   *generic_signature_index_addr = generic_signature_index;
1357   AnnotationArray* a = allocate_annotations(runtime_visible_annotations,
1358                                             runtime_visible_annotations_length,
1359                                             CHECK);
1360   parsed_annotations->set_field_annotations(a);
1361   a = allocate_annotations(runtime_visible_type_annotations,
1362                            runtime_visible_type_annotations_length,
1363                            CHECK);
1364   parsed_annotations->set_field_type_annotations(a);
1365   return;
1366 }
1367 
1368 
1369 // Side-effects: populates the _fields, _fields_annotations,
1370 // _fields_type_annotations fields
1371 void ClassFileParser::parse_fields(const ClassFileStream* const cfs,
1372                                    AccessFlags class_access_flags,
1373                                    ConstantPool* cp,
1374                                    const int cp_size,
1375                                    u2* const java_fields_count_ptr,
1376                                    TRAPS) {
1377 
1378   assert(cfs != nullptr, "invariant");
1379   assert(cp != nullptr, "invariant");
1380   assert(java_fields_count_ptr != nullptr, "invariant");
1381 
1382   assert(nullptr == _fields_annotations, "invariant");
1383   assert(nullptr == _fields_type_annotations, "invariant");
1384 
1385   bool is_inline_type = !class_access_flags.is_identity_class() && !class_access_flags.is_abstract();
1386   cfs->guarantee_more(2, CHECK);  // length
1387   const u2 length = cfs->get_u2_fast();
1388   *java_fields_count_ptr = length;
1389 
1390   int num_injected = 0;
1391   const InjectedField* const injected = JavaClasses::get_injected(_class_name,
1392                                                                   &num_injected);
1393 
1394   // two more slots are required for inline classes:
1395   // one for the static field with a reference to the pre-allocated default value
1396   // one for the field the JVM injects when detecting an empty inline class
1397   const int total_fields = length + num_injected + (is_inline_type ? 2 : 0);
1398 
1399   // Allocate a temporary resource array to collect field data.
1400   // After parsing all fields, data are stored in a UNSIGNED5 compressed stream.
1401   _temp_field_info = new GrowableArray<FieldInfo>(total_fields);
1402 
1403   int instance_fields_count = 0;
1404   ResourceMark rm(THREAD);
1405   for (int n = 0; n < length; n++) {
1406     // access_flags, name_index, descriptor_index, attributes_count
1407     cfs->guarantee_more(8, CHECK);
1408 
1409     jint recognized_modifiers = JVM_RECOGNIZED_FIELD_MODIFIERS;
1410     if (!supports_inline_types()) {
1411       recognized_modifiers &= ~JVM_ACC_STRICT;
1412     }
1413 
1414     const jint flags = cfs->get_u2_fast() & recognized_modifiers;
1415     verify_legal_field_modifiers(flags, class_access_flags, CHECK);
1416     AccessFlags access_flags;


1417     access_flags.set_flags(flags);
1418     FieldInfo::FieldFlags fieldFlags(0);
1419 
1420     const u2 name_index = cfs->get_u2_fast();
1421     guarantee_property(valid_symbol_at(name_index),
1422       "Invalid constant pool index %u for field name in class file %s",
1423       name_index, CHECK);
1424     const Symbol* const name = cp->symbol_at(name_index);
1425     verify_legal_field_name(name, CHECK);
1426 
1427     const u2 signature_index = cfs->get_u2_fast();
1428     guarantee_property(valid_symbol_at(signature_index),
1429       "Invalid constant pool index %u for field signature in class file %s",
1430       signature_index, CHECK);
1431     const Symbol* const sig = cp->symbol_at(signature_index);
1432     verify_legal_field_signature(name, sig, CHECK);
1433     if (!access_flags.is_static()) instance_fields_count++;
1434 
1435     u2 constantvalue_index = 0;
1436     bool is_synthetic = false;
1437     u2 generic_signature_index = 0;
1438     const bool is_static = access_flags.is_static();
1439     FieldAnnotationCollector parsed_annotations(_loader_data);
1440 
1441     bool is_null_restricted = false;
1442 
1443     const u2 attributes_count = cfs->get_u2_fast();
1444     if (attributes_count > 0) {
1445       parse_field_attributes(cfs,
1446                              attributes_count,
1447                              is_static,
1448                              signature_index,
1449                              &constantvalue_index,
1450                              &is_synthetic,
1451                              &generic_signature_index,
1452                              &parsed_annotations,
1453                              CHECK);
1454 
1455       if (parsed_annotations.field_annotations() != nullptr) {
1456         if (_fields_annotations == nullptr) {
1457           _fields_annotations = MetadataFactory::new_array<AnnotationArray*>(
1458                                              _loader_data, length, nullptr,
1459                                              CHECK);
1460         }
1461         _fields_annotations->at_put(n, parsed_annotations.field_annotations());
1462         if (parsed_annotations.has_annotation(AnnotationCollector::_jdk_internal_NullRestricted)) {
1463           if (!Signature::has_envelope(sig)) {
1464             Exceptions::fthrow(
1465               THREAD_AND_LOCATION,
1466               vmSymbols::java_lang_ClassFormatError(),
1467               "Illegal use of @jdk.internal.vm.annotation.NullRestricted annotation on field %s.%s with signature %s (primitive types can never be null)",
1468               class_name()->as_C_string(), name->as_C_string(), sig->as_C_string());
1469           }
1470           const bool is_strict = (flags & JVM_ACC_STRICT) != 0;
1471           if (!is_strict) {
1472             Exceptions::fthrow(
1473               THREAD_AND_LOCATION,
1474               vmSymbols::java_lang_ClassFormatError(),
1475               "Illegal use of @jdk.internal.vm.annotation.NullRestricted annotation on field %s.%s which doesn't have the @jdk.internal.vm.annotation.Strict annotation",
1476               class_name()->as_C_string(), name->as_C_string());
1477           }
1478           is_null_restricted = true;
1479         }
1480         parsed_annotations.set_field_annotations(nullptr);
1481       }
1482       if (parsed_annotations.field_type_annotations() != nullptr) {
1483         if (_fields_type_annotations == nullptr) {
1484           _fields_type_annotations =
1485             MetadataFactory::new_array<AnnotationArray*>(_loader_data,
1486                                                          length,
1487                                                          nullptr,
1488                                                          CHECK);
1489         }
1490         _fields_type_annotations->at_put(n, parsed_annotations.field_type_annotations());
1491         parsed_annotations.set_field_type_annotations(nullptr);
1492       }
1493 
1494       if (is_synthetic) {
1495         access_flags.set_is_synthetic();
1496       }
1497       if (generic_signature_index != 0) {
1498         fieldFlags.update_generic(true);
1499       }
1500     }
1501 
1502     if (is_null_restricted) {
1503       fieldFlags.update_null_free_inline_type(true);
1504     }
1505 
1506     const BasicType type = cp->basic_type_for_signature_at(signature_index);
1507 
1508     // Update number of static oop fields.
1509     if (is_static && is_reference_type(type)) {
1510       _static_oop_count++;
1511     }
1512 
1513     FieldInfo fi(access_flags, name_index, signature_index, constantvalue_index, fieldFlags);
1514     fi.set_index(n);
1515     if (fieldFlags.is_generic()) {
1516       fi.set_generic_signature_index(generic_signature_index);
1517     }
1518     parsed_annotations.apply_to(&fi);
1519     if (fi.field_flags().is_contended()) {
1520       _has_contended_fields = true;
1521     }
1522     if (access_flags.is_strict() && access_flags.is_static()) {
1523       _has_strict_static_fields = true;
1524     }
1525     _temp_field_info->append(fi);
1526   }
1527   assert(_temp_field_info->length() == length, "Must be");
1528 

1529   if (num_injected != 0) {
1530     for (int n = 0; n < num_injected; n++) {
1531       // Check for duplicates
1532       if (injected[n].may_be_java) {
1533         const Symbol* const name      = injected[n].name();
1534         const Symbol* const signature = injected[n].signature();
1535         bool duplicate = false;
1536         for (int i = 0; i < length; i++) {
1537           const FieldInfo* const f = _temp_field_info->adr_at(i);
1538           if (name      == cp->symbol_at(f->name_index()) &&
1539               signature == cp->symbol_at(f->signature_index())) {
1540             // Symbol is desclared in Java so skip this one
1541             duplicate = true;
1542             break;
1543           }
1544         }
1545         if (duplicate) {
1546           // These will be removed from the field array at the end
1547           continue;
1548         }
1549       }
1550 
1551       // Injected field
1552       FieldInfo::FieldFlags fflags(0);
1553       fflags.update_injected(true);
1554       AccessFlags aflags;
1555       FieldInfo fi(aflags, (u2)(injected[n].name_index), (u2)(injected[n].signature_index), 0, fflags);
1556       int idx = _temp_field_info->append(fi);
1557       _temp_field_info->adr_at(idx)->set_index(idx);

1558     }
1559   }
1560 
1561   if (is_inline_type) {
1562     // Inject static ".null_reset" field. This is an all-zero value with its null-channel set to zero.
1563     // IT should never be seen by user code, it is used when writing "null" to a nullable flat field
1564     // The all-zero value ensure that any embedded oop will be set to null, to avoid keeping dead objects
1565     // alive.
1566     FieldInfo::FieldFlags fflags2(0);
1567     fflags2.update_injected(true);
1568     AccessFlags aflags2(JVM_ACC_STATIC);
1569     FieldInfo fi2(aflags2,
1570                  (u2)vmSymbols::as_int(VM_SYMBOL_ENUM_NAME(null_reset_value_name)),
1571                  (u2)vmSymbols::as_int(VM_SYMBOL_ENUM_NAME(object_signature)),
1572                  0,
1573                  fflags2);
1574     int idx2 = _temp_field_info->append(fi2);
1575     _temp_field_info->adr_at(idx2)->set_index(idx2);
1576     _static_oop_count++;
1577   }
1578 
1579   if (_need_verify && length > 1) {
1580     // Check duplicated fields
1581     ResourceMark rm(THREAD);
1582     // Set containing name-signature pairs
1583     NameSigHashtable* names_and_sigs = new NameSigHashtable();
1584     for (int i = 0; i < _temp_field_info->length(); i++) {
1585       NameSigHash name_and_sig(_temp_field_info->adr_at(i)->name(_cp),
1586                                _temp_field_info->adr_at(i)->signature(_cp));
1587       // If no duplicates, add name/signature in hashtable names_and_sigs.
1588       if(!names_and_sigs->put(name_and_sig, 0)) {
1589         classfile_parse_error("Duplicate field name \"%s\" with signature \"%s\" in class file %s",
1590                                name_and_sig._name->as_C_string(), name_and_sig._sig->as_klass_external_name(), THREAD);
1591         return;
1592       }
1593     }
1594   }
1595 }
1596 
1597 

1937     }
1938     case VM_SYMBOL_ENUM_NAME(jdk_internal_vm_annotation_Contended_signature): {
1939       if (_location != _in_field && _location != _in_class) {
1940         break;  // only allow for fields and classes
1941       }
1942       if (!EnableContended || (RestrictContended && !privileged)) {
1943         break;  // honor privileges
1944       }
1945       return _jdk_internal_vm_annotation_Contended;
1946     }
1947     case VM_SYMBOL_ENUM_NAME(jdk_internal_vm_annotation_ReservedStackAccess_signature): {
1948       if (_location != _in_method)  break;  // only allow for methods
1949       if (RestrictReservedStack && !privileged) break; // honor privileges
1950       return _jdk_internal_vm_annotation_ReservedStackAccess;
1951     }
1952     case VM_SYMBOL_ENUM_NAME(jdk_internal_ValueBased_signature): {
1953       if (_location != _in_class)   break;  // only allow for classes
1954       if (!privileged)              break;  // only allow in privileged code
1955       return _jdk_internal_ValueBased;
1956     }
1957     case VM_SYMBOL_ENUM_NAME(jdk_internal_vm_annotation_LooselyConsistentValue_signature): {
1958       if (_location != _in_class)   break; // only allow for classes
1959       return _jdk_internal_LooselyConsistentValue;
1960     }
1961     case VM_SYMBOL_ENUM_NAME(jdk_internal_vm_annotation_NullRestricted_signature): {
1962       if (_location != _in_field)   break; // only allow for fields
1963       return _jdk_internal_NullRestricted;
1964     }
1965     case VM_SYMBOL_ENUM_NAME(java_lang_Deprecated): {
1966       return _java_lang_Deprecated;
1967     }
1968     case VM_SYMBOL_ENUM_NAME(jdk_internal_vm_annotation_AOTSafeClassInitializer_signature): {
1969       if (_location != _in_class)   break;  // only allow for classes
1970       if (!privileged)              break;  // only allow in privileged code
1971       return _jdk_internal_vm_annotation_AOTSafeClassInitializer;
1972     }
1973     case VM_SYMBOL_ENUM_NAME(jdk_internal_vm_annotation_AOTRuntimeSetup_signature): {
1974       if (_location != _in_method)  break;  // only allow for methods
1975       if (!privileged)              break;  // only allow in privileged code
1976       return _method_AOTRuntimeSetup;
1977     }
1978     default: {
1979       break;
1980     }
1981   }
1982   return AnnotationCollector::_unknown;
1983 }
1984 

2181   }
2182 
2183   if (runtime_visible_type_annotations_length > 0) {
2184     a = allocate_annotations(runtime_visible_type_annotations,
2185                              runtime_visible_type_annotations_length,
2186                              CHECK);
2187     cm->set_type_annotations(a);
2188   }
2189 }
2190 
2191 
2192 // Note: the parse_method below is big and clunky because all parsing of the code and exceptions
2193 // attribute is inlined. This is cumbersome to avoid since we inline most of the parts in the
2194 // Method* to save footprint, so we only know the size of the resulting Method* when the
2195 // entire method attribute is parsed.
2196 //
2197 // The has_localvariable_table parameter is used to pass up the value to InstanceKlass.
2198 
2199 Method* ClassFileParser::parse_method(const ClassFileStream* const cfs,
2200                                       bool is_interface,
2201                                       bool is_value_class,
2202                                       bool is_abstract_class,
2203                                       const ConstantPool* cp,
2204                                       bool* const has_localvariable_table,
2205                                       TRAPS) {
2206   assert(cfs != nullptr, "invariant");
2207   assert(cp != nullptr, "invariant");
2208   assert(has_localvariable_table != nullptr, "invariant");
2209 
2210   ResourceMark rm(THREAD);
2211   // Parse fixed parts:
2212   // access_flags, name_index, descriptor_index, attributes_count
2213   cfs->guarantee_more(8, CHECK_NULL);
2214 
2215   u2 flags = cfs->get_u2_fast();
2216   const u2 name_index = cfs->get_u2_fast();
2217   const int cp_size = cp->length();
2218   guarantee_property(
2219     valid_symbol_at(name_index),
2220     "Illegal constant pool index %u for method name in class file %s",
2221     name_index, CHECK_NULL);
2222   const Symbol* const name = cp->symbol_at(name_index);

2224 
2225   const u2 signature_index = cfs->get_u2_fast();
2226   guarantee_property(
2227     valid_symbol_at(signature_index),
2228     "Illegal constant pool index %u for method signature in class file %s",
2229     signature_index, CHECK_NULL);
2230   const Symbol* const signature = cp->symbol_at(signature_index);
2231 
2232   if (name == vmSymbols::class_initializer_name()) {
2233     // We ignore the other access flags for a valid class initializer.
2234     // (JVM Spec 2nd ed., chapter 4.6)
2235     if (_major_version < 51) { // backward compatibility
2236       flags = JVM_ACC_STATIC;
2237     } else if ((flags & JVM_ACC_STATIC) == JVM_ACC_STATIC) {
2238       flags &= JVM_ACC_STATIC | (_major_version <= JAVA_16_VERSION ? JVM_ACC_STRICT : 0);
2239     } else {
2240       classfile_parse_error("Method <clinit> is not static in class file %s", THREAD);
2241       return nullptr;
2242     }
2243   } else {
2244     verify_legal_method_modifiers(flags, access_flags() , name, CHECK_NULL);
2245   }
2246 
2247   if (name == vmSymbols::object_initializer_name() && is_interface) {
2248     classfile_parse_error("Interface cannot have a method named <init>, class file %s", THREAD);
2249     return nullptr;
2250   }
2251 
2252   if (EnableValhalla) {
2253     if (((flags & JVM_ACC_SYNCHRONIZED) == JVM_ACC_SYNCHRONIZED)
2254         && ((flags & JVM_ACC_STATIC) == 0 )
2255         && !_access_flags.is_identity_class()) {
2256       classfile_parse_error("Invalid synchronized method in non-identity class %s", THREAD);
2257         return nullptr;
2258     }
2259   }
2260 
2261   int args_size = -1;  // only used when _need_verify is true
2262   if (_need_verify) {
2263     verify_legal_name_with_signature(name, signature, CHECK_NULL);
2264     args_size = ((flags & JVM_ACC_STATIC) ? 0 : 1) +
2265                  verify_legal_method_signature(name, signature, CHECK_NULL);
2266     if (args_size > MAX_ARGS_SIZE) {
2267       classfile_parse_error("Too many arguments in method signature in class file %s", THREAD);
2268       return nullptr;
2269     }
2270   }
2271 
2272   AccessFlags access_flags(flags & JVM_RECOGNIZED_METHOD_MODIFIERS);
2273 
2274   // Default values for code and exceptions attribute elements
2275   u2 max_stack = 0;
2276   u2 max_locals = 0;
2277   u4 code_length = 0;
2278   const u1* code_start = nullptr;
2279   u2 exception_table_length = 0;
2280   const unsafe_u2* exception_table_start = nullptr; // (potentially unaligned) pointer to array of u2 elements

2775                           CHECK_NULL);
2776 
2777   if (InstanceKlass::is_finalization_enabled() &&
2778       name == vmSymbols::finalize_method_name() &&
2779       signature == vmSymbols::void_method_signature()) {
2780     if (m->is_empty_method()) {
2781       _has_empty_finalizer = true;
2782     } else {
2783       _has_finalizer = true;
2784     }
2785   }
2786 
2787   NOT_PRODUCT(m->verify());
2788   return m;
2789 }
2790 
2791 
2792 // Side-effects: populates the _methods field in the parser
2793 void ClassFileParser::parse_methods(const ClassFileStream* const cfs,
2794                                     bool is_interface,
2795                                     bool is_value_class,
2796                                     bool is_abstract_type,
2797                                     bool* const has_localvariable_table,
2798                                     bool* has_final_method,
2799                                     bool* declares_nonstatic_concrete_methods,
2800                                     TRAPS) {
2801   assert(cfs != nullptr, "invariant");
2802   assert(has_localvariable_table != nullptr, "invariant");
2803   assert(has_final_method != nullptr, "invariant");
2804   assert(declares_nonstatic_concrete_methods != nullptr, "invariant");
2805 
2806   assert(nullptr == _methods, "invariant");
2807 
2808   cfs->guarantee_more(2, CHECK);  // length
2809   const u2 length = cfs->get_u2_fast();
2810   if (length == 0) {
2811     _methods = Universe::the_empty_method_array();
2812   } else {
2813     _methods = MetadataFactory::new_array<Method*>(_loader_data,
2814                                                    length,
2815                                                    nullptr,
2816                                                    CHECK);
2817 
2818     for (int index = 0; index < length; index++) {
2819       Method* method = parse_method(cfs,
2820                                     is_interface,
2821                                     is_value_class,
2822                                     is_abstract_type,
2823                                     _cp,
2824                                     has_localvariable_table,
2825                                     CHECK);
2826 
2827       if (method->is_final()) {
2828         *has_final_method = true;
2829       }
2830       // declares_nonstatic_concrete_methods: declares concrete instance methods, any access flags
2831       // used for interface initialization, and default method inheritance analysis
2832       if (is_interface && !(*declares_nonstatic_concrete_methods)
2833         && !method->is_abstract() && !method->is_static()) {
2834         *declares_nonstatic_concrete_methods = true;
2835       }
2836       _methods->at_put(index, method);
2837     }
2838 
2839     if (_need_verify && length > 1) {
2840       // Check duplicated methods
2841       ResourceMark rm(THREAD);
2842       // Set containing name-signature pairs

3068         valid_klass_reference_at(outer_class_info_index),
3069       "outer_class_info_index %u has bad constant type in class file %s",
3070       outer_class_info_index, CHECK_0);
3071 
3072     if (outer_class_info_index != 0) {
3073       const Symbol* const outer_class_name = cp->klass_name_at(outer_class_info_index);
3074       char* bytes = (char*)outer_class_name->bytes();
3075       guarantee_property(bytes[0] != JVM_SIGNATURE_ARRAY,
3076                          "Outer class is an array class in class file %s", CHECK_0);
3077     }
3078     // Inner class name
3079     const u2 inner_name_index = cfs->get_u2_fast();
3080     guarantee_property(
3081       inner_name_index == 0 || valid_symbol_at(inner_name_index),
3082       "inner_name_index %u has bad constant type in class file %s",
3083       inner_name_index, CHECK_0);
3084     if (_need_verify) {
3085       guarantee_property(inner_class_info_index != outer_class_info_index,
3086                          "Class is both outer and inner class in class file %s", CHECK_0);
3087     }
3088 
3089     // Access flags
3090     u2 flags;
3091     // JVM_ACC_MODULE is defined in JDK-9 and later.
3092     if (_major_version >= JAVA_9_VERSION) {
3093       flags = cfs->get_u2_fast() & (RECOGNIZED_INNER_CLASS_MODIFIERS | JVM_ACC_MODULE);
3094     } else {
3095       flags = cfs->get_u2_fast() & RECOGNIZED_INNER_CLASS_MODIFIERS;
3096     }
3097 
3098     if ((flags & JVM_ACC_INTERFACE) && _major_version < JAVA_6_VERSION) {
3099       // Set abstract bit for old class files for backward compatibility
3100       flags |= JVM_ACC_ABSTRACT;
3101     }
3102 
3103     if (!supports_inline_types()) {
3104       const bool is_module = (flags & JVM_ACC_MODULE) != 0;
3105       const bool is_interface = (flags & JVM_ACC_INTERFACE) != 0;
3106       if (!is_module && !is_interface) {
3107         flags |= JVM_ACC_IDENTITY;
3108       }
3109     }
3110 
3111     Symbol* inner_name_symbol = inner_name_index == 0 ? nullptr : cp->symbol_at(inner_name_index);
3112     verify_legal_class_modifiers(flags, inner_name_symbol, inner_name_index == 0, CHECK_0);
3113     AccessFlags inner_access_flags(flags);
3114 
3115     inner_classes->at_put(index++, inner_class_info_index);
3116     inner_classes->at_put(index++, outer_class_info_index);
3117     inner_classes->at_put(index++, inner_name_index);
3118     inner_classes->at_put(index++, inner_access_flags.as_unsigned_short());
3119   }
3120 
3121   // Check for circular and duplicate entries.
3122   bool has_circularity = false;
3123   if (_need_verify) {
3124     has_circularity = check_inner_classes_circularity(cp, length * 4, CHECK_0);
3125     if (has_circularity) {
3126       // If circularity check failed then ignore InnerClasses attribute.
3127       MetadataFactory::free_array<u2>(_loader_data, _inner_classes);
3128       index = 0;
3129       if (parsed_enclosingmethod_attribute) {
3130         inner_classes = MetadataFactory::new_array<u2>(_loader_data, 2, CHECK_0);

3196   if (length > 0) {
3197     int index = 0;
3198     cfs->guarantee_more(2 * length, CHECK_0);
3199     for (int n = 0; n < length; n++) {
3200       const u2 class_info_index = cfs->get_u2_fast();
3201       guarantee_property(
3202         valid_klass_reference_at(class_info_index),
3203         "Permitted subclass class_info_index %u has bad constant type in class file %s",
3204         class_info_index, CHECK_0);
3205       permitted_subclasses->at_put(index++, class_info_index);
3206     }
3207     assert(index == size, "wrong size");
3208   }
3209 
3210   // Restore buffer's current position.
3211   cfs->set_current(current_mark);
3212 
3213   return length;
3214 }
3215 
3216 u2 ClassFileParser::parse_classfile_loadable_descriptors_attribute(const ClassFileStream* const cfs,
3217                                                                    const u1* const loadable_descriptors_attribute_start,
3218                                                                    TRAPS) {
3219   const u1* const current_mark = cfs->current();
3220   u2 length = 0;
3221   if (loadable_descriptors_attribute_start != nullptr) {
3222     cfs->set_current(loadable_descriptors_attribute_start);
3223     cfs->guarantee_more(2, CHECK_0);  // length
3224     length = cfs->get_u2_fast();
3225   }
3226   const int size = length;
3227   Array<u2>* const loadable_descriptors = MetadataFactory::new_array<u2>(_loader_data, size, CHECK_0);
3228   _loadable_descriptors = loadable_descriptors;
3229   if (length > 0) {
3230     int index = 0;
3231     cfs->guarantee_more(2 * length, CHECK_0);
3232     for (int n = 0; n < length; n++) {
3233       const u2 descriptor_index = cfs->get_u2_fast();
3234       guarantee_property(
3235         valid_symbol_at(descriptor_index),
3236         "LoadableDescriptors descriptor_index %u has bad constant type in class file %s",
3237         descriptor_index, CHECK_0);
3238       Symbol* descriptor = _cp->symbol_at(descriptor_index);
3239       bool valid = legal_field_signature(descriptor, CHECK_0);
3240       if(!valid) {
3241         ResourceMark rm(THREAD);
3242         Exceptions::fthrow(THREAD_AND_LOCATION,
3243           vmSymbols::java_lang_ClassFormatError(),
3244           "Descriptor from LoadableDescriptors attribute at index \"%d\" in class %s has illegal signature \"%s\"",
3245           descriptor_index, _class_name->as_C_string(), descriptor->as_C_string());
3246         return 0;
3247       }
3248       loadable_descriptors->at_put(index++, descriptor_index);
3249     }
3250     assert(index == size, "wrong size");
3251   }
3252 
3253   // Restore buffer's current position.
3254   cfs->set_current(current_mark);
3255 
3256   return length;
3257 }
3258 
3259 //  Record {
3260 //    u2 attribute_name_index;
3261 //    u4 attribute_length;
3262 //    u2 components_count;
3263 //    component_info components[components_count];
3264 //  }
3265 //  component_info {
3266 //    u2 name_index;
3267 //    u2 descriptor_index
3268 //    u2 attributes_count;
3269 //    attribute_info_attributes[attributes_count];
3270 //  }
3271 u4 ClassFileParser::parse_classfile_record_attribute(const ClassFileStream* const cfs,
3272                                                      const ConstantPool* cp,
3273                                                      const u1* const record_attribute_start,
3274                                                      TRAPS) {
3275   const u1* const current_mark = cfs->current();
3276   int components_count = 0;
3277   unsigned int calculate_attr_size = 0;
3278   if (record_attribute_start != nullptr) {

3504   }
3505   guarantee_property(current_start + attribute_byte_length == cfs->current(),
3506                      "Bad length on BootstrapMethods in class file %s",
3507                      CHECK);
3508 }
3509 
3510 void ClassFileParser::parse_classfile_attributes(const ClassFileStream* const cfs,
3511                                                  ConstantPool* cp,
3512                  ClassFileParser::ClassAnnotationCollector* parsed_annotations,
3513                                                  TRAPS) {
3514   assert(cfs != nullptr, "invariant");
3515   assert(cp != nullptr, "invariant");
3516   assert(parsed_annotations != nullptr, "invariant");
3517 
3518   // Set inner classes attribute to default sentinel
3519   _inner_classes = Universe::the_empty_short_array();
3520   // Set nest members attribute to default sentinel
3521   _nest_members = Universe::the_empty_short_array();
3522   // Set _permitted_subclasses attribute to default sentinel
3523   _permitted_subclasses = Universe::the_empty_short_array();
3524   // Set _loadable_descriptors attribute to default sentinel
3525   _loadable_descriptors = Universe::the_empty_short_array();
3526   cfs->guarantee_more(2, CHECK);  // attributes_count
3527   u2 attributes_count = cfs->get_u2_fast();
3528   bool parsed_sourcefile_attribute = false;
3529   bool parsed_innerclasses_attribute = false;
3530   bool parsed_nest_members_attribute = false;
3531   bool parsed_permitted_subclasses_attribute = false;
3532   bool parsed_loadable_descriptors_attribute = false;
3533   bool parsed_nest_host_attribute = false;
3534   bool parsed_record_attribute = false;
3535   bool parsed_enclosingmethod_attribute = false;
3536   bool parsed_bootstrap_methods_attribute = false;
3537   const u1* runtime_visible_annotations = nullptr;
3538   int runtime_visible_annotations_length = 0;
3539   const u1* runtime_visible_type_annotations = nullptr;
3540   int runtime_visible_type_annotations_length = 0;
3541   bool runtime_invisible_type_annotations_exists = false;
3542   bool runtime_invisible_annotations_exists = false;
3543   bool parsed_source_debug_ext_annotations_exist = false;
3544   const u1* inner_classes_attribute_start = nullptr;
3545   u4  inner_classes_attribute_length = 0;
3546   u2  enclosing_method_class_index = 0;
3547   u2  enclosing_method_method_index = 0;
3548   const u1* nest_members_attribute_start = nullptr;
3549   u4  nest_members_attribute_length = 0;
3550   const u1* record_attribute_start = nullptr;
3551   u4  record_attribute_length = 0;
3552   const u1* permitted_subclasses_attribute_start = nullptr;
3553   u4  permitted_subclasses_attribute_length = 0;
3554   const u1* loadable_descriptors_attribute_start = nullptr;
3555   u4  loadable_descriptors_attribute_length = 0;
3556 
3557   // Iterate over attributes
3558   while (attributes_count--) {
3559     cfs->guarantee_more(6, CHECK);  // attribute_name_index, attribute_length
3560     const u2 attribute_name_index = cfs->get_u2_fast();
3561     const u4 attribute_length = cfs->get_u4_fast();
3562     guarantee_property(
3563       valid_symbol_at(attribute_name_index),
3564       "Attribute name has bad constant pool index %u in class file %s",
3565       attribute_name_index, CHECK);
3566     const Symbol* const tag = cp->symbol_at(attribute_name_index);
3567     if (tag == vmSymbols::tag_source_file()) {
3568       // Check for SourceFile tag
3569       if (_need_verify) {
3570         guarantee_property(attribute_length == 2, "Wrong SourceFile attribute length in class file %s", CHECK);
3571       }
3572       if (parsed_sourcefile_attribute) {
3573         classfile_parse_error("Multiple SourceFile attributes in class file %s", THREAD);
3574         return;
3575       } else {

3751               return;
3752             }
3753             parsed_record_attribute = true;
3754             record_attribute_start = cfs->current();
3755             record_attribute_length = attribute_length;
3756           } else if (_major_version >= JAVA_17_VERSION) {
3757             if (tag == vmSymbols::tag_permitted_subclasses()) {
3758               if (parsed_permitted_subclasses_attribute) {
3759                 classfile_parse_error("Multiple PermittedSubclasses attributes in class file %s", CHECK);
3760                 return;
3761               }
3762               // Classes marked ACC_FINAL cannot have a PermittedSubclasses attribute.
3763               if (_access_flags.is_final()) {
3764                 classfile_parse_error("PermittedSubclasses attribute in final class file %s", CHECK);
3765                 return;
3766               }
3767               parsed_permitted_subclasses_attribute = true;
3768               permitted_subclasses_attribute_start = cfs->current();
3769               permitted_subclasses_attribute_length = attribute_length;
3770             }
3771             if (EnableValhalla && tag == vmSymbols::tag_loadable_descriptors()) {
3772               if (parsed_loadable_descriptors_attribute) {
3773                 classfile_parse_error("Multiple LoadableDescriptors attributes in class file %s", CHECK);
3774                 return;
3775               }
3776               parsed_loadable_descriptors_attribute = true;
3777               loadable_descriptors_attribute_start = cfs->current();
3778               loadable_descriptors_attribute_length = attribute_length;
3779             }
3780           }
3781           // Skip attribute_length for any attribute where major_verson >= JAVA_17_VERSION
3782           cfs->skip_u1(attribute_length, CHECK);
3783         } else {
3784           // Unknown attribute
3785           cfs->skip_u1(attribute_length, CHECK);
3786         }
3787       } else {
3788         // Unknown attribute
3789         cfs->skip_u1(attribute_length, CHECK);
3790       }
3791     } else {
3792       // Unknown attribute
3793       cfs->skip_u1(attribute_length, CHECK);
3794     }
3795   }
3796   _class_annotations = allocate_annotations(runtime_visible_annotations,
3797                                             runtime_visible_annotations_length,
3798                                             CHECK);
3799   _class_type_annotations = allocate_annotations(runtime_visible_type_annotations,

3836                             CHECK);
3837     if (_need_verify) {
3838       guarantee_property(record_attribute_length == calculated_attr_length,
3839                          "Record attribute has wrong length in class file %s",
3840                          CHECK);
3841     }
3842   }
3843 
3844   if (parsed_permitted_subclasses_attribute) {
3845     const u2 num_subclasses = parse_classfile_permitted_subclasses_attribute(
3846                             cfs,
3847                             permitted_subclasses_attribute_start,
3848                             CHECK);
3849     if (_need_verify) {
3850       guarantee_property(
3851         permitted_subclasses_attribute_length == sizeof(num_subclasses) + sizeof(u2) * num_subclasses,
3852         "Wrong PermittedSubclasses attribute length in class file %s", CHECK);
3853     }
3854   }
3855 
3856   if (parsed_loadable_descriptors_attribute) {
3857     const u2 num_classes = parse_classfile_loadable_descriptors_attribute(
3858                             cfs,
3859                             loadable_descriptors_attribute_start,
3860                             CHECK);
3861     if (_need_verify) {
3862       guarantee_property(
3863         loadable_descriptors_attribute_length == sizeof(num_classes) + sizeof(u2) * num_classes,
3864         "Wrong LoadableDescriptors attribute length in class file %s", CHECK);
3865     }
3866   }
3867 
3868   if (_max_bootstrap_specifier_index >= 0) {
3869     guarantee_property(parsed_bootstrap_methods_attribute,
3870                        "Missing BootstrapMethods attribute in class file %s", CHECK);
3871   }
3872 }
3873 
3874 void ClassFileParser::apply_parsed_class_attributes(InstanceKlass* k) {
3875   assert(k != nullptr, "invariant");
3876 
3877   if (_synthetic_flag)
3878     k->set_is_synthetic();
3879   if (_sourcefile_index != 0) {
3880     k->set_source_file_name_index(_sourcefile_index);
3881   }
3882   if (_generic_signature_index != 0) {
3883     k->set_generic_signature_index(_generic_signature_index);
3884   }
3885   if (_sde_buffer != nullptr) {
3886     k->set_source_debug_extension(_sde_buffer, _sde_length);
3887   }

3914     _class_type_annotations  = nullptr;
3915     _fields_annotations      = nullptr;
3916     _fields_type_annotations = nullptr;
3917 }
3918 
3919 // Transfer ownership of metadata allocated to the InstanceKlass.
3920 void ClassFileParser::apply_parsed_class_metadata(
3921                                             InstanceKlass* this_klass,
3922                                             int java_fields_count) {
3923   assert(this_klass != nullptr, "invariant");
3924 
3925   _cp->set_pool_holder(this_klass);
3926   this_klass->set_constants(_cp);
3927   this_klass->set_fieldinfo_stream(_fieldinfo_stream);
3928   this_klass->set_fieldinfo_search_table(_fieldinfo_search_table);
3929   this_klass->set_fields_status(_fields_status);
3930   this_klass->set_methods(_methods);
3931   this_klass->set_inner_classes(_inner_classes);
3932   this_klass->set_nest_members(_nest_members);
3933   this_klass->set_nest_host_index(_nest_host);
3934   this_klass->set_loadable_descriptors(_loadable_descriptors);
3935   this_klass->set_annotations(_combined_annotations);
3936   this_klass->set_permitted_subclasses(_permitted_subclasses);
3937   this_klass->set_record_components(_record_components);
3938   this_klass->set_inline_layout_info_array(_inline_layout_info_array);
3939 
3940   DEBUG_ONLY(FieldInfoStream::validate_search_table(_cp, _fieldinfo_stream, _fieldinfo_search_table));
3941 
3942   // Delay the setting of _local_interfaces and _transitive_interfaces until after
3943   // initialize_supers() in fill_instance_klass(). It is because the _local_interfaces could
3944   // be shared with _transitive_interfaces and _transitive_interfaces may be shared with
3945   // its _super. If an OOM occurs while loading the current klass, its _super field
3946   // may not have been set. When GC tries to free the klass, the _transitive_interfaces
3947   // may be deallocated mistakenly in InstanceKlass::deallocate_interfaces(). Subsequent
3948   // dereferences to the deallocated _transitive_interfaces will result in a crash.
3949 
3950   // Clear out these fields so they don't get deallocated by the destructor
3951   clear_class_metadata();
3952 }
3953 
3954 AnnotationArray* ClassFileParser::allocate_annotations(const u1* const anno,
3955                                                        int anno_length,
3956                                                        TRAPS) {
3957   AnnotationArray* annotations = nullptr;
3958   if (anno != nullptr) {
3959     annotations = MetadataFactory::new_array<u1>(_loader_data,
3960                                                  anno_length,
3961                                                  CHECK_(annotations));
3962     for (int i = 0; i < anno_length; i++) {
3963       annotations->at_put(i, anno[i]);
3964     }
3965   }
3966   return annotations;
3967 }
3968 
3969 void ClassFileParser::check_super_class(ConstantPool* const cp,
3970                                         const int super_class_index,
3971                                         const bool need_verify,
3972                                         TRAPS) {
3973   assert(cp != nullptr, "invariant");
3974 
3975   if (super_class_index == 0) {
3976     guarantee_property(_class_name == vmSymbols::java_lang_Object(),
3977                        "Invalid superclass index 0 in class file %s",

3978                        CHECK);
3979   } else {
3980     guarantee_property(valid_klass_reference_at(super_class_index),
3981                        "Invalid superclass index %u in class file %s",
3982                        super_class_index,
3983                        CHECK);
3984 
3985     // The class name should be legal because it is checked when parsing constant pool.
3986     // However, make sure it is not an array type.
3987     if (need_verify) {
3988       guarantee_property(cp->klass_name_at(super_class_index)->char_at(0) != JVM_SIGNATURE_ARRAY,
3989                         "Bad superclass name in class file %s", CHECK);
3990     }
3991   }
3992 }
3993 
3994 OopMapBlocksBuilder::OopMapBlocksBuilder(unsigned int max_blocks) {
3995   _max_nonstatic_oop_maps = max_blocks;
3996   _nonstatic_oop_map_count = 0;
3997   if (max_blocks == 0) {

4149   // See documentation of InstanceKlass::can_be_fastpath_allocated().
4150   assert(ik->size_helper() > 0, "layout_helper is initialized");
4151   if (ik->is_abstract() || ik->is_interface()
4152       || (ik->name() == vmSymbols::java_lang_Class() && ik->class_loader() == nullptr)
4153       || ik->size_helper() >= FastAllocateSizeLimit) {
4154     // Forbid fast-path allocation.
4155     const jint lh = Klass::instance_layout_helper(ik->size_helper(), true);
4156     ik->set_layout_helper(lh);
4157   }
4158 
4159   // Propagate the AOT runtimeSetup method discovery
4160   if (_has_aot_runtime_setup_method) {
4161     ik->set_is_runtime_setup_required();
4162     if (log_is_enabled(Info, aot, init)) {
4163       ResourceMark rm;
4164       log_info(aot, init)("Found @AOTRuntimeSetup class %s", ik->external_name());
4165     }
4166   }
4167 }
4168 
4169 bool ClassFileParser::supports_inline_types() const {
4170   // Inline types are only supported by class file version 70.65535 and later
4171   return _major_version > JAVA_26_VERSION ||
4172          (_major_version == JAVA_26_VERSION && _minor_version == JAVA_PREVIEW_MINOR_VERSION);
4173 }
4174 
4175 // utility methods for appending an array with check for duplicates
4176 
4177 static void append_interfaces(GrowableArray<InstanceKlass*>* result,
4178                               const Array<InstanceKlass*>* const ifs) {
4179   // iterate over new interfaces
4180   for (int i = 0; i < ifs->length(); i++) {
4181     InstanceKlass* const e = ifs->at(i);
4182     assert(e->is_klass() && e->is_interface(), "just checking");
4183     // add new interface
4184     result->append_if_missing(e);
4185   }
4186 }
4187 
4188 static Array<InstanceKlass*>* compute_transitive_interfaces(const InstanceKlass* super,
4189                                                             Array<InstanceKlass*>* local_ifs,
4190                                                             ClassLoaderData* loader_data,
4191                                                             TRAPS) {
4192   assert(local_ifs != nullptr, "invariant");
4193   assert(loader_data != nullptr, "invariant");
4194 

4198   // Add superclass transitive interfaces size
4199   if (super != nullptr) {
4200     super_size = super->transitive_interfaces()->length();
4201     max_transitive_size += super_size;
4202   }
4203   // Add local interfaces' super interfaces
4204   const int local_size = local_ifs->length();
4205   for (int i = 0; i < local_size; i++) {
4206     InstanceKlass* const l = local_ifs->at(i);
4207     max_transitive_size += l->transitive_interfaces()->length();
4208   }
4209   // Finally add local interfaces
4210   max_transitive_size += local_size;
4211   // Construct array
4212   if (max_transitive_size == 0) {
4213     // no interfaces, use canonicalized array
4214     return Universe::the_empty_instance_klass_array();
4215   } else if (max_transitive_size == super_size) {
4216     // no new local interfaces added, share superklass' transitive interface array
4217     return super->transitive_interfaces();
4218     // The three lines below are commented to work around bug JDK-8245487
4219 //  } else if (max_transitive_size == local_size) {
4220 //    // only local interfaces added, share local interface array
4221 //    return local_ifs;
4222   } else {
4223     ResourceMark rm;
4224     GrowableArray<InstanceKlass*>* const result = new GrowableArray<InstanceKlass*>(max_transitive_size);
4225 
4226     // Copy down from superclass
4227     if (super != nullptr) {
4228       append_interfaces(result, super->transitive_interfaces());
4229     }
4230 
4231     // Copy down from local interfaces' superinterfaces
4232     for (int i = 0; i < local_size; i++) {
4233       InstanceKlass* const l = local_ifs->at(i);
4234       append_interfaces(result, l->transitive_interfaces());
4235     }
4236     // Finally add local interfaces
4237     append_interfaces(result, local_ifs);
4238 
4239     // length will be less than the max_transitive_size if duplicates were removed
4240     const int length = result->length();
4241     assert(length <= max_transitive_size, "just checking");
4242 
4243     Array<InstanceKlass*>* const new_result =
4244       MetadataFactory::new_array<InstanceKlass*>(loader_data, length, CHECK_NULL);
4245     for (int i = 0; i < length; i++) {
4246       InstanceKlass* const e = result->at(i);
4247       assert(e != nullptr, "just checking");
4248       new_result->at_put(i, e);
4249     }
4250     return new_result;
4251   }
4252 }
4253 
4254 void ClassFileParser::check_super_class_access(const InstanceKlass* this_klass, TRAPS) {
4255   assert(this_klass != nullptr, "invariant");
4256   const InstanceKlass* const super = this_klass->super();
4257 
4258   if (super != nullptr) {
4259     if (super->is_final()) {
4260       classfile_icce_error("class %s cannot inherit from final class %s", super, THREAD);
4261       return;
4262     }
4263 
4264     if (super->is_sealed()) {
4265       stringStream ss;
4266       ResourceMark rm(THREAD);
4267       if (!super->has_as_permitted_subclass(this_klass, ss)) {
4268         classfile_icce_error(ss.as_string(), THREAD);
4269         return;
4270       }
4271     }
4272 
4273     // The JVMS says that super classes for value types must not have the ACC_IDENTITY
4274     // flag set. But, java.lang.Object must still be allowed to be a direct super class
4275     // for a value classes.  So, it is treated as a special case for now.
4276     if (!this_klass->access_flags().is_identity_class() &&
4277         super->name() != vmSymbols::java_lang_Object() &&
4278         super->is_identity_class()) {
4279       classfile_icce_error("value class %s cannot inherit from class %s", super, THREAD);
4280       return;
4281     }
4282 
4283     Reflection::VerifyClassAccessResults vca_result =
4284       Reflection::verify_class_access(this_klass, super, false);
4285     if (vca_result != Reflection::ACCESS_OK) {
4286       ResourceMark rm(THREAD);
4287       char* msg = Reflection::verify_class_access_msg(this_klass,
4288                                                       super,
4289                                                       vca_result);
4290 
4291       // Names are all known to be < 64k so we know this formatted message is not excessively large.
4292       if (msg == nullptr) {
4293         bool same_module = (this_klass->module() == super->module());
4294         Exceptions::fthrow(
4295           THREAD_AND_LOCATION,
4296           vmSymbols::java_lang_IllegalAccessError(),
4297           "class %s cannot access its %ssuperclass %s (%s%s%s)",
4298           this_klass->external_name(),
4299           super->is_abstract() ? "abstract " : "",
4300           super->external_name(),
4301           (same_module) ? this_klass->joint_in_module_of_loader(super) : this_klass->class_in_module_of_loader(),
4302           (same_module) ? "" : "; ",

4455 // Verify the class modifiers for the current class, or an inner class if inner_name is non-null.
4456 void ClassFileParser::verify_legal_class_modifiers(jint flags, Symbol* inner_name, bool is_anonymous_inner_class, TRAPS) const {
4457   const bool is_module = (flags & JVM_ACC_MODULE) != 0;
4458   assert(_major_version >= JAVA_9_VERSION || !is_module, "JVM_ACC_MODULE should not be set");
4459   if (is_module) {
4460     ResourceMark rm(THREAD);
4461     // Names are all known to be < 64k so we know this formatted message is not excessively large.
4462     Exceptions::fthrow(
4463       THREAD_AND_LOCATION,
4464       vmSymbols::java_lang_NoClassDefFoundError(),
4465       "%s is not a class because access_flag ACC_MODULE is set",
4466       _class_name->as_C_string());
4467     return;
4468   }
4469 
4470   if (!_need_verify) { return; }
4471 
4472   const bool is_interface  = (flags & JVM_ACC_INTERFACE)  != 0;
4473   const bool is_abstract   = (flags & JVM_ACC_ABSTRACT)   != 0;
4474   const bool is_final      = (flags & JVM_ACC_FINAL)      != 0;
4475   const bool is_identity   = (flags & JVM_ACC_IDENTITY)   != 0;
4476   const bool is_enum       = (flags & JVM_ACC_ENUM)       != 0;
4477   const bool is_annotation = (flags & JVM_ACC_ANNOTATION) != 0;
4478   const bool major_gte_1_5 = _major_version >= JAVA_1_5_VERSION;
4479   const bool valid_value_class = is_identity || is_interface ||
4480                                  (supports_inline_types() && (!is_identity && (is_abstract || is_final)));
4481 
4482   if ((is_abstract && is_final) ||
4483       (is_interface && !is_abstract) ||
4484       (is_interface && major_gte_1_5 && (is_identity || is_enum)) ||   //  ACC_SUPER (now ACC_IDENTITY) was illegal for interfaces
4485       (!is_interface && major_gte_1_5 && is_annotation) ||
4486       (!valid_value_class)) {
4487     ResourceMark rm(THREAD);
4488     const char* class_note = "";
4489     if (!valid_value_class) {
4490       class_note = " (a value class must be final or else abstract)";
4491     }
4492     // Names are all known to be < 64k so we know this formatted message is not excessively large.
4493     if (inner_name == nullptr && !is_anonymous_inner_class) {
4494       Exceptions::fthrow(
4495         THREAD_AND_LOCATION,
4496         vmSymbols::java_lang_ClassFormatError(),
4497         "Illegal class modifiers in class %s: 0x%X",
4498         _class_name->as_C_string(), flags
4499       );
4500     } else {
4501       if (is_anonymous_inner_class) {
4502         Exceptions::fthrow(
4503           THREAD_AND_LOCATION,
4504           vmSymbols::java_lang_ClassFormatError(),
4505           "Illegal class modifiers in anonymous inner class of class %s: 0x%X",
4506           _class_name->as_C_string(), flags
4507         );
4508       } else {
4509         Exceptions::fthrow(
4510           THREAD_AND_LOCATION,
4511           vmSymbols::java_lang_ClassFormatError(),

4565         THREAD_AND_LOCATION,
4566         vmSymbols::java_lang_UnsupportedClassVersionError(),
4567         "%s (class file version %u.%u) was compiled with preview features that are unsupported. "
4568         "This version of the Java Runtime only recognizes preview features for class file version %u.%u",
4569         class_name->as_C_string(), major, minor, JVM_CLASSFILE_MAJOR_VERSION, JAVA_PREVIEW_MINOR_VERSION);
4570       return;
4571     }
4572 
4573     if (!Arguments::enable_preview()) {
4574       classfile_ucve_error("Preview features are not enabled for %s (class file version %u.%u). Try running with '--enable-preview'",
4575                            class_name, major, minor, THREAD);
4576       return;
4577     }
4578 
4579   } else { // minor != JAVA_PREVIEW_MINOR_VERSION
4580     classfile_ucve_error("%s (class file version %u.%u) was compiled with an invalid non-zero minor version",
4581                          class_name, major, minor, THREAD);
4582   }
4583 }
4584 
4585 void ClassFileParser:: verify_legal_field_modifiers(jint flags,
4586                                                    AccessFlags class_access_flags,
4587                                                    TRAPS) const {
4588   if (!_need_verify) { return; }
4589 
4590   const bool is_public    = (flags & JVM_ACC_PUBLIC)    != 0;
4591   const bool is_protected = (flags & JVM_ACC_PROTECTED) != 0;
4592   const bool is_private   = (flags & JVM_ACC_PRIVATE)   != 0;
4593   const bool is_static    = (flags & JVM_ACC_STATIC)    != 0;
4594   const bool is_final     = (flags & JVM_ACC_FINAL)     != 0;
4595   const bool is_volatile  = (flags & JVM_ACC_VOLATILE)  != 0;
4596   const bool is_transient = (flags & JVM_ACC_TRANSIENT) != 0;
4597   const bool is_enum      = (flags & JVM_ACC_ENUM)      != 0;
4598   const bool is_strict    = (flags & JVM_ACC_STRICT)    != 0;
4599   const bool major_gte_1_5 = _major_version >= JAVA_1_5_VERSION;
4600 
4601   const bool is_interface = class_access_flags.is_interface();
4602   const bool is_identity_class = class_access_flags.is_identity_class();
4603 
4604   bool is_illegal = false;
4605   const char* error_msg = "";
4606 
4607   // There is some overlap in the checks that apply, for example interface fields
4608   // must be static, static fields can't be strict, and therefore interfaces can't
4609   // have strict fields. So we don't have to check every possible invalid combination
4610   // individually as long as all are covered. Once we have found an illegal combination
4611   // we can stop checking.
4612 
4613   if (!is_illegal) {
4614     if (is_interface) {
4615       if (!is_public || !is_static || !is_final || is_private ||
4616           is_protected || is_volatile || is_transient ||
4617           (major_gte_1_5 && is_enum)) {
4618         is_illegal = true;
4619         error_msg = "interface fields must be public, static and final, and may be synthetic";
4620       }
4621     } else { // not interface
4622       if (has_illegal_visibility(flags)) {
4623         is_illegal = true;
4624         error_msg = "invalid visibility flags for class field";
4625       } else if (is_final && is_volatile) {
4626         is_illegal = true;
4627         error_msg = "fields cannot be final and volatile";
4628       } else if (supports_inline_types()) {
4629         if (!is_identity_class && !is_static && (!is_strict || !is_final)) {
4630           is_illegal = true;
4631           error_msg = "value class fields must be either non-static final and strict, or static";
4632         }
4633       }
4634     }
4635   }
4636 
4637   if (is_illegal) {
4638     ResourceMark rm(THREAD);
4639     // Names are all known to be < 64k so we know this formatted message is not excessively large.
4640     Exceptions::fthrow(
4641       THREAD_AND_LOCATION,
4642       vmSymbols::java_lang_ClassFormatError(),
4643       "Illegal field modifiers (%s) in class %s: 0x%X",
4644       error_msg, _class_name->as_C_string(), flags);
4645     return;
4646   }
4647 }
4648 
4649 void ClassFileParser::verify_legal_method_modifiers(jint flags,
4650                                                     AccessFlags class_access_flags,
4651                                                     const Symbol* name,
4652                                                     TRAPS) const {
4653   if (!_need_verify) { return; }
4654 
4655   const bool is_public       = (flags & JVM_ACC_PUBLIC)       != 0;
4656   const bool is_private      = (flags & JVM_ACC_PRIVATE)      != 0;
4657   const bool is_static       = (flags & JVM_ACC_STATIC)       != 0;
4658   const bool is_final        = (flags & JVM_ACC_FINAL)        != 0;
4659   const bool is_native       = (flags & JVM_ACC_NATIVE)       != 0;
4660   const bool is_abstract     = (flags & JVM_ACC_ABSTRACT)     != 0;
4661   const bool is_bridge       = (flags & JVM_ACC_BRIDGE)       != 0;
4662   const bool is_strict       = (flags & JVM_ACC_STRICT)       != 0;
4663   const bool is_synchronized = (flags & JVM_ACC_SYNCHRONIZED) != 0;
4664   const bool is_protected    = (flags & JVM_ACC_PROTECTED)    != 0;
4665   const bool major_gte_1_5   = _major_version >= JAVA_1_5_VERSION;
4666   const bool major_gte_8     = _major_version >= JAVA_8_VERSION;
4667   const bool major_gte_17    = _major_version >= JAVA_17_VERSION;
4668   const bool is_initializer  = (name == vmSymbols::object_initializer_name());
4669   // LW401 CR required: removal of value factories support
4670   const bool is_interface    = class_access_flags.is_interface();
4671   const bool is_identity_class = class_access_flags.is_identity_class();
4672   const bool is_abstract_class = class_access_flags.is_abstract();
4673 
4674   bool is_illegal = false;
4675 
4676   const char* class_note = "";
4677   if (is_interface) {
4678     if (major_gte_8) {
4679       // Class file version is JAVA_8_VERSION or later Methods of
4680       // interfaces may set any of the flags except ACC_PROTECTED,
4681       // ACC_FINAL, ACC_NATIVE, and ACC_SYNCHRONIZED; they must
4682       // have exactly one of the ACC_PUBLIC or ACC_PRIVATE flags set.
4683       if ((is_public == is_private) || /* Only one of private and public should be true - XNOR */
4684           (is_native || is_protected || is_final || is_synchronized) ||
4685           // If a specific method of a class or interface has its
4686           // ACC_ABSTRACT flag set, it must not have any of its
4687           // ACC_FINAL, ACC_NATIVE, ACC_PRIVATE, ACC_STATIC,
4688           // ACC_STRICT, or ACC_SYNCHRONIZED flags set.  No need to
4689           // check for ACC_FINAL, ACC_NATIVE or ACC_SYNCHRONIZED as
4690           // those flags are illegal irrespective of ACC_ABSTRACT being set or not.
4691           (is_abstract && (is_private || is_static || (!major_gte_17 && is_strict)))) {
4692         is_illegal = true;
4693       }
4694     } else if (major_gte_1_5) {
4695       // Class file version in the interval [JAVA_1_5_VERSION, JAVA_8_VERSION)
4696       if (!is_public || is_private || is_protected || is_static || is_final ||
4697           is_synchronized || is_native || !is_abstract || is_strict) {
4698         is_illegal = true;
4699       }
4700     } else {
4701       // Class file version is pre-JAVA_1_5_VERSION
4702       if (!is_public || is_static || is_final || is_native || !is_abstract) {
4703         is_illegal = true;
4704       }
4705     }
4706   } else { // not interface
4707     if (has_illegal_visibility(flags)) {
4708       is_illegal = true;
4709     } else {
4710       if (is_initializer) {
4711         if (is_static || is_final || is_synchronized || is_native ||
4712             is_abstract || (major_gte_1_5 && is_bridge)) {
4713           is_illegal = true;
4714         }
4715       } else { // not initializer
4716         if (!is_identity_class && is_synchronized && !is_static) {
4717           is_illegal = true;
4718           class_note = " (not an identity class)";
4719         } else {
4720           if (is_abstract) {
4721             if ((is_final || is_native || is_private || is_static ||
4722                 (major_gte_1_5 && (is_synchronized || (!major_gte_17 && is_strict))))) {
4723               is_illegal = true;
4724             }
4725           }
4726         }
4727       }
4728     }
4729   }
4730 
4731   if (is_illegal) {
4732     ResourceMark rm(THREAD);
4733     // Names are all known to be < 64k so we know this formatted message is not excessively large.
4734     Exceptions::fthrow(
4735       THREAD_AND_LOCATION,
4736       vmSymbols::java_lang_ClassFormatError(),
4737       "Method %s in class %s%s has illegal modifiers: 0x%X",
4738       name->as_C_string(), _class_name->as_C_string(),
4739       class_note, flags);
4740     return;
4741   }
4742 }
4743 
4744 void ClassFileParser::verify_legal_utf8(const unsigned char* buffer,
4745                                         int length,
4746                                         TRAPS) const {
4747   assert(_need_verify, "only called when _need_verify is true");
4748   // Note: 0 <= length < 64K, as it comes from a u2 entry in the CP.
4749   if (!UTF8::is_legal_utf8(buffer, static_cast<size_t>(length), _major_version <= 47)) {
4750     classfile_parse_error("Illegal UTF8 string in constant pool in class file %s", THREAD);
4751   }
4752 }
4753 
4754 // Unqualified names may not contain the characters '.', ';', '[', or '/'.
4755 // In class names, '/' separates unqualified names.  This is verified in this function also.
4756 // Method names also may not contain the characters '<' or '>', unless <init>
4757 // or <clinit>.  Note that method names may not be <init> or <clinit> in this
4758 // method.  Because these names have been checked as special cases before
4759 // calling this method in verify_legal_method_name.

4777         if (type == ClassFileParser::LegalClass) {
4778           if (p == name || p+1 >= name+length ||
4779               *(p+1) == JVM_SIGNATURE_SLASH) {
4780             return false;
4781           }
4782         } else {
4783           return false;   // do not permit '/' unless it's class name
4784         }
4785         break;
4786       case JVM_SIGNATURE_SPECIAL:
4787       case JVM_SIGNATURE_ENDSPECIAL:
4788         // do not permit '<' or '>' in method names
4789         if (type == ClassFileParser::LegalMethod) {
4790           return false;
4791         }
4792     }
4793   }
4794   return true;
4795 }
4796 
4797 bool ClassFileParser::is_class_in_loadable_descriptors_attribute(Symbol *klass) {
4798   if (_loadable_descriptors == nullptr) return false;
4799   for (int i = 0; i < _loadable_descriptors->length(); i++) {
4800         Symbol* class_name = _cp->symbol_at(_loadable_descriptors->at(i));
4801         if (class_name == klass) return true;
4802   }
4803   return false;
4804 }
4805 
4806 // Take pointer to a UTF8 byte string (not NUL-terminated).
4807 // Skip over the longest part of the string that could
4808 // be taken as a fieldname. Allow non-trailing '/'s if slash_ok is true.
4809 // Return a pointer to just past the fieldname.
4810 // Return null if no fieldname at all was found, or in the case of slash_ok
4811 // being true, we saw consecutive slashes (meaning we were looking for a
4812 // qualified path but found something that was badly-formed).
4813 static const char* skip_over_field_name(const char* const name,
4814                                         bool slash_ok,
4815                                         unsigned int length) {
4816   const char* p;
4817   jboolean last_is_slash = false;
4818   jboolean not_first_ch = false;
4819 
4820   for (p = name; p != name + length; not_first_ch = true) {
4821     const char* old_p = p;
4822     jchar ch = *p;
4823     if (ch < 128) {
4824       p++;
4825       // quick check for ascii

4887 // be taken as a field signature. Allow "void" if void_ok.
4888 // Return a pointer to just past the signature.
4889 // Return null if no legal signature is found.
4890 const char* ClassFileParser::skip_over_field_signature(const char* signature,
4891                                                        bool void_ok,
4892                                                        unsigned int length,
4893                                                        TRAPS) const {
4894   unsigned int array_dim = 0;
4895   while (length > 0) {
4896     switch (signature[0]) {
4897     case JVM_SIGNATURE_VOID: if (!void_ok) { return nullptr; }
4898     case JVM_SIGNATURE_BOOLEAN:
4899     case JVM_SIGNATURE_BYTE:
4900     case JVM_SIGNATURE_CHAR:
4901     case JVM_SIGNATURE_SHORT:
4902     case JVM_SIGNATURE_INT:
4903     case JVM_SIGNATURE_FLOAT:
4904     case JVM_SIGNATURE_LONG:
4905     case JVM_SIGNATURE_DOUBLE:
4906       return signature + 1;
4907     case JVM_SIGNATURE_CLASS:
4908     {
4909       if (_major_version < JAVA_1_5_VERSION) {
4910         signature++;
4911         length--;
4912         // Skip over the class name if one is there
4913         const char* const p = skip_over_field_name(signature, true, length);
4914         assert(p == nullptr || p > signature, "must parse one character at least");
4915         // The next character better be a semicolon
4916         if (p != nullptr                             && // Parse of field name succeeded.
4917             p - signature < static_cast<int>(length) && // There is at least one character left to parse.
4918             p[0] == JVM_SIGNATURE_ENDCLASS) {
4919           return p + 1;
4920         }
4921       }
4922       else {
4923         // Skip leading 'L' or 'Q' and ignore first appearance of ';'
4924         signature++;
4925         const char* c = (const char*) memchr(signature, JVM_SIGNATURE_ENDCLASS, length - 1);
4926         // Format check signature
4927         if (c != nullptr) {
4928           int newlen = pointer_delta_as_int(c, (char*) signature);
4929           bool legal = verify_unqualified_name(signature, newlen, LegalClass);
4930           if (!legal) {
4931             classfile_parse_error("Class name is empty or contains illegal character "
4932                                   "in descriptor in class file %s",
4933                                   THREAD);
4934             return nullptr;
4935           }
4936           return signature + newlen + 1;
4937         }
4938       }
4939       return nullptr;
4940     }
4941     case JVM_SIGNATURE_ARRAY:
4942       array_dim++;
4943       if (array_dim > 255) {

4959 
4960 // Checks if name is a legal class name.
4961 void ClassFileParser::verify_legal_class_name(const Symbol* name, TRAPS) const {
4962   if (!_need_verify) { return; }
4963 
4964   assert(name->refcount() > 0, "symbol must be kept alive");
4965   char* bytes = (char*)name->bytes();
4966   unsigned int length = name->utf8_length();
4967   bool legal = false;
4968 
4969   if (length > 0) {
4970     const char* p;
4971     if (bytes[0] == JVM_SIGNATURE_ARRAY) {
4972       p = skip_over_field_signature(bytes, false, length, CHECK);
4973       legal = (p != nullptr) && ((p - bytes) == (int)length);
4974     } else if (_major_version < JAVA_1_5_VERSION) {
4975       if (bytes[0] != JVM_SIGNATURE_SPECIAL) {
4976         p = skip_over_field_name(bytes, true, length);
4977         legal = (p != nullptr) && ((p - bytes) == (int)length);
4978       }
4979     } else if ((_major_version >= CONSTANT_CLASS_DESCRIPTORS || _class_name->starts_with("jdk/internal/reflect/"))
4980                    && bytes[length - 1] == ';' ) {
4981       // Support for L...; descriptors
4982       legal = verify_unqualified_name(bytes + 1, length - 2, LegalClass);
4983     } else {
4984       // 4900761: relax the constraints based on JSR202 spec
4985       // Class names may be drawn from the entire Unicode character set.
4986       // Identifiers between '/' must be unqualified names.
4987       // The utf8 string has been verified when parsing cpool entries.
4988       legal = verify_unqualified_name(bytes, length, LegalClass);
4989     }
4990   }
4991   if (!legal) {
4992     ResourceMark rm(THREAD);
4993     assert(_class_name != nullptr, "invariant");
4994     // Names are all known to be < 64k so we know this formatted message is not excessively large.
4995     Exceptions::fthrow(
4996       THREAD_AND_LOCATION,
4997       vmSymbols::java_lang_ClassFormatError(),
4998       "Illegal class name \"%.*s\" in class file %s", length, bytes,
4999       _class_name->as_C_string()
5000     );
5001     return;
5002   }

5030       THREAD_AND_LOCATION,
5031       vmSymbols::java_lang_ClassFormatError(),
5032       "Illegal field name \"%.*s\" in class %s", length, bytes,
5033       _class_name->as_C_string()
5034     );
5035     return;
5036   }
5037 }
5038 
5039 // Checks if name is a legal method name.
5040 void ClassFileParser::verify_legal_method_name(const Symbol* name, TRAPS) const {
5041   if (!_need_verify) { return; }
5042 
5043   assert(name != nullptr, "method name is null");
5044   char* bytes = (char*)name->bytes();
5045   unsigned int length = name->utf8_length();
5046   bool legal = false;
5047 
5048   if (length > 0) {
5049     if (bytes[0] == JVM_SIGNATURE_SPECIAL) {
5050       if (name == vmSymbols::object_initializer_name() ||
5051           name == vmSymbols::class_initializer_name()) {
5052         legal = true;
5053       }
5054     } else if (_major_version < JAVA_1_5_VERSION) {
5055       const char* p;
5056       p = skip_over_field_name(bytes, false, length);
5057       legal = (p != nullptr) && ((p - bytes) == (int)length);
5058     } else {
5059       // 4881221: relax the constraints based on JSR202 spec
5060       legal = verify_unqualified_name(bytes, length, LegalMethod);
5061     }
5062   }
5063 
5064   if (!legal) {
5065     ResourceMark rm(THREAD);
5066     assert(_class_name != nullptr, "invariant");
5067     // Names are all known to be < 64k so we know this formatted message is not excessively large.
5068     Exceptions::fthrow(
5069       THREAD_AND_LOCATION,
5070       vmSymbols::java_lang_ClassFormatError(),
5071       "Illegal method name \"%.*s\" in class %s", length, bytes,
5072       _class_name->as_C_string()
5073     );
5074     return;
5075   }
5076 }
5077 
5078 bool ClassFileParser::legal_field_signature(const Symbol* signature, TRAPS) const {
5079   const char* const bytes = (const char*)signature->bytes();
5080   const unsigned int length = signature->utf8_length();
5081   const char* const p = skip_over_field_signature(bytes, false, length, CHECK_false);
5082 
5083   if (p == nullptr || (p - bytes) != (int)length) {
5084     return false;
5085   }
5086   return true;
5087 }
5088 
5089 // Checks if signature is a legal field signature.
5090 void ClassFileParser::verify_legal_field_signature(const Symbol* name,
5091                                                    const Symbol* signature,
5092                                                    TRAPS) const {
5093   if (!_need_verify) { return; }
5094 
5095   const char* const bytes = (const char*)signature->bytes();
5096   const unsigned int length = signature->utf8_length();
5097   const char* const p = skip_over_field_signature(bytes, false, length, CHECK);
5098 
5099   if (p == nullptr || (p - bytes) != (int)length) {
5100     throwIllegalSignature("Field", name, signature, CHECK);
5101   }
5102 }
5103 
5104 // Check that the signature is compatible with the method name.  For example,
5105 // check that <init> has a void signature.
5106 void ClassFileParser::verify_legal_name_with_signature(const Symbol* name,
5107                                                        const Symbol* signature,
5108                                                        TRAPS) const {
5109   if (!_need_verify) {
5110     return;
5111   }
5112 
5113   // Class initializers cannot have args for class format version >= 51.
5114   if (name == vmSymbols::class_initializer_name() &&
5115       signature != vmSymbols::void_method_signature() &&
5116       _major_version >= JAVA_7_VERSION) {
5117     throwIllegalSignature("Method", name, signature, THREAD);
5118     return;
5119   }
5120 
5121   int sig_length = signature->utf8_length();
5122   if (name->utf8_length() > 0 &&
5123     name->char_at(0) == JVM_SIGNATURE_SPECIAL &&
5124     sig_length > 0 &&
5125     signature->char_at(sig_length - 1) != JVM_SIGNATURE_VOID) {
5126     throwIllegalSignature("Method", name, signature, THREAD);
5127   }
5128 }
5129 
5130 // Checks if signature is a legal method signature.
5131 // Returns number of parameters
5132 int ClassFileParser::verify_legal_method_signature(const Symbol* name,
5133                                                    const Symbol* signature,
5134                                                    TRAPS) const {
5135   if (!_need_verify) {
5136     // make sure caller's args_size will be less than 0 even for non-static
5137     // method so it will be recomputed in compute_size_of_parameters().
5138     return -2;
5139   }
5140 
5141   unsigned int args_size = 0;
5142   const char* p = (const char*)signature->bytes();
5143   unsigned int length = signature->utf8_length();
5144   const char* nextp;
5145 

5156       length -= pointer_delta_as_int(nextp, p);
5157       p = nextp;
5158       nextp = skip_over_field_signature(p, false, length, CHECK_0);
5159     }
5160     // The first non-signature thing better be a ')'
5161     if ((length > 0) && (*p++ == JVM_SIGNATURE_ENDFUNC)) {
5162       length--;
5163       // Now we better just have a return value
5164       nextp = skip_over_field_signature(p, true, length, CHECK_0);
5165       if (nextp && ((int)length == (nextp - p))) {
5166         return args_size;
5167       }
5168     }
5169   }
5170   // Report error
5171   throwIllegalSignature("Method", name, signature, THREAD);
5172   return 0;
5173 }
5174 
5175 int ClassFileParser::static_field_size() const {
5176   assert(_layout_info != nullptr, "invariant");
5177   return _layout_info->_static_field_size;
5178 }
5179 
5180 int ClassFileParser::total_oop_map_count() const {
5181   assert(_layout_info != nullptr, "invariant");
5182   return _layout_info->oop_map_blocks->_nonstatic_oop_map_count;
5183 }
5184 
5185 jint ClassFileParser::layout_size() const {
5186   assert(_layout_info != nullptr, "invariant");
5187   return _layout_info->_instance_size;
5188 }
5189 
5190 static void check_methods_for_intrinsics(const InstanceKlass* ik,
5191                                          const Array<Method*>* methods) {
5192   assert(ik != nullptr, "invariant");
5193   assert(methods != nullptr, "invariant");
5194 
5195   // Set up Method*::intrinsic_id as soon as we know the names of methods.
5196   // (We used to do this lazily, but now we query it in Rewriter,
5197   // which is eagerly done for every method, so we might as well do it now,
5198   // when everything is fresh in memory.)
5199   const vmSymbolID klass_id = Method::klass_id_for_intrinsics(ik);
5200 
5201   if (klass_id != vmSymbolID::NO_SID) {
5202     for (int j = 0; j < methods->length(); ++j) {
5203       Method* method = methods->at(j);
5204       method->init_intrinsic_id(klass_id);
5205 
5206       if (CheckIntrinsics) {
5207         // Check if an intrinsic is defined for method 'method',

5282   }
5283 }
5284 
5285 InstanceKlass* ClassFileParser::create_instance_klass(bool changed_by_loadhook,
5286                                                       const ClassInstanceInfo& cl_inst_info,
5287                                                       TRAPS) {
5288   if (_klass != nullptr) {
5289     return _klass;
5290   }
5291 
5292   InstanceKlass* const ik =
5293     InstanceKlass::allocate_instance_klass(*this, CHECK_NULL);
5294 
5295   if (is_hidden()) {
5296     mangle_hidden_class_name(ik);
5297   }
5298 
5299   fill_instance_klass(ik, changed_by_loadhook, cl_inst_info, CHECK_NULL);
5300 
5301   assert(_klass == ik, "invariant");

5302   return ik;
5303 }
5304 
5305 void ClassFileParser::fill_instance_klass(InstanceKlass* ik,
5306                                           bool changed_by_loadhook,
5307                                           const ClassInstanceInfo& cl_inst_info,
5308                                           TRAPS) {
5309   assert(ik != nullptr, "invariant");
5310 
5311   // Set name and CLD before adding to CLD
5312   ik->set_class_loader_data(_loader_data);
5313   ik->set_class_loader_type();
5314   ik->set_name(_class_name);
5315 
5316   // Add all classes to our internal class loader list here,
5317   // including classes in the bootstrap (null) class loader.
5318   const bool publicize = !is_internal();
5319 
5320   _loader_data->add_class(ik, publicize);
5321 
5322   set_klass_to_deallocate(ik);
5323 
5324   assert(_layout_info != nullptr, "invariant");
5325   assert(ik->static_field_size() == _layout_info->_static_field_size, "sanity");
5326   assert(ik->nonstatic_oop_map_count() == _layout_info->oop_map_blocks->_nonstatic_oop_map_count,
5327          "sanity");
5328 
5329   assert(ik->is_instance_klass(), "sanity");
5330   assert(ik->size_helper() == _layout_info->_instance_size, "sanity");
5331 
5332   // Fill in information already parsed
5333   ik->set_should_verify_class(_need_verify);
5334 
5335   // Not yet: supers are done below to support the new subtype-checking fields
5336   ik->set_nonstatic_field_size(_layout_info->_nonstatic_field_size);
5337   ik->set_has_nonstatic_fields(_layout_info->_has_nonstatic_fields);
5338   ik->set_has_strict_static_fields(_has_strict_static_fields);
5339 
5340   if (_layout_info->_is_naturally_atomic) {
5341     ik->set_is_naturally_atomic();
5342   }
5343 
5344   if (_layout_info->_must_be_atomic) {
5345     ik->set_must_be_atomic();
5346   }
5347 
5348   ik->set_static_oop_field_count(_static_oop_count);
5349 
5350   // this transfers ownership of a lot of arrays from
5351   // the parser onto the InstanceKlass*
5352   apply_parsed_class_metadata(ik, _java_fields_count);
5353   if (ik->is_inline_klass()) {
5354     InlineKlass::cast(ik)->init_fixed_block();
5355   }
5356 
5357   // can only set dynamic nest-host after static nest information is set
5358   if (cl_inst_info.dynamic_nest_host() != nullptr) {
5359     ik->set_nest_host(cl_inst_info.dynamic_nest_host());
5360   }
5361 
5362   // note that is not safe to use the fields in the parser from this point on
5363   assert(nullptr == _cp, "invariant");
5364   assert(nullptr == _fieldinfo_stream, "invariant");
5365   assert(nullptr == _fieldinfo_search_table, "invariant");
5366   assert(nullptr == _fields_status, "invariant");
5367   assert(nullptr == _methods, "invariant");
5368   assert(nullptr == _inner_classes, "invariant");
5369   assert(nullptr == _nest_members, "invariant");
5370   assert(nullptr == _loadable_descriptors, "invariant");
5371   assert(nullptr == _combined_annotations, "invariant");
5372   assert(nullptr == _record_components, "invariant");
5373   assert(nullptr == _permitted_subclasses, "invariant");
5374   assert(nullptr == _inline_layout_info_array, "invariant");
5375 
5376   if (_has_localvariable_table) {
5377     ik->set_has_localvariable_table(true);
5378   }
5379 
5380   if (_has_final_method) {
5381     ik->set_has_final_method();
5382   }
5383 
5384   ik->copy_method_ordering(_method_ordering, CHECK);
5385   // The InstanceKlass::_methods_jmethod_ids cache
5386   // is managed on the assumption that the initial cache
5387   // size is equal to the number of methods in the class. If
5388   // that changes, then InstanceKlass::idnum_can_increment()
5389   // has to be changed accordingly.
5390   ik->set_initial_method_idnum(checked_cast<u2>(ik->methods()->length()));
5391 
5392   ik->set_this_class_index(_this_class_index);
5393 
5394   if (_is_hidden) {

5431   if ((_num_miranda_methods > 0) ||
5432       // if this class introduced new miranda methods or
5433       (_super_klass != nullptr && _super_klass->has_miranda_methods())
5434         // super class exists and this class inherited miranda methods
5435      ) {
5436        ik->set_has_miranda_methods(); // then set a flag
5437   }
5438 
5439   // Fill in information needed to compute superclasses.
5440   ik->initialize_supers(const_cast<InstanceKlass*>(_super_klass), _transitive_interfaces, CHECK);
5441   ik->set_transitive_interfaces(_transitive_interfaces);
5442   ik->set_local_interfaces(_local_interfaces);
5443   _transitive_interfaces = nullptr;
5444   _local_interfaces = nullptr;
5445 
5446   // Initialize itable offset tables
5447   klassItable::setup_itable_offset_table(ik);
5448 
5449   // Compute transitive closure of interfaces this class implements
5450   // Do final class setup
5451   OopMapBlocksBuilder* oop_map_blocks = _layout_info->oop_map_blocks;
5452   if (oop_map_blocks->_nonstatic_oop_map_count > 0) {
5453     oop_map_blocks->copy(ik->start_of_nonstatic_oop_maps());
5454   }
5455 
5456   if (_has_contended_fields || _parsed_annotations->is_contended() ||
5457       ( _super_klass != nullptr && _super_klass->has_contended_annotations())) {
5458     ik->set_has_contended_annotations(true);
5459   }
5460 
5461   // Fill in has_finalizer and layout_helper
5462   set_precomputed_flags(ik);
5463 
5464   // check if this class can access its super class
5465   check_super_class_access(ik, CHECK);
5466 
5467   // check if this class can access its superinterfaces
5468   check_super_interface_access(ik, CHECK);
5469 
5470   // check if this class overrides any final method
5471   check_final_method_override(ik, CHECK);

5492 
5493   assert(_all_mirandas != nullptr, "invariant");
5494 
5495   // Generate any default methods - default methods are public interface methods
5496   // that have a default implementation.  This is new with Java 8.
5497   if (_has_nonstatic_concrete_methods) {
5498     DefaultMethods::generate_default_methods(ik,
5499                                              _all_mirandas,
5500                                              CHECK);
5501   }
5502 
5503   // Add read edges to the unnamed modules of the bootstrap and app class loaders.
5504   if (changed_by_loadhook && !module_handle.is_null() && module_entry->is_named() &&
5505       !module_entry->has_default_read_edges()) {
5506     if (!module_entry->set_has_default_read_edges()) {
5507       // We won a potential race
5508       JvmtiExport::add_default_read_edges(module_handle, THREAD);
5509     }
5510   }
5511 
5512   if (is_inline_type()) {
5513     InlineKlass* vk = InlineKlass::cast(ik);
5514     vk->set_payload_alignment(_layout_info->_payload_alignment);
5515     vk->set_payload_offset(_layout_info->_payload_offset);
5516     vk->set_payload_size_in_bytes(_layout_info->_payload_size_in_bytes);
5517     vk->set_non_atomic_size_in_bytes(_layout_info->_non_atomic_size_in_bytes);
5518     vk->set_non_atomic_alignment(_layout_info->_non_atomic_alignment);
5519     vk->set_atomic_size_in_bytes(_layout_info->_atomic_layout_size_in_bytes);
5520     vk->set_nullable_size_in_bytes(_layout_info->_nullable_layout_size_in_bytes);
5521     vk->set_null_marker_offset(_layout_info->_null_marker_offset);
5522     vk->set_null_reset_value_offset(_layout_info->_null_reset_value_offset);
5523     if (_layout_info->_is_empty_inline_klass) vk->set_is_empty_inline_type();
5524     vk->initialize_calling_convention(CHECK);
5525   }
5526 
5527   ClassLoadingService::notify_class_loaded(ik, false /* not shared class */);
5528 
5529   if (!is_internal()) {
5530     ik->print_class_load_logging(_loader_data, module_entry, _stream);
5531 
5532     if (ik->minor_version() == JAVA_PREVIEW_MINOR_VERSION &&
5533         ik->major_version() == JVM_CLASSFILE_MAJOR_VERSION &&
5534         log_is_enabled(Info, class, preview)) {
5535       ResourceMark rm;
5536       log_info(class, preview)("Loading class %s that depends on preview features (class file version %d.65535)",
5537                                ik->external_name(), JVM_CLASSFILE_MAJOR_VERSION);
5538     }
5539 
5540     if (log_is_enabled(Debug, class, resolve))  {
5541       ResourceMark rm;
5542       // print out the superclass.
5543       const char * from = ik->external_name();
5544       if (ik->super() != nullptr) {
5545         log_debug(class, resolve)("%s %s (super)",
5546                    from,

5589                                  const ClassLoadInfo* cl_info,
5590                                  Publicity pub_level,
5591                                  TRAPS) :
5592   _stream(stream),
5593   _class_name(nullptr),
5594   _loader_data(loader_data),
5595   _is_hidden(cl_info->is_hidden()),
5596   _can_access_vm_annotations(cl_info->can_access_vm_annotations()),
5597   _orig_cp_size(0),
5598   _static_oop_count(0),
5599   _super_klass(),
5600   _cp(nullptr),
5601   _fieldinfo_stream(nullptr),
5602   _fieldinfo_search_table(nullptr),
5603   _fields_status(nullptr),
5604   _methods(nullptr),
5605   _inner_classes(nullptr),
5606   _nest_members(nullptr),
5607   _nest_host(0),
5608   _permitted_subclasses(nullptr),
5609   _loadable_descriptors(nullptr),
5610   _record_components(nullptr),
5611   _local_interfaces(nullptr),
5612   _local_interface_indexes(nullptr),
5613   _transitive_interfaces(nullptr),
5614   _combined_annotations(nullptr),
5615   _class_annotations(nullptr),
5616   _class_type_annotations(nullptr),
5617   _fields_annotations(nullptr),
5618   _fields_type_annotations(nullptr),
5619   _klass(nullptr),
5620   _klass_to_deallocate(nullptr),
5621   _parsed_annotations(nullptr),
5622   _layout_info(nullptr),
5623   _inline_layout_info_array(nullptr),
5624   _temp_field_info(nullptr),
5625   _method_ordering(nullptr),
5626   _all_mirandas(nullptr),
5627   _vtable_size(0),
5628   _itable_size(0),
5629   _num_miranda_methods(0),
5630   _protection_domain(cl_info->protection_domain()),
5631   _access_flags(),
5632   _pub_level(pub_level),
5633   _bad_constant_seen(0),
5634   _synthetic_flag(false),
5635   _sde_length(false),
5636   _sde_buffer(nullptr),
5637   _sourcefile_index(0),
5638   _generic_signature_index(0),
5639   _major_version(0),
5640   _minor_version(0),
5641   _this_class_index(0),
5642   _super_class_index(0),
5643   _itfs_len(0),
5644   _java_fields_count(0),
5645   _need_verify(false),
5646   _has_nonstatic_concrete_methods(false),
5647   _declares_nonstatic_concrete_methods(false),
5648   _has_localvariable_table(false),
5649   _has_final_method(false),
5650   _has_contended_fields(false),
5651   _has_aot_runtime_setup_method(false),
5652   _has_strict_static_fields(false),
5653   _has_inline_type_fields(false),
5654   _is_naturally_atomic(false),
5655   _must_be_atomic(true),
5656   _has_loosely_consistent_annotation(false),
5657   _has_finalizer(false),
5658   _has_empty_finalizer(false),
5659   _max_bootstrap_specifier_index(-1) {
5660 
5661   _class_name = name != nullptr ? name : vmSymbols::unknown_class_name();
5662   _class_name->increment_refcount();
5663 
5664   assert(_loader_data != nullptr, "invariant");
5665   assert(stream != nullptr, "invariant");
5666   assert(_stream != nullptr, "invariant");
5667   assert(_stream->buffer() == _stream->current(), "invariant");
5668   assert(_class_name != nullptr, "invariant");
5669   assert(0 == _access_flags.as_unsigned_short(), "invariant");
5670 
5671   // Figure out whether we can skip format checking (matching classic VM behavior)
5672   // Always verify CFLH bytes from the user agents.
5673   _need_verify = stream->from_class_file_load_hook() ? true : Verifier::should_verify_for(_loader_data->class_loader());
5674 
5675   // synch back verification state to stream to check for truncation.
5676   stream->set_need_verify(_need_verify);
5677 
5678   parse_stream(stream, CHECK);
5679 
5680   post_process_parsed_stream(stream, _cp, CHECK);
5681 }
5682 
5683 void ClassFileParser::clear_class_metadata() {
5684   // metadata created before the instance klass is created.  Must be
5685   // deallocated if classfile parsing returns an error.
5686   _cp = nullptr;
5687   _fieldinfo_stream = nullptr;
5688   _fieldinfo_search_table = nullptr;
5689   _fields_status = nullptr;
5690   _methods = nullptr;
5691   _inner_classes = nullptr;
5692   _nest_members = nullptr;
5693   _permitted_subclasses = nullptr;
5694   _loadable_descriptors = nullptr;
5695   _combined_annotations = nullptr;
5696   _class_annotations = _class_type_annotations = nullptr;
5697   _fields_annotations = _fields_type_annotations = nullptr;
5698   _record_components = nullptr;
5699   _inline_layout_info_array = nullptr;
5700 }
5701 
5702 // Destructor to clean up
5703 ClassFileParser::~ClassFileParser() {
5704   _class_name->decrement_refcount();
5705 
5706   if (_cp != nullptr) {
5707     MetadataFactory::free_metadata(_loader_data, _cp);
5708   }
5709 
5710   if (_fieldinfo_stream != nullptr) {
5711     MetadataFactory::free_array<u1>(_loader_data, _fieldinfo_stream);
5712   }
5713   MetadataFactory::free_array<u1>(_loader_data, _fieldinfo_search_table);
5714 
5715   if (_fields_status != nullptr) {
5716     MetadataFactory::free_array<FieldStatus>(_loader_data, _fields_status);
5717   }
5718 
5719   if (_inline_layout_info_array != nullptr) {
5720     MetadataFactory::free_array<InlineLayoutInfo>(_loader_data, _inline_layout_info_array);
5721   }
5722 
5723   if (_methods != nullptr) {
5724     // Free methods
5725     InstanceKlass::deallocate_methods(_loader_data, _methods);
5726   }
5727 
5728   // beware of the Universe::empty_blah_array!!
5729   if (_inner_classes != nullptr && _inner_classes != Universe::the_empty_short_array()) {
5730     MetadataFactory::free_array<u2>(_loader_data, _inner_classes);
5731   }
5732 
5733   if (_nest_members != nullptr && _nest_members != Universe::the_empty_short_array()) {
5734     MetadataFactory::free_array<u2>(_loader_data, _nest_members);
5735   }
5736 
5737   if (_record_components != nullptr) {
5738     InstanceKlass::deallocate_record_components(_loader_data, _record_components);
5739   }
5740 
5741   if (_permitted_subclasses != nullptr && _permitted_subclasses != Universe::the_empty_short_array()) {
5742     MetadataFactory::free_array<u2>(_loader_data, _permitted_subclasses);
5743   }
5744 
5745   if (_loadable_descriptors != nullptr && _loadable_descriptors != Universe::the_empty_short_array()) {
5746     MetadataFactory::free_array<u2>(_loader_data, _loadable_descriptors);
5747   }
5748 
5749   // Free interfaces
5750   InstanceKlass::deallocate_interfaces(_loader_data, _super_klass,
5751                                        _local_interfaces, _transitive_interfaces);
5752 
5753   if (_combined_annotations != nullptr) {
5754     // After all annotations arrays have been created, they are installed into the
5755     // Annotations object that will be assigned to the InstanceKlass being created.
5756 
5757     // Deallocate the Annotations object and the installed annotations arrays.
5758     _combined_annotations->deallocate_contents(_loader_data);
5759 
5760     // If the _combined_annotations pointer is non-null,
5761     // then the other annotations fields should have been cleared.
5762     assert(_class_annotations       == nullptr, "Should have been cleared");
5763     assert(_class_type_annotations  == nullptr, "Should have been cleared");
5764     assert(_fields_annotations      == nullptr, "Should have been cleared");
5765     assert(_fields_type_annotations == nullptr, "Should have been cleared");
5766   } else {
5767     // If the annotations arrays were not installed into the Annotations object,
5768     // then they have to be deallocated explicitly.

5827 
5828   assert(cp_size == (u2)cp->length(), "invariant");
5829 
5830   // ACCESS FLAGS
5831   stream->guarantee_more(8, CHECK);  // flags, this_class, super_class, infs_len
5832 
5833   // Access flags
5834   u2 flags;
5835   // JVM_ACC_MODULE is defined in JDK-9 and later.
5836   if (_major_version >= JAVA_9_VERSION) {
5837     flags = stream->get_u2_fast() & (JVM_RECOGNIZED_CLASS_MODIFIERS | JVM_ACC_MODULE);
5838   } else {
5839     flags = stream->get_u2_fast() & JVM_RECOGNIZED_CLASS_MODIFIERS;
5840   }
5841 
5842   if ((flags & JVM_ACC_INTERFACE) && _major_version < JAVA_6_VERSION) {
5843     // Set abstract bit for old class files for backward compatibility
5844     flags |= JVM_ACC_ABSTRACT;
5845   }
5846 
5847   // Fixing ACC_SUPER/ACC_IDENTITY for old class files
5848   if (!supports_inline_types()) {
5849     const bool is_module = (flags & JVM_ACC_MODULE) != 0;
5850     const bool is_interface = (flags & JVM_ACC_INTERFACE) != 0;
5851     if (!is_module && !is_interface) {
5852       flags |= JVM_ACC_IDENTITY;
5853     }
5854   }
5855 
5856   verify_legal_class_modifiers(flags, nullptr, false, CHECK);
5857 
5858   short bad_constant = class_bad_constant_seen();
5859   if (bad_constant != 0) {
5860     // Do not throw CFE until after the access_flags are checked because if
5861     // ACC_MODULE is set in the access flags, then NCDFE must be thrown, not CFE.
5862     classfile_parse_error("Unknown constant tag %u in class file %s", bad_constant, THREAD);
5863     return;
5864   }
5865 
5866   _access_flags.set_flags(flags);
5867 
5868   // This class and superclass
5869   _this_class_index = stream->get_u2_fast();
5870   guarantee_property(
5871     valid_cp_range(_this_class_index, cp_size) &&
5872       cp->tag_at(_this_class_index).is_unresolved_klass(),
5873     "Invalid this class index %u in constant pool in class file %s",
5874     _this_class_index, CHECK);
5875 

5939       }
5940       ls.cr();
5941     }
5942   }
5943 
5944   // SUPERKLASS
5945   _super_class_index = stream->get_u2_fast();
5946   check_super_class(cp,
5947                     _super_class_index,
5948                     _need_verify,
5949                     CHECK);
5950 
5951   // Interfaces
5952   _itfs_len = stream->get_u2_fast();
5953   parse_interfaces(stream,
5954                    _itfs_len,
5955                    cp,
5956                    &_has_nonstatic_concrete_methods,
5957                    CHECK);
5958 


5959   // Fields (offsets are filled in later)
5960   parse_fields(stream,
5961                _access_flags,
5962                cp,
5963                cp_size,
5964                &_java_fields_count,
5965                CHECK);
5966 
5967   assert(_temp_field_info != nullptr, "invariant");
5968 
5969   // Methods
5970   parse_methods(stream,
5971                 is_interface(),
5972                 !is_identity_class(),
5973                 is_abstract_class(),
5974                 &_has_localvariable_table,
5975                 &_has_final_method,
5976                 &_declares_nonstatic_concrete_methods,
5977                 CHECK);
5978 
5979   assert(_methods != nullptr, "invariant");
5980 
5981   if (_declares_nonstatic_concrete_methods) {
5982     _has_nonstatic_concrete_methods = true;
5983   }
5984 
5985   // Additional attributes/annotations
5986   _parsed_annotations = new ClassAnnotationCollector();
5987   parse_classfile_attributes(stream, cp, _parsed_annotations, CHECK);
5988 
5989   assert(_inner_classes != nullptr, "invariant");
5990 
5991   // Finalize the Annotations metadata object,
5992   // now that all annotation arrays have been created.
5993   create_combined_annotations(CHECK);

6041 }
6042 
6043 void ClassFileParser::post_process_parsed_stream(const ClassFileStream* const stream,
6044                                                  ConstantPool* cp,
6045                                                  TRAPS) {
6046   assert(stream != nullptr, "invariant");
6047   assert(stream->at_eos(), "invariant");
6048   assert(cp != nullptr, "invariant");
6049   assert(_loader_data != nullptr, "invariant");
6050 
6051   if (_class_name == vmSymbols::java_lang_Object()) {
6052     precond(_super_class_index == 0);
6053     precond(_super_klass == nullptr);
6054     guarantee_property(_local_interfaces == Universe::the_empty_instance_klass_array(),
6055                        "java.lang.Object cannot implement an interface in class file %s",
6056                        CHECK);
6057   } else {
6058     // Set _super_klass after class file is parsed and format is checked
6059     assert(_super_class_index > 0, "any class other than Object must have a super class");
6060     Symbol* const super_class_name = cp->klass_name_at(_super_class_index);
6061     if (is_interface()) {
6062       // Before attempting to resolve the superclass, check for class format
6063       // errors not checked yet.
6064       guarantee_property(super_class_name == vmSymbols::java_lang_Object(),
6065         "Interfaces must have java.lang.Object as superclass in class file %s",
6066         CHECK);
6067     }
6068     Handle loader(THREAD, _loader_data->class_loader());
6069     if (loader.is_null() && super_class_name == vmSymbols::java_lang_Object()) {
6070       // fast path to avoid lookup
6071       _super_klass = vmClasses::Object_klass();
6072     } else {
6073       _super_klass = (const InstanceKlass*)
6074                        SystemDictionary::resolve_super_or_fail(_class_name,
6075                                                                super_class_name,
6076                                                                loader,
6077                                                                true,
6078                                                                CHECK);
6079     }
6080   }
6081 
6082   if (_super_klass != nullptr) {
6083     if (_super_klass->is_interface()) {
6084       classfile_icce_error("class %s has interface %s as super class", _super_klass, THREAD);
6085       return;
6086     }
6087 
6088     if (_super_klass->is_final()) {
6089       classfile_icce_error("class %s cannot inherit from final class %s", _super_klass, THREAD);
6090       return;
6091     }
6092 
6093     if (EnableValhalla) {
6094       check_identity_and_value_modifiers(this, _super_klass, CHECK);
6095     }
6096 
6097     if (_super_klass->has_nonstatic_concrete_methods()) {
6098       _has_nonstatic_concrete_methods = true;
6099     }
6100   }
6101 
6102   if (_parsed_annotations->has_annotation(AnnotationCollector::_jdk_internal_LooselyConsistentValue) && _access_flags.is_identity_class()) {
6103     THROW_MSG(vmSymbols::java_lang_ClassFormatError(),
6104           err_msg("class %s cannot have annotation jdk.internal.vm.annotation.LooselyConsistentValue, because it is not a value class",
6105                   _class_name->as_klass_external_name()));
6106   }
6107 
6108   // Determining is the class allows tearing or not (default is not)
6109   if (EnableValhalla && !_access_flags.is_identity_class()) {
6110     if (_parsed_annotations->has_annotation(ClassAnnotationCollector::_jdk_internal_LooselyConsistentValue)
6111         && (_super_klass == vmClasses::Object_klass() || !_super_klass->must_be_atomic())) {
6112       // Conditions above are not sufficient to determine atomicity requirements,
6113       // the presence of fields with atomic requirements could force the current class to have atomicy requirements too
6114       // Marking as not needing atomicity for now, can be updated when computing the fields layout
6115       // The InstanceKlass must be filled with the value from the FieldLayoutInfo returned by
6116       // the FieldLayoutBuilder, not with this _must_be_atomic field.
6117       _must_be_atomic = false;
6118     }
6119     // Apply VM options override
6120     if (*ForceNonTearable != '\0') {
6121       // Allow a command line switch to force the same atomicity property:
6122       const char* class_name_str = _class_name->as_C_string();
6123       if (StringUtils::class_list_match(ForceNonTearable, class_name_str)) {
6124         _must_be_atomic = true;
6125       }
6126     }
6127   }
6128 
6129   int itfs_len = _local_interface_indexes == nullptr ? 0 : _local_interface_indexes->length();
6130   _local_interfaces = MetadataFactory::new_array<InstanceKlass*>(_loader_data, itfs_len, nullptr, CHECK);
6131   if (_local_interface_indexes != nullptr) {
6132     for (int i = 0; i < _local_interface_indexes->length(); i++) {
6133       u2 interface_index = _local_interface_indexes->at(i);
6134       Klass* interf;
6135       if (cp->tag_at(interface_index).is_klass()) {
6136         interf = cp->resolved_klass_at(interface_index);
6137       } else {
6138         Symbol* const unresolved_klass  = cp->klass_name_at(interface_index);
6139 
6140         // Don't need to check legal name because it's checked when parsing constant pool.
6141         // But need to make sure it's not an array type.
6142         guarantee_property(unresolved_klass->char_at(0) != JVM_SIGNATURE_ARRAY,
6143                             "Bad interface name in class file %s", CHECK);
6144 
6145         // Call resolve on the interface class name with class circularity checking
6146         interf = SystemDictionary::resolve_super_or_fail(
6147                                                   _class_name,
6148                                                   unresolved_klass,
6149                                                   Handle(THREAD, _loader_data->class_loader()),
6150                                                   false,
6151                                                   CHECK);
6152       }
6153 
6154       if (!interf->is_interface()) {
6155         THROW_MSG(vmSymbols::java_lang_IncompatibleClassChangeError(),
6156                   err_msg("class %s can not implement %s, because it is not an interface (%s)",
6157                           _class_name->as_klass_external_name(),
6158                           interf->external_name(),
6159                           interf->class_in_module_of_loader()));
6160       }
6161 
6162       if (EnableValhalla) {
6163         // Check modifiers and set carries_identity_modifier/carries_value_modifier flags
6164         check_identity_and_value_modifiers(this, InstanceKlass::cast(interf), CHECK);
6165       }
6166 
6167       if (InstanceKlass::cast(interf)->has_nonstatic_concrete_methods()) {
6168         _has_nonstatic_concrete_methods = true;
6169       }
6170       _local_interfaces->at_put(i, InstanceKlass::cast(interf));
6171     }
6172   }
6173   assert(_local_interfaces != nullptr, "invariant");
6174 
6175   // Compute the transitive list of all unique interfaces implemented by this class
6176   _transitive_interfaces =
6177     compute_transitive_interfaces(_super_klass,
6178                                   _local_interfaces,
6179                                   _loader_data,
6180                                   CHECK);
6181 
6182   assert(_transitive_interfaces != nullptr, "invariant");
6183 
6184   // sort methods
6185   _method_ordering = sort_methods(_methods);
6186 
6187   _all_mirandas = new GrowableArray<Method*>(20);
6188 
6189   Handle loader(THREAD, _loader_data->class_loader());
6190   klassVtable::compute_vtable_size_and_num_mirandas(&_vtable_size,
6191                                                     &_num_miranda_methods,
6192                                                     _all_mirandas,
6193                                                     _super_klass,
6194                                                     _methods,
6195                                                     _access_flags,
6196                                                     _major_version,
6197                                                     loader,
6198                                                     _class_name,
6199                                                     _local_interfaces);
6200 
6201   // Size of Java itable (in words)
6202   _itable_size = is_interface() ? 0 :
6203     klassItable::compute_itable_size(_transitive_interfaces);
6204 
6205   assert(_parsed_annotations != nullptr, "invariant");
6206 
6207   if (EnableValhalla) {
6208     _inline_layout_info_array = MetadataFactory::new_array<InlineLayoutInfo>(_loader_data,
6209                                                    java_fields_count(),
6210                                                    CHECK);
6211     for (GrowableArrayIterator<FieldInfo> it = _temp_field_info->begin(); it != _temp_field_info->end(); ++it) {
6212       FieldInfo fieldinfo = *it;
6213       if (fieldinfo.access_flags().is_static()) continue;  // Only non-static fields are processed at load time
6214       Symbol* sig = fieldinfo.signature(cp);
6215       if (fieldinfo.field_flags().is_null_free_inline_type()) {
6216         // Pre-load classes of null-free fields that are candidate for flattening
6217         TempNewSymbol s = Signature::strip_envelope(sig);
6218         if (s == _class_name) {
6219           THROW_MSG(vmSymbols::java_lang_ClassCircularityError(),
6220                     err_msg("Class %s cannot have a null-free non-static field of its own type", _class_name->as_C_string()));
6221         }
6222         log_info(class, preload)("Preloading of class %s during loading of class %s. "
6223                                   "Cause: a null-free non-static field is declared with this type",
6224                                   s->as_C_string(), _class_name->as_C_string());
6225         InstanceKlass* klass = SystemDictionary::resolve_with_circularity_detection(_class_name, s,
6226                                                                                     Handle(THREAD,
6227                                                                                     _loader_data->class_loader()),
6228                                                                                     false, THREAD);
6229         if (HAS_PENDING_EXCEPTION) {
6230           log_warning(class, preload)("Preloading of class %s during loading of class %s "
6231                                       "(cause: null-free non-static field) failed: %s",
6232                                       s->as_C_string(), _class_name->as_C_string(),
6233                                       PENDING_EXCEPTION->klass()->name()->as_C_string());
6234           return; // Exception is still pending
6235         }
6236         assert(klass != nullptr, "Sanity check");
6237         InstanceKlass::check_can_be_annotated_with_NullRestricted(klass, _class_name, CHECK);
6238         InlineKlass* vk = InlineKlass::cast(klass);
6239         _inline_layout_info_array->adr_at(fieldinfo.index())->set_klass(vk);
6240         log_info(class, preload)("Preloading of class %s during loading of class %s "
6241                                  "(cause: null-free non-static field) succeeded",
6242                                  s->as_C_string(), _class_name->as_C_string());
6243       } else if (Signature::has_envelope(sig) && PreloadClasses) {
6244         // Preloading classes for nullable fields that are listed in the LoadableDescriptors attribute
6245         // Those classes would be required later for the flattening of nullable inline type fields
6246         TempNewSymbol name = Signature::strip_envelope(sig);
6247         if (name != _class_name && is_class_in_loadable_descriptors_attribute(sig)) {
6248           log_info(class, preload)("Preloading of class %s during loading of class %s. "
6249                                    "Cause: field type in LoadableDescriptors attribute",
6250                                    name->as_C_string(), _class_name->as_C_string());
6251           oop loader = loader_data()->class_loader();
6252           Klass* klass = SystemDictionary::resolve_super_or_fail(_class_name, name,
6253                                                                  Handle(THREAD, loader),
6254                                                                  false, THREAD);
6255           if (klass != nullptr) {
6256             if (klass->is_inline_klass()) {
6257               _inline_layout_info_array->adr_at(fieldinfo.index())->set_klass(InlineKlass::cast(klass));
6258               log_info(class, preload)("Preloading of class %s during loading of class %s "
6259                                        "(cause: field type in LoadableDescriptors attribute) succeeded",
6260                                        name->as_C_string(), _class_name->as_C_string());
6261             } else {
6262               // Non value class are allowed by the current spec, but it could be an indication of an issue so let's log a warning
6263               log_warning(class, preload)("Preloading of class %s during loading of class %s "
6264                                           "(cause: field type in LoadableDescriptors attribute) but loaded class is not a value class",
6265                                           name->as_C_string(), _class_name->as_C_string());
6266             }
6267           } else {
6268             log_warning(class, preload)("Preloading of class %s during loading of class %s "
6269                                         "(cause: field type in LoadableDescriptors attribute) failed : %s",
6270                                         name->as_C_string(), _class_name->as_C_string(),
6271                                         PENDING_EXCEPTION->klass()->name()->as_C_string());
6272           }
6273           // Loads triggered by the LoadableDescriptors attribute are speculative, failures must not impact loading of current class
6274           if (HAS_PENDING_EXCEPTION) {
6275             CLEAR_PENDING_EXCEPTION;
6276           }
6277         } else {
6278           // Just poking the system dictionary to see if the class has already be loaded. Looking for migrated classes
6279           // used when --enable-preview when jdk isn't compiled with --enable-preview so doesn't include LoadableDescriptors.
6280           // This is temporary.
6281           oop loader = loader_data()->class_loader();
6282           InstanceKlass* klass = SystemDictionary::find_instance_klass(THREAD, name, Handle(THREAD, loader));
6283           if (klass != nullptr && klass->is_inline_klass()) {
6284             _inline_layout_info_array->adr_at(fieldinfo.index())->set_klass(InlineKlass::cast(klass));
6285             log_info(class, preload)("Preloading of class %s during loading of class %s "
6286                                      "(cause: field type not in LoadableDescriptors attribute) succeeded",
6287                                      name->as_C_string(), _class_name->as_C_string());
6288           }
6289         }
6290       }
6291     }
6292   }
6293 
6294   _layout_info = new FieldLayoutInfo();
6295   FieldLayoutBuilder lb(class_name(), loader_data(), super_klass(), _cp, /*_fields*/ _temp_field_info,
6296       _parsed_annotations->is_contended(), is_inline_type(),
6297       access_flags().is_abstract() && !access_flags().is_identity_class() && !access_flags().is_interface(),
6298       _must_be_atomic, _layout_info, _inline_layout_info_array);
6299   lb.build_layout();
6300   _has_inline_type_fields = _layout_info->_has_inline_fields;
6301 
6302   int injected_fields_count = _temp_field_info->length() - _java_fields_count;
6303   _fieldinfo_stream =
6304     FieldInfoStream::create_FieldInfoStream(_temp_field_info, _java_fields_count,
6305                                             injected_fields_count, loader_data(), CHECK);
6306   _fieldinfo_search_table = FieldInfoStream::create_search_table(_cp, _fieldinfo_stream, _loader_data, CHECK);
6307   _fields_status =
6308     MetadataFactory::new_array<FieldStatus>(_loader_data, _temp_field_info->length(),
6309                                             FieldStatus(0), CHECK);
6310 
6311   // Strict static fields track initialization status from the beginning of time.
6312   // After this class runs <clinit>, they will be verified as being "not unset".
6313   // See Step 8 of InstanceKlass::initialize_impl.
6314   if (_has_strict_static_fields) {
6315     bool found_one = false;
6316     for (int i = 0; i < _temp_field_info->length(); i++) {
6317       FieldInfo& fi = *_temp_field_info->adr_at(i);
6318       if (fi.access_flags().is_strict() && fi.access_flags().is_static()) {
6319         found_one = true;
6320         if (fi.initializer_index() != 0) {
6321           // skip strict static fields with ConstantValue attributes
6322         } else {
6323           _fields_status->adr_at(fi.index())->update_strict_static_unset(true);
6324           _fields_status->adr_at(fi.index())->update_strict_static_unread(true);
6325         }
6326       }
6327     }
6328     assert(found_one == _has_strict_static_fields,
6329            "correct prediction = %d", (int)_has_strict_static_fields);
6330   }
6331 }
6332 
6333 void ClassFileParser::set_klass(InstanceKlass* klass) {
6334 
6335 #ifdef ASSERT
6336   if (klass != nullptr) {
6337     assert(nullptr == _klass, "leaking?");
6338   }
6339 #endif
6340 
6341   _klass = klass;
6342 }
6343 
6344 void ClassFileParser::set_klass_to_deallocate(InstanceKlass* klass) {
6345 
6346 #ifdef ASSERT
6347   if (klass != nullptr) {
6348     assert(nullptr == _klass_to_deallocate, "leaking?");
6349   }
6350 #endif
< prev index next >