1 /* 2 * Copyright (c) 1997, 2026, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 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/systemDictionaryShared.hpp" 39 #include "classfile/verificationType.hpp" 40 #include "classfile/verifier.hpp" 41 #include "classfile/vmClasses.hpp" 42 #include "classfile/vmSymbols.hpp" 43 #include "jvm.h" 44 #include "logging/log.hpp" 45 #include "logging/logStream.hpp" 46 #include "memory/allocation.hpp" 47 #include "memory/metadataFactory.hpp" 48 #include "memory/oopFactory.hpp" 49 #include "memory/resourceArea.hpp" 50 #include "memory/universe.hpp" 51 #include "oops/annotations.hpp" 52 #include "oops/bsmAttribute.inline.hpp" 53 #include "oops/constantPool.inline.hpp" 54 #include "oops/fieldInfo.hpp" 55 #include "oops/fieldStreams.inline.hpp" 56 #include "oops/inlineKlass.inline.hpp" 57 #include "oops/instanceKlass.inline.hpp" 58 #include "oops/instanceMirrorKlass.hpp" 59 #include "oops/klass.inline.hpp" 60 #include "oops/klassVtable.hpp" 61 #include "oops/metadata.hpp" 62 #include "oops/method.inline.hpp" 63 #include "oops/oop.inline.hpp" 64 #include "oops/recordComponent.hpp" 65 #include "oops/symbol.hpp" 66 #include "prims/jvmtiExport.hpp" 67 #include "prims/jvmtiThreadState.hpp" 68 #include "runtime/arguments.hpp" 69 #include "runtime/fieldDescriptor.inline.hpp" 70 #include "runtime/handles.inline.hpp" 71 #include "runtime/javaCalls.hpp" 72 #include "runtime/os.hpp" 73 #include "runtime/perfData.hpp" 74 #include "runtime/reflection.hpp" 75 #include "runtime/safepointVerifiers.hpp" 76 #include "runtime/signature.hpp" 77 #include "runtime/timer.hpp" 78 #include "services/classLoadingService.hpp" 79 #include "services/threadService.hpp" 80 #include "utilities/align.hpp" 81 #include "utilities/bitMap.inline.hpp" 82 #include "utilities/checkedCast.hpp" 83 #include "utilities/copy.hpp" 84 #include "utilities/exceptions.hpp" 85 #include "utilities/formatBuffer.hpp" 86 #include "utilities/globalDefinitions.hpp" 87 #include "utilities/growableArray.hpp" 88 #include "utilities/hashTable.hpp" 89 #include "utilities/macros.hpp" 90 #include "utilities/ostream.hpp" 91 #include "utilities/stringUtils.hpp" 92 #include "utilities/utf8.hpp" 93 94 // We generally try to create the oops directly when parsing, rather than 95 // allocating temporary data structures and copying the bytes twice. A 96 // temporary area is only needed when parsing utf8 entries in the constant 97 // pool and when parsing line number tables. 98 99 // We add assert in debug mode when class format is not checked. 100 101 #define JAVA_CLASSFILE_MAGIC 0xCAFEBABE 102 #define JAVA_MIN_SUPPORTED_VERSION 45 103 #define JAVA_PREVIEW_MINOR_VERSION 65535 104 105 // Used for two backward compatibility reasons: 106 // - to check for new additions to the class file format in JDK1.5 107 // - to check for bug fixes in the format checker in JDK1.5 108 #define JAVA_1_5_VERSION 49 109 110 // Used for backward compatibility reasons: 111 // - to check for javac bug fixes that happened after 1.5 112 // - also used as the max version when running in jdk6 113 #define JAVA_6_VERSION 50 114 115 // Used for backward compatibility reasons: 116 // - to disallow argument and require ACC_STATIC for <clinit> methods 117 #define JAVA_7_VERSION 51 118 119 // Extension method support. 120 #define JAVA_8_VERSION 52 121 122 #define JAVA_9_VERSION 53 123 124 #define JAVA_10_VERSION 54 125 126 #define JAVA_11_VERSION 55 127 128 #define JAVA_12_VERSION 56 129 130 #define JAVA_13_VERSION 57 131 132 #define JAVA_14_VERSION 58 133 134 #define JAVA_15_VERSION 59 135 136 #define JAVA_16_VERSION 60 137 138 #define JAVA_17_VERSION 61 139 140 #define JAVA_18_VERSION 62 141 142 #define JAVA_19_VERSION 63 143 144 #define JAVA_20_VERSION 64 145 146 #define JAVA_21_VERSION 65 147 148 #define JAVA_22_VERSION 66 149 150 #define JAVA_23_VERSION 67 151 152 #define JAVA_24_VERSION 68 153 154 #define JAVA_25_VERSION 69 155 156 #define JAVA_26_VERSION 70 157 158 #define JAVA_27_VERSION 71 159 160 void ClassFileParser::set_class_bad_constant_seen(short bad_constant) { 161 assert((bad_constant == JVM_CONSTANT_Module || 162 bad_constant == JVM_CONSTANT_Package) && _major_version >= JAVA_9_VERSION, 163 "Unexpected bad constant pool entry"); 164 if (_bad_constant_seen == 0) _bad_constant_seen = bad_constant; 165 } 166 167 void ClassFileParser::parse_constant_pool_entries(const ClassFileStream* const stream, 168 ConstantPool* cp, 169 const int length, 170 TRAPS) { 171 assert(stream != nullptr, "invariant"); 172 assert(cp != nullptr, "invariant"); 173 174 // Use a local copy of ClassFileStream. It helps the C++ compiler to optimize 175 // this function (_current can be allocated in a register, with scalar 176 // replacement of aggregates). The _current pointer is copied back to 177 // stream() when this function returns. DON'T call another method within 178 // this method that uses stream(). 179 const ClassFileStream cfs1 = *stream; 180 const ClassFileStream* const cfs = &cfs1; 181 182 DEBUG_ONLY(const u1* const old_current = stream->current();) 183 184 // Used for batching symbol allocations. 185 const char* names[SymbolTable::symbol_alloc_batch_size]; 186 int lengths[SymbolTable::symbol_alloc_batch_size]; 187 int indices[SymbolTable::symbol_alloc_batch_size]; 188 unsigned int hashValues[SymbolTable::symbol_alloc_batch_size]; 189 int names_count = 0; 190 191 // parsing Index 0 is unused 192 for (int index = 1; index < length; index++) { 193 // Each of the following case guarantees one more byte in the stream 194 // for the following tag or the access_flags following constant pool, 195 // so we don't need bounds-check for reading tag. 196 const u1 tag = cfs->get_u1_fast(); 197 switch (tag) { 198 case JVM_CONSTANT_Class: { 199 cfs->guarantee_more(3, CHECK); // name_index, tag/access_flags 200 const u2 name_index = cfs->get_u2_fast(); 201 cp->klass_index_at_put(index, name_index); 202 break; 203 } 204 case JVM_CONSTANT_Fieldref: { 205 cfs->guarantee_more(5, CHECK); // class_index, name_and_type_index, tag/access_flags 206 const u2 class_index = cfs->get_u2_fast(); 207 const u2 name_and_type_index = cfs->get_u2_fast(); 208 cp->field_at_put(index, class_index, name_and_type_index); 209 break; 210 } 211 case JVM_CONSTANT_Methodref: { 212 cfs->guarantee_more(5, CHECK); // class_index, name_and_type_index, tag/access_flags 213 const u2 class_index = cfs->get_u2_fast(); 214 const u2 name_and_type_index = cfs->get_u2_fast(); 215 cp->method_at_put(index, class_index, name_and_type_index); 216 break; 217 } 218 case JVM_CONSTANT_InterfaceMethodref: { 219 cfs->guarantee_more(5, CHECK); // class_index, name_and_type_index, tag/access_flags 220 const u2 class_index = cfs->get_u2_fast(); 221 const u2 name_and_type_index = cfs->get_u2_fast(); 222 cp->interface_method_at_put(index, class_index, name_and_type_index); 223 break; 224 } 225 case JVM_CONSTANT_String : { 226 cfs->guarantee_more(3, CHECK); // string_index, tag/access_flags 227 const u2 string_index = cfs->get_u2_fast(); 228 cp->string_index_at_put(index, string_index); 229 break; 230 } 231 case JVM_CONSTANT_MethodHandle : 232 case JVM_CONSTANT_MethodType: { 233 if (_major_version < Verifier::INVOKEDYNAMIC_MAJOR_VERSION) { 234 classfile_parse_error( 235 "Class file version does not support constant tag %u in class file %s", 236 tag, THREAD); 237 return; 238 } 239 if (tag == JVM_CONSTANT_MethodHandle) { 240 cfs->guarantee_more(4, CHECK); // ref_kind, method_index, tag/access_flags 241 const u1 ref_kind = cfs->get_u1_fast(); 242 const u2 method_index = cfs->get_u2_fast(); 243 cp->method_handle_index_at_put(index, ref_kind, method_index); 244 } 245 else if (tag == JVM_CONSTANT_MethodType) { 246 cfs->guarantee_more(3, CHECK); // signature_index, tag/access_flags 247 const u2 signature_index = cfs->get_u2_fast(); 248 cp->method_type_index_at_put(index, signature_index); 249 } 250 else { 251 ShouldNotReachHere(); 252 } 253 break; 254 } 255 case JVM_CONSTANT_Dynamic : { 256 if (_major_version < Verifier::DYNAMICCONSTANT_MAJOR_VERSION) { 257 classfile_parse_error( 258 "Class file version does not support constant tag %u in class file %s", 259 tag, THREAD); 260 return; 261 } 262 cfs->guarantee_more(5, CHECK); // bsm_index, nt, tag/access_flags 263 const u2 bootstrap_specifier_index = cfs->get_u2_fast(); 264 const u2 name_and_type_index = cfs->get_u2_fast(); 265 if (_max_bootstrap_specifier_index < (int) bootstrap_specifier_index) { 266 _max_bootstrap_specifier_index = (int) bootstrap_specifier_index; // collect for later 267 } 268 cp->dynamic_constant_at_put(index, bootstrap_specifier_index, name_and_type_index); 269 break; 270 } 271 case JVM_CONSTANT_InvokeDynamic : { 272 if (_major_version < Verifier::INVOKEDYNAMIC_MAJOR_VERSION) { 273 classfile_parse_error( 274 "Class file version does not support constant tag %u in class file %s", 275 tag, THREAD); 276 return; 277 } 278 cfs->guarantee_more(5, CHECK); // bsm_index, nt, tag/access_flags 279 const u2 bootstrap_specifier_index = cfs->get_u2_fast(); 280 const u2 name_and_type_index = cfs->get_u2_fast(); 281 if (_max_bootstrap_specifier_index < (int) bootstrap_specifier_index) { 282 _max_bootstrap_specifier_index = (int) bootstrap_specifier_index; // collect for later 283 } 284 cp->invoke_dynamic_at_put(index, bootstrap_specifier_index, name_and_type_index); 285 break; 286 } 287 case JVM_CONSTANT_Integer: { 288 cfs->guarantee_more(5, CHECK); // bytes, tag/access_flags 289 const u4 bytes = cfs->get_u4_fast(); 290 cp->int_at_put(index, (jint)bytes); 291 break; 292 } 293 case JVM_CONSTANT_Float: { 294 cfs->guarantee_more(5, CHECK); // bytes, tag/access_flags 295 const u4 bytes = cfs->get_u4_fast(); 296 cp->float_at_put(index, *(jfloat*)&bytes); 297 break; 298 } 299 case JVM_CONSTANT_Long: { 300 // A mangled type might cause you to overrun allocated memory 301 guarantee_property(index + 1 < length, 302 "Invalid constant pool entry %u in class file %s", 303 index, 304 CHECK); 305 cfs->guarantee_more(9, CHECK); // bytes, tag/access_flags 306 const u8 bytes = cfs->get_u8_fast(); 307 cp->long_at_put(index, bytes); 308 index++; // Skip entry following eigth-byte constant, see JVM book p. 98 309 break; 310 } 311 case JVM_CONSTANT_Double: { 312 // A mangled type might cause you to overrun allocated memory 313 guarantee_property(index+1 < length, 314 "Invalid constant pool entry %u in class file %s", 315 index, 316 CHECK); 317 cfs->guarantee_more(9, CHECK); // bytes, tag/access_flags 318 const u8 bytes = cfs->get_u8_fast(); 319 cp->double_at_put(index, *(jdouble*)&bytes); 320 index++; // Skip entry following eigth-byte constant, see JVM book p. 98 321 break; 322 } 323 case JVM_CONSTANT_NameAndType: { 324 cfs->guarantee_more(5, CHECK); // name_index, signature_index, tag/access_flags 325 const u2 name_index = cfs->get_u2_fast(); 326 const u2 signature_index = cfs->get_u2_fast(); 327 cp->name_and_type_at_put(index, name_index, signature_index); 328 break; 329 } 330 case JVM_CONSTANT_Utf8 : { 331 cfs->guarantee_more(2, CHECK); // utf8_length 332 u2 utf8_length = cfs->get_u2_fast(); 333 const u1* utf8_buffer = cfs->current(); 334 assert(utf8_buffer != nullptr, "null utf8 buffer"); 335 // Got utf8 string, guarantee utf8_length+1 bytes, set stream position forward. 336 cfs->guarantee_more(utf8_length+1, CHECK); // utf8 string, tag/access_flags 337 cfs->skip_u1_fast(utf8_length); 338 339 // Before storing the symbol, make sure it's legal 340 if (_need_verify) { 341 verify_legal_utf8(utf8_buffer, utf8_length, CHECK); 342 } 343 344 unsigned int hash; 345 Symbol* const result = SymbolTable::lookup_only((const char*)utf8_buffer, 346 utf8_length, 347 hash); 348 if (result == nullptr) { 349 names[names_count] = (const char*)utf8_buffer; 350 lengths[names_count] = utf8_length; 351 indices[names_count] = index; 352 hashValues[names_count++] = hash; 353 if (names_count == SymbolTable::symbol_alloc_batch_size) { 354 SymbolTable::new_symbols(_loader_data, 355 constantPoolHandle(THREAD, cp), 356 names_count, 357 names, 358 lengths, 359 indices, 360 hashValues); 361 names_count = 0; 362 } 363 } else { 364 cp->symbol_at_put(index, result); 365 } 366 break; 367 } 368 case JVM_CONSTANT_Module: 369 case JVM_CONSTANT_Package: { 370 // Record that an error occurred in these two cases but keep parsing so 371 // that ACC_Module can be checked for in the access_flags. Need to 372 // throw NoClassDefFoundError in that case. 373 if (_major_version >= JAVA_9_VERSION) { 374 cfs->guarantee_more(3, CHECK); 375 cfs->get_u2_fast(); 376 set_class_bad_constant_seen(tag); 377 break; 378 } 379 } 380 default: { 381 classfile_parse_error("Unknown constant tag %u in class file %s", 382 tag, 383 THREAD); 384 return; 385 } 386 } // end of switch(tag) 387 } // end of for 388 389 // Allocate the remaining symbols 390 if (names_count > 0) { 391 SymbolTable::new_symbols(_loader_data, 392 constantPoolHandle(THREAD, cp), 393 names_count, 394 names, 395 lengths, 396 indices, 397 hashValues); 398 } 399 400 // Copy _current pointer of local copy back to stream. 401 assert(stream->current() == old_current, "non-exclusive use of stream"); 402 stream->set_current(cfs1.current()); 403 404 } 405 406 static inline bool valid_cp_range(int index, int length) { 407 return (index > 0 && index < length); 408 } 409 410 static inline Symbol* check_symbol_at(const ConstantPool* cp, int index) { 411 assert(cp != nullptr, "invariant"); 412 if (valid_cp_range(index, cp->length()) && cp->tag_at(index).is_utf8()) { 413 return cp->symbol_at(index); 414 } 415 return nullptr; 416 } 417 418 void ClassFileParser::parse_constant_pool(const ClassFileStream* const stream, 419 ConstantPool* const cp, 420 const int length, 421 TRAPS) { 422 assert(cp != nullptr, "invariant"); 423 assert(stream != nullptr, "invariant"); 424 425 // parsing constant pool entries 426 parse_constant_pool_entries(stream, cp, length, CHECK); 427 if (class_bad_constant_seen() != 0) { 428 // a bad CP entry has been detected previously so stop parsing and just return. 429 return; 430 } 431 432 int index = 1; // declared outside of loops for portability 433 int num_klasses = 0; 434 435 // first verification pass - validate cross references 436 // and fixup class and string constants 437 for (index = 1; index < length; index++) { // Index 0 is unused 438 const jbyte tag = cp->tag_at(index).value(); 439 switch (tag) { 440 case JVM_CONSTANT_Class: { 441 ShouldNotReachHere(); // Only JVM_CONSTANT_ClassIndex should be present 442 break; 443 } 444 case JVM_CONSTANT_Fieldref: 445 // fall through 446 case JVM_CONSTANT_Methodref: 447 // fall through 448 case JVM_CONSTANT_InterfaceMethodref: { 449 if (!_need_verify) break; 450 const int klass_ref_index = cp->uncached_klass_ref_index_at(index); 451 const int name_and_type_ref_index = cp->uncached_name_and_type_ref_index_at(index); 452 guarantee_property(valid_klass_reference_at(klass_ref_index), 453 "Invalid constant pool index %u in class file %s", 454 klass_ref_index, CHECK); 455 guarantee_property(valid_cp_range(name_and_type_ref_index, length) && 456 cp->tag_at(name_and_type_ref_index).is_name_and_type(), 457 "Invalid constant pool index %u in class file %s", 458 name_and_type_ref_index, CHECK); 459 break; 460 } 461 case JVM_CONSTANT_String: { 462 ShouldNotReachHere(); // Only JVM_CONSTANT_StringIndex should be present 463 break; 464 } 465 case JVM_CONSTANT_Integer: 466 break; 467 case JVM_CONSTANT_Float: 468 break; 469 case JVM_CONSTANT_Long: 470 case JVM_CONSTANT_Double: { 471 index++; 472 guarantee_property( 473 (index < length && cp->tag_at(index).is_invalid()), 474 "Improper constant pool long/double index %u in class file %s", 475 index, CHECK); 476 break; 477 } 478 case JVM_CONSTANT_NameAndType: { 479 if (!_need_verify) break; 480 const int name_ref_index = cp->name_ref_index_at(index); 481 const int signature_ref_index = cp->signature_ref_index_at(index); 482 guarantee_property(valid_symbol_at(name_ref_index), 483 "Invalid constant pool index %u in class file %s", 484 name_ref_index, CHECK); 485 guarantee_property(valid_symbol_at(signature_ref_index), 486 "Invalid constant pool index %u in class file %s", 487 signature_ref_index, CHECK); 488 break; 489 } 490 case JVM_CONSTANT_Utf8: 491 break; 492 case JVM_CONSTANT_UnresolvedClass: // fall-through 493 case JVM_CONSTANT_UnresolvedClassInError: { 494 ShouldNotReachHere(); // Only JVM_CONSTANT_ClassIndex should be present 495 break; 496 } 497 case JVM_CONSTANT_ClassIndex: { 498 const int class_index = cp->klass_index_at(index); 499 guarantee_property(valid_symbol_at(class_index), 500 "Invalid constant pool index %u in class file %s", 501 class_index, CHECK); 502 503 cp->unresolved_klass_at_put(index, class_index, num_klasses++); 504 break; 505 } 506 case JVM_CONSTANT_StringIndex: { 507 const int string_index = cp->string_index_at(index); 508 guarantee_property(valid_symbol_at(string_index), 509 "Invalid constant pool index %u in class file %s", 510 string_index, CHECK); 511 Symbol* const sym = cp->symbol_at(string_index); 512 cp->unresolved_string_at_put(index, sym); 513 break; 514 } 515 case JVM_CONSTANT_MethodHandle: { 516 const int ref_index = cp->method_handle_index_at(index); 517 guarantee_property(valid_cp_range(ref_index, length), 518 "Invalid constant pool index %u in class file %s", 519 ref_index, CHECK); 520 const constantTag tag = cp->tag_at(ref_index); 521 const int ref_kind = cp->method_handle_ref_kind_at(index); 522 523 switch (ref_kind) { 524 case JVM_REF_getField: 525 case JVM_REF_getStatic: 526 case JVM_REF_putField: 527 case JVM_REF_putStatic: { 528 guarantee_property( 529 tag.is_field(), 530 "Invalid constant pool index %u in class file %s (not a field)", 531 ref_index, CHECK); 532 break; 533 } 534 case JVM_REF_invokeVirtual: 535 case JVM_REF_newInvokeSpecial: { 536 guarantee_property( 537 tag.is_method(), 538 "Invalid constant pool index %u in class file %s (not a method)", 539 ref_index, CHECK); 540 break; 541 } 542 case JVM_REF_invokeStatic: 543 case JVM_REF_invokeSpecial: { 544 guarantee_property( 545 tag.is_method() || 546 ((_major_version >= JAVA_8_VERSION) && tag.is_interface_method()), 547 "Invalid constant pool index %u in class file %s (not a method)", 548 ref_index, CHECK); 549 break; 550 } 551 case JVM_REF_invokeInterface: { 552 guarantee_property( 553 tag.is_interface_method(), 554 "Invalid constant pool index %u in class file %s (not an interface method)", 555 ref_index, CHECK); 556 break; 557 } 558 default: { 559 classfile_parse_error( 560 "Bad method handle kind at constant pool index %u in class file %s", 561 index, THREAD); 562 return; 563 } 564 } // switch(refkind) 565 // Keep the ref_index unchanged. It will be indirected at link-time. 566 break; 567 } // case MethodHandle 568 case JVM_CONSTANT_MethodType: { 569 const int ref_index = cp->method_type_index_at(index); 570 guarantee_property(valid_symbol_at(ref_index), 571 "Invalid constant pool index %u in class file %s", 572 ref_index, CHECK); 573 break; 574 } 575 case JVM_CONSTANT_Dynamic: { 576 const int name_and_type_ref_index = 577 cp->bootstrap_name_and_type_ref_index_at(index); 578 579 guarantee_property(valid_cp_range(name_and_type_ref_index, length) && 580 cp->tag_at(name_and_type_ref_index).is_name_and_type(), 581 "Invalid constant pool index %u in class file %s", 582 name_and_type_ref_index, CHECK); 583 // bootstrap specifier index must be checked later, 584 // when BootstrapMethods attr is available 585 586 // Mark the constant pool as having a CONSTANT_Dynamic_info structure 587 cp->set_has_dynamic_constant(); 588 break; 589 } 590 case JVM_CONSTANT_InvokeDynamic: { 591 const int name_and_type_ref_index = 592 cp->bootstrap_name_and_type_ref_index_at(index); 593 594 guarantee_property(valid_cp_range(name_and_type_ref_index, length) && 595 cp->tag_at(name_and_type_ref_index).is_name_and_type(), 596 "Invalid constant pool index %u in class file %s", 597 name_and_type_ref_index, CHECK); 598 // bootstrap specifier index must be checked later, 599 // when BootstrapMethods attr is available 600 break; 601 } 602 default: { 603 fatal("bad constant pool tag value %u", cp->tag_at(index).value()); 604 ShouldNotReachHere(); 605 break; 606 } 607 } // switch(tag) 608 } // end of for 609 610 cp->allocate_resolved_klasses(_loader_data, num_klasses, CHECK); 611 612 if (!_need_verify) { 613 return; 614 } 615 616 // second verification pass - checks the strings are of the right format. 617 // but not yet to the other entries 618 for (index = 1; index < length; index++) { 619 const jbyte tag = cp->tag_at(index).value(); 620 switch (tag) { 621 case JVM_CONSTANT_UnresolvedClass: { 622 const Symbol* const class_name = cp->klass_name_at(index); 623 // check the name 624 verify_legal_class_name(class_name, CHECK); 625 break; 626 } 627 case JVM_CONSTANT_NameAndType: { 628 if (_need_verify) { 629 const int sig_index = cp->signature_ref_index_at(index); 630 const int name_index = cp->name_ref_index_at(index); 631 const Symbol* const name = cp->symbol_at(name_index); 632 const Symbol* const sig = cp->symbol_at(sig_index); 633 guarantee_property(sig->utf8_length() != 0, 634 "Illegal zero length constant pool entry at %d in class %s", 635 sig_index, CHECK); 636 guarantee_property(name->utf8_length() != 0, 637 "Illegal zero length constant pool entry at %d in class %s", 638 name_index, CHECK); 639 640 if (Signature::is_method(sig)) { 641 // Format check method name and signature 642 verify_legal_method_name(name, CHECK); 643 verify_legal_method_signature(name, sig, CHECK); 644 } else { 645 // Format check field name and signature 646 verify_legal_field_name(name, CHECK); 647 verify_legal_field_signature(name, sig, CHECK); 648 } 649 } 650 break; 651 } 652 case JVM_CONSTANT_Dynamic: { 653 const int name_and_type_ref_index = 654 cp->uncached_name_and_type_ref_index_at(index); 655 // already verified to be utf8 656 const int name_ref_index = 657 cp->name_ref_index_at(name_and_type_ref_index); 658 // already verified to be utf8 659 const int signature_ref_index = 660 cp->signature_ref_index_at(name_and_type_ref_index); 661 const Symbol* const name = cp->symbol_at(name_ref_index); 662 const Symbol* const signature = cp->symbol_at(signature_ref_index); 663 if (_need_verify) { 664 // CONSTANT_Dynamic's name and signature are verified above, when iterating NameAndType_info. 665 // Need only to be sure signature is the right type. 666 if (Signature::is_method(signature)) { 667 throwIllegalSignature("CONSTANT_Dynamic", name, signature, CHECK); 668 } 669 } 670 break; 671 } 672 case JVM_CONSTANT_InvokeDynamic: 673 case JVM_CONSTANT_Fieldref: 674 case JVM_CONSTANT_Methodref: 675 case JVM_CONSTANT_InterfaceMethodref: { 676 const int name_and_type_ref_index = 677 cp->uncached_name_and_type_ref_index_at(index); 678 // already verified to be utf8 679 const int name_ref_index = 680 cp->name_ref_index_at(name_and_type_ref_index); 681 // already verified to be utf8 682 const int signature_ref_index = 683 cp->signature_ref_index_at(name_and_type_ref_index); 684 const Symbol* const name = cp->symbol_at(name_ref_index); 685 const Symbol* const signature = cp->symbol_at(signature_ref_index); 686 if (tag == JVM_CONSTANT_Fieldref) { 687 if (_need_verify) { 688 // Field name and signature are verified above, when iterating NameAndType_info. 689 // Need only to be sure signature is non-zero length and the right type. 690 if (Signature::is_method(signature)) { 691 throwIllegalSignature("Field", name, signature, CHECK); 692 } 693 } 694 } else { 695 if (_need_verify) { 696 // Method name and signature are individually verified above, when iterating 697 // NameAndType_info. Need to check here that signature is non-zero length and 698 // the right type. 699 if (!Signature::is_method(signature)) { 700 throwIllegalSignature("Method", name, signature, CHECK); 701 } 702 } 703 // If a class method name begins with '<', it must be "<init>" and have void signature. 704 const unsigned int name_len = name->utf8_length(); 705 if (tag == JVM_CONSTANT_Methodref && name_len != 0 && 706 name->char_at(0) == JVM_SIGNATURE_SPECIAL) { 707 if (name != vmSymbols::object_initializer_name()) { 708 classfile_parse_error( 709 "Bad method name at constant pool index %u in class file %s", 710 name_ref_index, THREAD); 711 return; 712 } else if (!Signature::is_void_method(signature)) { // must have void signature. 713 throwIllegalSignature("Method", name, signature, CHECK); 714 } 715 } 716 } 717 break; 718 } 719 case JVM_CONSTANT_MethodHandle: { 720 const int ref_index = cp->method_handle_index_at(index); 721 const int ref_kind = cp->method_handle_ref_kind_at(index); 722 switch (ref_kind) { 723 case JVM_REF_invokeVirtual: 724 case JVM_REF_invokeStatic: 725 case JVM_REF_invokeSpecial: 726 case JVM_REF_newInvokeSpecial: { 727 const int name_and_type_ref_index = 728 cp->uncached_name_and_type_ref_index_at(ref_index); 729 const int name_ref_index = 730 cp->name_ref_index_at(name_and_type_ref_index); 731 const Symbol* const name = cp->symbol_at(name_ref_index); 732 if (ref_kind == JVM_REF_newInvokeSpecial) { 733 if (name != vmSymbols::object_initializer_name()) { 734 classfile_parse_error( 735 "Bad constructor name at constant pool index %u in class file %s", 736 name_ref_index, THREAD); 737 return; 738 } 739 } else { 740 if (name == vmSymbols::object_initializer_name()) { 741 classfile_parse_error( 742 "Bad method name at constant pool index %u in class file %s", 743 name_ref_index, THREAD); 744 return; 745 } 746 } 747 break; 748 } 749 // Other ref_kinds are already fully checked in previous pass. 750 } // switch(ref_kind) 751 break; 752 } 753 case JVM_CONSTANT_MethodType: { 754 const Symbol* const no_name = vmSymbols::type_name(); // place holder 755 const Symbol* const signature = cp->method_type_signature_at(index); 756 verify_legal_method_signature(no_name, signature, CHECK); 757 break; 758 } 759 case JVM_CONSTANT_Utf8: { 760 assert(cp->symbol_at(index)->refcount() != 0, "count corrupted"); 761 } 762 } // switch(tag) 763 } // end of for 764 } 765 766 class NameSigHash: public ResourceObj { 767 public: 768 const Symbol* _name; // name 769 const Symbol* _sig; // signature 770 771 static const int HASH_ROW_SIZE = 256; 772 773 NameSigHash(Symbol* name, Symbol* sig) : 774 _name(name), 775 _sig(sig) {} 776 777 static unsigned int hash(NameSigHash const& namesig) { 778 return namesig._name->identity_hash() ^ namesig._sig->identity_hash(); 779 } 780 781 static bool equals(NameSigHash const& e0, NameSigHash const& e1) { 782 return (e0._name == e1._name) && 783 (e0._sig == e1._sig); 784 } 785 }; 786 787 using NameSigHashtable = HashTable<NameSigHash, int, 788 NameSigHash::HASH_ROW_SIZE, 789 AnyObj::RESOURCE_AREA, mtInternal, 790 &NameSigHash::hash, &NameSigHash::equals>; 791 792 // Side-effects: populates the _local_interfaces field 793 void ClassFileParser::parse_interfaces(const ClassFileStream* const stream, 794 const int itfs_len, 795 ConstantPool* const cp, 796 bool* const has_nonstatic_concrete_methods, 797 TRAPS) { 798 assert(stream != nullptr, "invariant"); 799 assert(cp != nullptr, "invariant"); 800 assert(has_nonstatic_concrete_methods != nullptr, "invariant"); 801 802 if (itfs_len == 0) { 803 _local_interfaces = Universe::the_empty_instance_klass_array(); 804 } else { 805 assert(itfs_len > 0, "only called for len>0"); 806 _local_interfaces = MetadataFactory::new_array<InstanceKlass*>(_loader_data, itfs_len, nullptr, CHECK); 807 808 int index; 809 for (index = 0; index < itfs_len; index++) { 810 const u2 interface_index = stream->get_u2(CHECK); 811 Klass* interf; 812 guarantee_property( 813 valid_klass_reference_at(interface_index), 814 "Interface name has bad constant pool index %u in class file %s", 815 interface_index, CHECK); 816 if (cp->tag_at(interface_index).is_klass()) { 817 interf = cp->resolved_klass_at(interface_index); 818 } else { 819 Symbol* const unresolved_klass = cp->klass_name_at(interface_index); 820 821 // Don't need to check legal name because it's checked when parsing constant pool. 822 // But need to make sure it's not an array type. 823 guarantee_property(unresolved_klass->char_at(0) != JVM_SIGNATURE_ARRAY, 824 "Bad interface name in class file %s", CHECK); 825 826 // Call resolve on the interface class name with class circularity checking 827 interf = SystemDictionary::resolve_super_or_fail(_class_name, 828 unresolved_klass, 829 Handle(THREAD, _loader_data->class_loader()), 830 false, CHECK); 831 } 832 833 if (!interf->is_interface()) { 834 THROW_MSG(vmSymbols::java_lang_IncompatibleClassChangeError(), 835 err_msg("class %s can not implement %s, because it is not an interface (%s)", 836 _class_name->as_klass_external_name(), 837 interf->external_name(), 838 interf->class_in_module_of_loader())); 839 } 840 841 if (InstanceKlass::cast(interf)->has_nonstatic_concrete_methods()) { 842 *has_nonstatic_concrete_methods = true; 843 } 844 _local_interfaces->at_put(index, InstanceKlass::cast(interf)); 845 } 846 847 if (!_need_verify || itfs_len <= 1) { 848 return; 849 } 850 851 // Check if there's any duplicates in interfaces 852 ResourceMark rm(THREAD); 853 // Set containing interface names 854 HashTable<Symbol*, int>* interface_names = new HashTable<Symbol*, int>(); 855 for (index = 0; index < itfs_len; index++) { 856 const InstanceKlass* const k = _local_interfaces->at(index); 857 Symbol* interface_name = k->name(); 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); 878 879 const constantTag value_type = cp->tag_at(constantvalue_index); 880 switch(cp->basic_type_for_signature_at(signature_index)) { 881 case T_LONG: { 882 guarantee_property(value_type.is_long(), 883 "Inconsistent constant value type in class file %s", 884 CHECK); 885 break; 886 } 887 case T_FLOAT: { 888 guarantee_property(value_type.is_float(), 889 "Inconsistent constant value type in class file %s", 890 CHECK); 891 break; 892 } 893 case T_DOUBLE: { 894 guarantee_property(value_type.is_double(), 895 "Inconsistent constant value type in class file %s", 896 CHECK); 897 break; 898 } 899 case T_BYTE: 900 case T_CHAR: 901 case T_SHORT: 902 case T_BOOLEAN: 903 case T_INT: { 904 guarantee_property(value_type.is_int(), 905 "Inconsistent constant value type in class file %s", 906 CHECK); 907 break; 908 } 909 case T_OBJECT: { 910 guarantee_property((cp->symbol_at(signature_index)->equals("Ljava/lang/String;") 911 && value_type.is_string()), 912 "Bad string initial value in class file %s", 913 CHECK); 914 break; 915 } 916 default: { 917 classfile_parse_error("Unable to set initial value %u in class file %s", 918 constantvalue_index, 919 THREAD); 920 } 921 } 922 } 923 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 _jdk_internal_vm_annotation_TrustFinalFields, 951 _annotation_LIMIT 952 }; 953 const Location _location; 954 int _annotations_present; 955 u2 _contended_group; 956 957 AnnotationCollector(Location location) 958 : _location(location), _annotations_present(0), _contended_group(0) 959 { 960 assert((int)_annotation_LIMIT <= (int)sizeof(_annotations_present) * BitsPerByte, ""); 961 } 962 // If this annotation name has an ID, report it (or _none). 963 ID annotation_index(const ClassLoaderData* loader_data, const Symbol* name, bool can_access_vm_annotations); 964 // Set the annotation name: 965 void set_annotation(ID id) { 966 assert((int)id >= 0 && (int)id < (int)_annotation_LIMIT, "oob"); 967 _annotations_present |= (int)nth_bit((int)id); 968 } 969 970 void remove_annotation(ID id) { 971 assert((int)id >= 0 && (int)id < (int)_annotation_LIMIT, "oob"); 972 _annotations_present &= (int)~nth_bit((int)id); 973 } 974 975 // Report if the annotation is present. 976 bool has_any_annotations() const { return _annotations_present != 0; } 977 bool has_annotation(ID id) const { return (nth_bit((int)id) & _annotations_present) != 0; } 978 979 void set_contended_group(u2 group) { _contended_group = group; } 980 u2 contended_group() const { return _contended_group; } 981 982 bool is_contended() const { return has_annotation(_jdk_internal_vm_annotation_Contended); } 983 984 void set_stable(bool stable) { set_annotation(_field_Stable); } 985 bool is_stable() const { return has_annotation(_field_Stable); } 986 987 bool has_aot_runtime_setup() const { return has_annotation(_method_AOTRuntimeSetup); } 988 }; 989 990 // This class also doubles as a holder for metadata cleanup. 991 class ClassFileParser::FieldAnnotationCollector : public AnnotationCollector { 992 private: 993 ClassLoaderData* _loader_data; 994 AnnotationArray* _field_annotations; 995 AnnotationArray* _field_type_annotations; 996 public: 997 FieldAnnotationCollector(ClassLoaderData* loader_data) : 998 AnnotationCollector(_in_field), 999 _loader_data(loader_data), 1000 _field_annotations(nullptr), 1001 _field_type_annotations(nullptr) {} 1002 ~FieldAnnotationCollector(); 1003 void apply_to(FieldInfo* f); 1004 AnnotationArray* field_annotations() { return _field_annotations; } 1005 AnnotationArray* field_type_annotations() { return _field_type_annotations; } 1006 1007 void set_field_annotations(AnnotationArray* a) { _field_annotations = a; } 1008 void set_field_type_annotations(AnnotationArray* a) { _field_type_annotations = a; } 1009 }; 1010 1011 class MethodAnnotationCollector : public AnnotationCollector{ 1012 public: 1013 MethodAnnotationCollector() : AnnotationCollector(_in_method) { } 1014 void apply_to(const methodHandle& m); 1015 }; 1016 1017 class ClassFileParser::ClassAnnotationCollector : public AnnotationCollector{ 1018 public: 1019 ClassAnnotationCollector() : AnnotationCollector(_in_class) { } 1020 void apply_to(InstanceKlass* ik); 1021 }; 1022 1023 1024 static int skip_annotation_value(const u1* buffer, int limit, int index, int recursion_depth); // fwd decl 1025 static const int max_recursion_depth = 5; 1026 1027 // Safely increment index by val if does not pass limit 1028 #define SAFE_ADD(index, limit, val) \ 1029 if (index >= limit - val) return limit; \ 1030 index += val; 1031 1032 // Skip an annotation. Return >=limit if there is any problem. 1033 static int skip_annotation(const u1* buffer, int limit, int index, int recursion_depth = 0) { 1034 assert(buffer != nullptr, "invariant"); 1035 if (recursion_depth > max_recursion_depth) { 1036 return limit; 1037 } 1038 // annotation := atype:u2 do(nmem:u2) {member:u2 value} 1039 // value := switch (tag:u1) { ... } 1040 SAFE_ADD(index, limit, 4); // skip atype and read nmem 1041 int nmem = Bytes::get_Java_u2((address)buffer + index - 2); 1042 while (--nmem >= 0 && index < limit) { 1043 SAFE_ADD(index, limit, 2); // skip member 1044 index = skip_annotation_value(buffer, limit, index, recursion_depth + 1); 1045 } 1046 return index; 1047 } 1048 1049 // Skip an annotation value. Return >=limit if there is any problem. 1050 static int skip_annotation_value(const u1* buffer, int limit, int index, int recursion_depth) { 1051 assert(buffer != nullptr, "invariant"); 1052 1053 if (recursion_depth > max_recursion_depth) { 1054 return limit; 1055 } 1056 // value := switch (tag:u1) { 1057 // case B, C, I, S, Z, D, F, J, c: con:u2; 1058 // case e: e_class:u2 e_name:u2; 1059 // case s: s_con:u2; 1060 // case [: do(nval:u2) {value}; 1061 // case @: annotation; 1062 // case s: s_con:u2; 1063 // } 1064 SAFE_ADD(index, limit, 1); // read tag 1065 const u1 tag = buffer[index - 1]; 1066 switch (tag) { 1067 case 'B': 1068 case 'C': 1069 case 'I': 1070 case 'S': 1071 case 'Z': 1072 case 'D': 1073 case 'F': 1074 case 'J': 1075 case 'c': 1076 case 's': 1077 SAFE_ADD(index, limit, 2); // skip con or s_con 1078 break; 1079 case 'e': 1080 SAFE_ADD(index, limit, 4); // skip e_class, e_name 1081 break; 1082 case '[': 1083 { 1084 SAFE_ADD(index, limit, 2); // read nval 1085 int nval = Bytes::get_Java_u2((address)buffer + index - 2); 1086 while (--nval >= 0 && index < limit) { 1087 index = skip_annotation_value(buffer, limit, index, recursion_depth + 1); 1088 } 1089 } 1090 break; 1091 case '@': 1092 index = skip_annotation(buffer, limit, index, recursion_depth + 1); 1093 break; 1094 default: 1095 return limit; // bad tag byte 1096 } 1097 return index; 1098 } 1099 1100 // Sift through annotations, looking for those significant to the VM: 1101 static void parse_annotations(const ConstantPool* const cp, 1102 const u1* buffer, int limit, 1103 AnnotationCollector* coll, 1104 ClassLoaderData* loader_data, 1105 const bool can_access_vm_annotations) { 1106 1107 assert(cp != nullptr, "invariant"); 1108 assert(buffer != nullptr, "invariant"); 1109 assert(coll != nullptr, "invariant"); 1110 assert(loader_data != nullptr, "invariant"); 1111 1112 // annotations := do(nann:u2) {annotation} 1113 int index = 2; // read nann 1114 if (index >= limit) return; 1115 int nann = Bytes::get_Java_u2((address)buffer + index - 2); 1116 enum { // initial annotation layout 1117 atype_off = 0, // utf8 such as 'Ljava/lang/annotation/Retention;' 1118 count_off = 2, // u2 such as 1 (one value) 1119 member_off = 4, // utf8 such as 'value' 1120 tag_off = 6, // u1 such as 'c' (type) or 'e' (enum) 1121 e_tag_val = 'e', 1122 e_type_off = 7, // utf8 such as 'Ljava/lang/annotation/RetentionPolicy;' 1123 e_con_off = 9, // utf8 payload, such as 'SOURCE', 'CLASS', 'RUNTIME' 1124 e_size = 11, // end of 'e' annotation 1125 c_tag_val = 'c', // payload is type 1126 c_con_off = 7, // utf8 payload, such as 'I' 1127 c_size = 9, // end of 'c' annotation 1128 s_tag_val = 's', // payload is String 1129 s_con_off = 7, // utf8 payload, such as 'Ljava/lang/String;' 1130 s_size = 9, 1131 b_tag_val = 'Z', // payload is boolean 1132 min_size = 6 // smallest possible size (zero members) 1133 }; 1134 // Cannot add min_size to index in case of overflow MAX_INT 1135 while ((--nann) >= 0 && (index - 2 <= limit - min_size)) { 1136 int index0 = index; 1137 index = skip_annotation(buffer, limit, index); 1138 const u1* const abase = buffer + index0; 1139 const int atype = Bytes::get_Java_u2((address)abase + atype_off); 1140 const int count = Bytes::get_Java_u2((address)abase + count_off); 1141 const Symbol* const aname = check_symbol_at(cp, atype); 1142 if (aname == nullptr) break; // invalid annotation name 1143 const Symbol* member = nullptr; 1144 if (count >= 1) { 1145 const int member_index = Bytes::get_Java_u2((address)abase + member_off); 1146 member = check_symbol_at(cp, member_index); 1147 if (member == nullptr) break; // invalid member name 1148 } 1149 1150 // Here is where parsing particular annotations will take place. 1151 AnnotationCollector::ID id = coll->annotation_index(loader_data, aname, can_access_vm_annotations); 1152 if (AnnotationCollector::_unknown == id) continue; 1153 coll->set_annotation(id); 1154 if (AnnotationCollector::_java_lang_Deprecated == id) { 1155 // @Deprecated can specify forRemoval=true, which we need 1156 // to record for JFR to use. If the annotation is not well-formed 1157 // then we may not be able to determine that. 1158 const u1* offset = abase + member_off; 1159 // There are only 2 members in @Deprecated. 1160 int n_members = MIN2(count, 2); 1161 for (int i = 0; i < n_members; ++i) { 1162 int member_index = Bytes::get_Java_u2((address)offset); 1163 offset += 2; 1164 member = check_symbol_at(cp, member_index); 1165 if (member == vmSymbols::since() && 1166 (*((address)offset) == s_tag_val)) { 1167 // Found `since` first so skip over it 1168 offset += 3; 1169 } 1170 else if (member == vmSymbols::for_removal() && 1171 (*((address)offset) == b_tag_val)) { 1172 const u2 boolean_value_index = Bytes::get_Java_u2((address)offset + 1); 1173 // No guarantee the entry is valid so check it refers to an int in the CP. 1174 if (cp->is_within_bounds(boolean_value_index) && 1175 cp->tag_at(boolean_value_index).is_int() && 1176 cp->int_at(boolean_value_index) == 1) { 1177 // forRemoval == true 1178 coll->set_annotation(AnnotationCollector::_java_lang_Deprecated_for_removal); 1179 } 1180 break; // no need to check further 1181 } 1182 else { 1183 // This @Deprecated annotation is malformed so we don't try to 1184 // determine whether forRemoval is set. 1185 break; 1186 } 1187 } 1188 continue; // proceed to next annotation 1189 } 1190 1191 if (AnnotationCollector::_jdk_internal_vm_annotation_Contended == id) { 1192 // @Contended can optionally specify the contention group. 1193 // 1194 // Contended group defines the equivalence class over the fields: 1195 // the fields within the same contended group are not treated distinct. 1196 // The only exception is default group, which does not incur the 1197 // equivalence. Naturally, contention group for classes is meaningless. 1198 // 1199 // While the contention group is specified as String, annotation 1200 // values are already interned, and we might as well use the constant 1201 // pool index as the group tag. 1202 // 1203 u2 group_index = 0; // default contended group 1204 if (count == 1 1205 && s_size == (index - index0) // match size 1206 && s_tag_val == *(abase + tag_off) 1207 && member == vmSymbols::value_name()) { 1208 group_index = Bytes::get_Java_u2((address)abase + s_con_off); 1209 // No guarantee the group_index is valid so check it refers to a 1210 // symbol in the CP. 1211 if (cp->is_within_bounds(group_index) && 1212 cp->tag_at(group_index).is_utf8()) { 1213 // Seems valid, so check for empty string and reset 1214 if (cp->symbol_at(group_index)->utf8_length() == 0) { 1215 group_index = 0; // default contended group 1216 } 1217 } else { 1218 // Not valid so use the default 1219 group_index = 0; 1220 } 1221 } 1222 coll->set_contended_group(group_index); 1223 continue; // proceed to next annotation 1224 } 1225 } 1226 } 1227 1228 1229 // Parse attributes for a field. 1230 void ClassFileParser::parse_field_attributes(const ClassFileStream* const cfs, 1231 u2 attributes_count, 1232 bool is_static, u2 signature_index, 1233 u2* const constantvalue_index_addr, 1234 bool* const is_synthetic_addr, 1235 u2* const generic_signature_index_addr, 1236 ClassFileParser::FieldAnnotationCollector* parsed_annotations, 1237 TRAPS) { 1238 assert(cfs != nullptr, "invariant"); 1239 assert(constantvalue_index_addr != nullptr, "invariant"); 1240 assert(is_synthetic_addr != nullptr, "invariant"); 1241 assert(generic_signature_index_addr != nullptr, "invariant"); 1242 assert(parsed_annotations != nullptr, "invariant"); 1243 assert(attributes_count > 0, "attributes_count should be greater than 0"); 1244 1245 u2 constantvalue_index = 0; 1246 u2 generic_signature_index = 0; 1247 bool is_synthetic = false; 1248 const u1* runtime_visible_annotations = nullptr; 1249 int runtime_visible_annotations_length = 0; 1250 const u1* runtime_visible_type_annotations = nullptr; 1251 int runtime_visible_type_annotations_length = 0; 1252 bool runtime_invisible_annotations_exists = false; 1253 bool runtime_invisible_type_annotations_exists = false; 1254 const ConstantPool* const cp = _cp; 1255 1256 while (attributes_count--) { 1257 cfs->guarantee_more(6, CHECK); // attribute_name_index, attribute_length 1258 const u2 attribute_name_index = cfs->get_u2_fast(); 1259 const u4 attribute_length = cfs->get_u4_fast(); 1260 guarantee_property(valid_symbol_at(attribute_name_index), 1261 "Invalid field attribute index %u in class file %s", 1262 attribute_name_index, 1263 CHECK); 1264 1265 const Symbol* const attribute_name = cp->symbol_at(attribute_name_index); 1266 if (is_static && attribute_name == vmSymbols::tag_constant_value()) { 1267 // ignore if non-static 1268 if (constantvalue_index != 0) { 1269 classfile_parse_error("Duplicate ConstantValue attribute in class file %s", THREAD); 1270 return; 1271 } 1272 guarantee_property( 1273 attribute_length == 2, 1274 "Invalid ConstantValue field attribute length %u in class file %s", 1275 attribute_length, CHECK); 1276 1277 constantvalue_index = cfs->get_u2(CHECK); 1278 if (_need_verify) { 1279 verify_constantvalue(cp, constantvalue_index, signature_index, CHECK); 1280 } 1281 } else if (attribute_name == vmSymbols::tag_synthetic()) { 1282 if (attribute_length != 0) { 1283 classfile_parse_error( 1284 "Invalid Synthetic field attribute length %u in class file %s", 1285 attribute_length, THREAD); 1286 return; 1287 } 1288 is_synthetic = true; 1289 } else if (attribute_name == vmSymbols::tag_deprecated()) { // 4276120 1290 if (attribute_length != 0) { 1291 classfile_parse_error( 1292 "Invalid Deprecated field attribute length %u in class file %s", 1293 attribute_length, THREAD); 1294 return; 1295 } 1296 } else if (_major_version >= JAVA_1_5_VERSION) { 1297 if (attribute_name == vmSymbols::tag_signature()) { 1298 if (generic_signature_index != 0) { 1299 classfile_parse_error( 1300 "Multiple Signature attributes for field in class file %s", THREAD); 1301 return; 1302 } 1303 if (attribute_length != 2) { 1304 classfile_parse_error( 1305 "Wrong size %u for field's Signature attribute in class file %s", 1306 attribute_length, THREAD); 1307 return; 1308 } 1309 generic_signature_index = parse_generic_signature_attribute(cfs, CHECK); 1310 } else if (attribute_name == vmSymbols::tag_runtime_visible_annotations()) { 1311 if (runtime_visible_annotations != nullptr) { 1312 classfile_parse_error( 1313 "Multiple RuntimeVisibleAnnotations attributes for field in class file %s", THREAD); 1314 return; 1315 } 1316 runtime_visible_annotations_length = attribute_length; 1317 runtime_visible_annotations = cfs->current(); 1318 assert(runtime_visible_annotations != nullptr, "null visible annotations"); 1319 cfs->guarantee_more(runtime_visible_annotations_length, CHECK); 1320 parse_annotations(cp, 1321 runtime_visible_annotations, 1322 runtime_visible_annotations_length, 1323 parsed_annotations, 1324 _loader_data, 1325 _can_access_vm_annotations); 1326 cfs->skip_u1_fast(runtime_visible_annotations_length); 1327 } else if (attribute_name == vmSymbols::tag_runtime_invisible_annotations()) { 1328 if (runtime_invisible_annotations_exists) { 1329 classfile_parse_error( 1330 "Multiple RuntimeInvisibleAnnotations attributes for field in class file %s", THREAD); 1331 return; 1332 } 1333 runtime_invisible_annotations_exists = true; 1334 cfs->skip_u1(attribute_length, CHECK); 1335 } else if (attribute_name == vmSymbols::tag_runtime_visible_type_annotations()) { 1336 if (runtime_visible_type_annotations != nullptr) { 1337 classfile_parse_error( 1338 "Multiple RuntimeVisibleTypeAnnotations attributes for field in class file %s", THREAD); 1339 return; 1340 } 1341 runtime_visible_type_annotations_length = attribute_length; 1342 runtime_visible_type_annotations = cfs->current(); 1343 assert(runtime_visible_type_annotations != nullptr, "null visible type annotations"); 1344 cfs->skip_u1(runtime_visible_type_annotations_length, CHECK); 1345 } else if (attribute_name == vmSymbols::tag_runtime_invisible_type_annotations()) { 1346 if (runtime_invisible_type_annotations_exists) { 1347 classfile_parse_error( 1348 "Multiple RuntimeInvisibleTypeAnnotations attributes for field in class file %s", THREAD); 1349 return; 1350 } else { 1351 runtime_invisible_type_annotations_exists = true; 1352 } 1353 cfs->skip_u1(attribute_length, CHECK); 1354 } else { 1355 cfs->skip_u1(attribute_length, CHECK); // Skip unknown attributes 1356 } 1357 } else { 1358 cfs->skip_u1(attribute_length, CHECK); // Skip unknown attributes 1359 } 1360 } 1361 1362 *constantvalue_index_addr = constantvalue_index; 1363 *is_synthetic_addr = is_synthetic; 1364 *generic_signature_index_addr = generic_signature_index; 1365 AnnotationArray* a = allocate_annotations(runtime_visible_annotations, 1366 runtime_visible_annotations_length, 1367 CHECK); 1368 parsed_annotations->set_field_annotations(a); 1369 a = allocate_annotations(runtime_visible_type_annotations, 1370 runtime_visible_type_annotations_length, 1371 CHECK); 1372 parsed_annotations->set_field_type_annotations(a); 1373 return; 1374 } 1375 1376 1377 // Side-effects: populates the _fields, _fields_annotations, 1378 // _fields_type_annotations fields 1379 void ClassFileParser::parse_fields(const ClassFileStream* const cfs, 1380 AccessFlags class_access_flags, 1381 ConstantPool* cp, 1382 const int cp_size, 1383 u2* const java_fields_count_ptr, 1384 TRAPS) { 1385 1386 assert(cfs != nullptr, "invariant"); 1387 assert(cp != nullptr, "invariant"); 1388 assert(java_fields_count_ptr != nullptr, "invariant"); 1389 1390 assert(nullptr == _fields_annotations, "invariant"); 1391 assert(nullptr == _fields_type_annotations, "invariant"); 1392 1393 // "inline type" means concrete value class 1394 bool is_inline_type = !class_access_flags.is_identity_class() && !class_access_flags.is_abstract(); 1395 // "value class" can be either abstract or concrete value class 1396 bool is_value_class = !class_access_flags.is_identity_class() && !class_access_flags.is_interface(); 1397 cfs->guarantee_more(2, CHECK); // length 1398 const u2 length = cfs->get_u2_fast(); 1399 *java_fields_count_ptr = length; 1400 1401 int num_injected = 0; 1402 const InjectedField* const injected = JavaClasses::get_injected(_class_name, 1403 &num_injected); 1404 1405 // Two more slots are required for inline classes: 1406 // - The static field ".null_reset" which carries the nullable flat layout 1407 // representation of null, added below 1408 // - The nonstatic field ".empty" the JVM injects when detecting an empty 1409 // inline class, added in FieldLayoutBuilder::compute_inline_class_layout 1410 // One more slot is required for both abstract value class and inline classes: 1411 // - The static field ".acmp_maps" for acmp and identity hash, tracks 1412 // nonstatic fields both inherited or declared, added below 1413 const int total_fields = length + num_injected + (is_inline_type ? 2 : 0) 1414 + (is_value_class ? 1 : 0); 1415 1416 // Allocate a temporary resource array to collect field data. 1417 // After parsing all fields, data are stored in a UNSIGNED5 compressed stream. 1418 _temp_field_info = new GrowableArray<FieldInfo>(total_fields); 1419 1420 ResourceMark rm(THREAD); 1421 for (int n = 0; n < length; n++) { 1422 // access_flags, name_index, descriptor_index, attributes_count 1423 cfs->guarantee_more(8, CHECK); 1424 1425 jint recognized_modifiers = JVM_RECOGNIZED_FIELD_MODIFIERS; 1426 if (!supports_inline_types()) { 1427 recognized_modifiers &= ~JVM_ACC_STRICT_INIT; 1428 } 1429 1430 const jint flags = cfs->get_u2_fast() & recognized_modifiers; 1431 verify_legal_field_modifiers(flags, class_access_flags, CHECK); 1432 AccessFlags access_flags; 1433 access_flags.set_flags(flags); 1434 FieldInfo::FieldFlags fieldFlags(0); 1435 1436 const u2 name_index = cfs->get_u2_fast(); 1437 guarantee_property(valid_symbol_at(name_index), 1438 "Invalid constant pool index %u for field name in class file %s", 1439 name_index, CHECK); 1440 const Symbol* const name = cp->symbol_at(name_index); 1441 verify_legal_field_name(name, CHECK); 1442 1443 const u2 signature_index = cfs->get_u2_fast(); 1444 guarantee_property(valid_symbol_at(signature_index), 1445 "Invalid constant pool index %u for field signature in class file %s", 1446 signature_index, CHECK); 1447 const Symbol* const sig = cp->symbol_at(signature_index); 1448 verify_legal_field_signature(name, sig, CHECK); 1449 1450 u2 constantvalue_index = 0; 1451 bool is_synthetic = false; 1452 u2 generic_signature_index = 0; 1453 const bool is_static = access_flags.is_static(); 1454 FieldAnnotationCollector parsed_annotations(_loader_data); 1455 1456 bool is_null_restricted = false; 1457 1458 const u2 attributes_count = cfs->get_u2_fast(); 1459 if (attributes_count > 0) { 1460 parse_field_attributes(cfs, 1461 attributes_count, 1462 is_static, 1463 signature_index, 1464 &constantvalue_index, 1465 &is_synthetic, 1466 &generic_signature_index, 1467 &parsed_annotations, 1468 CHECK); 1469 1470 if (parsed_annotations.field_annotations() != nullptr) { 1471 if (_fields_annotations == nullptr) { 1472 _fields_annotations = MetadataFactory::new_array<AnnotationArray*>( 1473 _loader_data, length, nullptr, 1474 CHECK); 1475 } 1476 _fields_annotations->at_put(n, parsed_annotations.field_annotations()); 1477 parsed_annotations.set_field_annotations(nullptr); 1478 if (parsed_annotations.has_annotation(AnnotationCollector::_jdk_internal_NullRestricted)) { 1479 if (!Signature::has_envelope(sig)) { 1480 Exceptions::fthrow( 1481 THREAD_AND_LOCATION, 1482 vmSymbols::java_lang_ClassFormatError(), 1483 "Illegal use of @jdk.internal.vm.annotation.NullRestricted annotation on field %s.%s with signature %s (primitive types can never be null)", 1484 class_name()->as_C_string(), name->as_C_string(), sig->as_C_string()); 1485 return; 1486 } 1487 if (!supports_inline_types()) { 1488 Exceptions::fthrow( 1489 THREAD_AND_LOCATION, 1490 vmSymbols::java_lang_ClassFormatError(), 1491 "Illegal use of @jdk.internal.vm.annotation.NullRestricted annotation on field %s.%s in non-preview class file", 1492 class_name()->as_C_string(), name->as_C_string()); 1493 return; 1494 } 1495 1496 if ((flags & JVM_ACC_STRICT_INIT) == 0) { 1497 // Inject STRICT_INIT and validate in context 1498 const jint patched_flags = flags | JVM_ACC_STRICT_INIT; 1499 verify_legal_field_modifiers(patched_flags, class_access_flags, CHECK); 1500 access_flags.set_flags(patched_flags); 1501 } 1502 is_null_restricted = true; 1503 } 1504 } 1505 if (parsed_annotations.field_type_annotations() != nullptr) { 1506 if (_fields_type_annotations == nullptr) { 1507 _fields_type_annotations = 1508 MetadataFactory::new_array<AnnotationArray*>(_loader_data, 1509 length, 1510 nullptr, 1511 CHECK); 1512 } 1513 _fields_type_annotations->at_put(n, parsed_annotations.field_type_annotations()); 1514 parsed_annotations.set_field_type_annotations(nullptr); 1515 } 1516 1517 if (is_synthetic) { 1518 access_flags.set_is_synthetic(); 1519 } 1520 if (generic_signature_index != 0) { 1521 fieldFlags.update_generic(true); 1522 } 1523 } 1524 1525 if (is_null_restricted) { 1526 fieldFlags.update_null_free_inline_type(true); 1527 } 1528 1529 const BasicType type = cp->basic_type_for_signature_at(signature_index); 1530 1531 // Update number of static oop fields. 1532 if (is_static && is_reference_type(type)) { 1533 _static_oop_count++; 1534 } 1535 1536 FieldInfo fi(access_flags, name_index, signature_index, constantvalue_index, fieldFlags); 1537 fi.set_index(n); 1538 if (fieldFlags.is_generic()) { 1539 fi.set_generic_signature_index(generic_signature_index); 1540 } 1541 parsed_annotations.apply_to(&fi); 1542 if (fi.field_flags().is_contended()) { 1543 _has_contended_fields = true; 1544 } 1545 if (access_flags.is_strict() && access_flags.is_static()) { 1546 _has_strict_static_fields = true; 1547 } 1548 _temp_field_info->append(fi); 1549 } 1550 assert(_temp_field_info->length() == length, "Must be"); 1551 1552 if (num_injected != 0) { 1553 for (int n = 0; n < num_injected; n++) { 1554 // Check for duplicates 1555 if (injected[n].may_be_java) { 1556 const Symbol* const name = injected[n].name(); 1557 const Symbol* const signature = injected[n].signature(); 1558 bool duplicate = false; 1559 for (int i = 0; i < length; i++) { 1560 const FieldInfo* const f = _temp_field_info->adr_at(i); 1561 if (name == cp->symbol_at(f->name_index()) && 1562 signature == cp->symbol_at(f->signature_index())) { 1563 // Symbol is desclared in Java so skip this one 1564 duplicate = true; 1565 break; 1566 } 1567 } 1568 if (duplicate) { 1569 // These will be removed from the field array at the end 1570 continue; 1571 } 1572 } 1573 1574 // Injected field 1575 FieldInfo::FieldFlags fflags(0); 1576 fflags.update_injected(true); 1577 AccessFlags aflags; 1578 FieldInfo fi(aflags, (u2)(injected[n].name_index), (u2)(injected[n].signature_index), 0, fflags); 1579 int idx = _temp_field_info->append(fi); 1580 _temp_field_info->adr_at(idx)->set_index(idx); 1581 } 1582 } 1583 1584 if (is_inline_type) { 1585 // Inject static ".null_reset" field. This is an all-zero value with its null-channel set to zero. 1586 // It should never be seen by user code, it is used when writing "null" to a nullable flat field 1587 // The all-zero value ensure that any embedded oop will be set to null, to avoid keeping dead objects 1588 // alive. 1589 FieldInfo::FieldFlags fflags2(0); 1590 fflags2.update_injected(true); 1591 AccessFlags aflags2(JVM_ACC_STATIC); 1592 FieldInfo fi2(aflags2, 1593 (u2)vmSymbols::as_int(VM_SYMBOL_ENUM_NAME(null_reset_value_name)), 1594 (u2)vmSymbols::as_int(VM_SYMBOL_ENUM_NAME(object_signature)), 1595 0, 1596 fflags2); 1597 int idx2 = _temp_field_info->append(fi2); 1598 _temp_field_info->adr_at(idx2)->set_index(idx2); 1599 _static_oop_count++; 1600 } 1601 if (!access_flags().is_identity_class() && !access_flags().is_interface() 1602 && _class_name != vmSymbols::java_lang_Object()) { 1603 // Acmp map ".acmp_maps" required for abstract and concrete value classes 1604 FieldInfo::FieldFlags fflags2(0); 1605 fflags2.update_injected(true); 1606 fflags2.update_stable(true); 1607 AccessFlags aflags2(JVM_ACC_STATIC | JVM_ACC_FINAL); 1608 FieldInfo fi3(aflags2, 1609 (u2)vmSymbols::as_int(VM_SYMBOL_ENUM_NAME(acmp_maps_name)), 1610 (u2)vmSymbols::as_int(VM_SYMBOL_ENUM_NAME(int_array_signature)), 1611 0, 1612 fflags2); 1613 int idx2 = _temp_field_info->append(fi3); 1614 _temp_field_info->adr_at(idx2)->set_index(idx2); 1615 _static_oop_count++; 1616 } 1617 1618 if (_need_verify && length > 1) { 1619 // Check duplicated fields 1620 ResourceMark rm(THREAD); 1621 // Set containing name-signature pairs 1622 NameSigHashtable* names_and_sigs = new NameSigHashtable(); 1623 for (int i = 0; i < _temp_field_info->length(); i++) { 1624 NameSigHash name_and_sig(_temp_field_info->adr_at(i)->name(_cp), 1625 _temp_field_info->adr_at(i)->signature(_cp)); 1626 // If no duplicates, add name/signature in hashtable names_and_sigs. 1627 if(!names_and_sigs->put(name_and_sig, 0)) { 1628 classfile_parse_error("Duplicate field name \"%s\" with signature \"%s\" in class file %s", 1629 name_and_sig._name->as_C_string(), name_and_sig._sig->as_klass_external_name(), THREAD); 1630 return; 1631 } 1632 } 1633 } 1634 } 1635 1636 1637 const ClassFileParser::unsafe_u2* ClassFileParser::parse_exception_table(const ClassFileStream* const cfs, 1638 u4 code_length, 1639 u4 exception_table_length, 1640 TRAPS) { 1641 assert(cfs != nullptr, "invariant"); 1642 1643 const unsafe_u2* const exception_table_start = cfs->current(); 1644 assert(exception_table_start != nullptr, "null exception table"); 1645 1646 cfs->guarantee_more(8 * exception_table_length, CHECK_NULL); // start_pc, 1647 // end_pc, 1648 // handler_pc, 1649 // catch_type_index 1650 1651 // Will check legal target after parsing code array in verifier. 1652 if (_need_verify) { 1653 for (unsigned int i = 0; i < exception_table_length; i++) { 1654 const u2 start_pc = cfs->get_u2_fast(); 1655 const u2 end_pc = cfs->get_u2_fast(); 1656 const u2 handler_pc = cfs->get_u2_fast(); 1657 const u2 catch_type_index = cfs->get_u2_fast(); 1658 guarantee_property((start_pc < end_pc) && (end_pc <= code_length), 1659 "Illegal exception table range in class file %s", 1660 CHECK_NULL); 1661 guarantee_property(handler_pc < code_length, 1662 "Illegal exception table handler in class file %s", 1663 CHECK_NULL); 1664 if (catch_type_index != 0) { 1665 guarantee_property(valid_klass_reference_at(catch_type_index), 1666 "Catch type in exception table has bad constant type in class file %s", CHECK_NULL); 1667 } 1668 } 1669 } else { 1670 cfs->skip_u2_fast(exception_table_length * 4); 1671 } 1672 return exception_table_start; 1673 } 1674 1675 void ClassFileParser::parse_linenumber_table(u4 code_attribute_length, 1676 u4 code_length, 1677 CompressedLineNumberWriteStream**const write_stream, 1678 TRAPS) { 1679 1680 const ClassFileStream* const cfs = _stream; 1681 unsigned int num_entries = cfs->get_u2(CHECK); 1682 1683 // Each entry is a u2 start_pc, and a u2 line_number 1684 const unsigned int length_in_bytes = num_entries * (sizeof(u2) * 2); 1685 1686 // Verify line number attribute and table length 1687 guarantee_property( 1688 code_attribute_length == sizeof(u2) + length_in_bytes, 1689 "LineNumberTable attribute has wrong length in class file %s", CHECK); 1690 1691 cfs->guarantee_more(length_in_bytes, CHECK); 1692 1693 if ((*write_stream) == nullptr) { 1694 if (length_in_bytes > fixed_buffer_size) { 1695 (*write_stream) = new CompressedLineNumberWriteStream(length_in_bytes); 1696 } else { 1697 (*write_stream) = new CompressedLineNumberWriteStream( 1698 _linenumbertable_buffer, fixed_buffer_size); 1699 } 1700 } 1701 1702 while (num_entries-- > 0) { 1703 const u2 bci = cfs->get_u2_fast(); // start_pc 1704 const u2 line = cfs->get_u2_fast(); // line_number 1705 guarantee_property(bci < code_length, 1706 "Invalid pc in LineNumberTable in class file %s", CHECK); 1707 (*write_stream)->write_pair(bci, line); 1708 } 1709 } 1710 1711 1712 class LVT_Hash : public AllStatic { 1713 public: 1714 1715 static bool equals(LocalVariableTableElement const& e0, LocalVariableTableElement const& e1) { 1716 /* 1717 * 3-tuple start_bci/length/slot has to be unique key, 1718 * so the following comparison seems to be redundant: 1719 * && elem->name_cp_index == entry->_elem->name_cp_index 1720 */ 1721 return (e0.start_bci == e1.start_bci && 1722 e0.length == e1.length && 1723 e0.name_cp_index == e1.name_cp_index && 1724 e0.slot == e1.slot); 1725 } 1726 1727 static unsigned int hash(LocalVariableTableElement const& e0) { 1728 unsigned int raw_hash = e0.start_bci; 1729 1730 raw_hash = e0.length + raw_hash * 37; 1731 raw_hash = e0.name_cp_index + raw_hash * 37; 1732 raw_hash = e0.slot + raw_hash * 37; 1733 1734 return raw_hash; 1735 } 1736 }; 1737 1738 1739 // Class file LocalVariableTable elements. 1740 class Classfile_LVT_Element { 1741 public: 1742 u2 start_bci; 1743 u2 length; 1744 u2 name_cp_index; 1745 u2 descriptor_cp_index; 1746 u2 slot; 1747 }; 1748 1749 static void copy_lvt_element(const Classfile_LVT_Element* const src, 1750 LocalVariableTableElement* const lvt) { 1751 lvt->start_bci = Bytes::get_Java_u2((u1*) &src->start_bci); 1752 lvt->length = Bytes::get_Java_u2((u1*) &src->length); 1753 lvt->name_cp_index = Bytes::get_Java_u2((u1*) &src->name_cp_index); 1754 lvt->descriptor_cp_index = Bytes::get_Java_u2((u1*) &src->descriptor_cp_index); 1755 lvt->signature_cp_index = 0; 1756 lvt->slot = Bytes::get_Java_u2((u1*) &src->slot); 1757 } 1758 1759 // Function is used to parse both attributes: 1760 // LocalVariableTable (LVT) and LocalVariableTypeTable (LVTT) 1761 const ClassFileParser::unsafe_u2* ClassFileParser::parse_localvariable_table(const ClassFileStream* cfs, 1762 u4 code_length, 1763 u2 max_locals, 1764 u4 code_attribute_length, 1765 u2* const localvariable_table_length, 1766 bool isLVTT, 1767 TRAPS) { 1768 const char* const tbl_name = (isLVTT) ? "LocalVariableTypeTable" : "LocalVariableTable"; 1769 *localvariable_table_length = cfs->get_u2(CHECK_NULL); 1770 const unsigned int size = checked_cast<unsigned>( 1771 (*localvariable_table_length) * sizeof(Classfile_LVT_Element) / sizeof(u2)); 1772 1773 const ConstantPool* const cp = _cp; 1774 1775 // Verify local variable table attribute has right length 1776 if (_need_verify) { 1777 guarantee_property(code_attribute_length == (sizeof(*localvariable_table_length) + size * sizeof(u2)), 1778 "%s has wrong length in class file %s", tbl_name, CHECK_NULL); 1779 } 1780 1781 const unsafe_u2* const localvariable_table_start = cfs->current(); 1782 assert(localvariable_table_start != nullptr, "null local variable table"); 1783 if (!_need_verify) { 1784 cfs->skip_u2_fast(size); 1785 } else { 1786 cfs->guarantee_more(size * 2, CHECK_NULL); 1787 for(int i = 0; i < (*localvariable_table_length); i++) { 1788 const u2 start_pc = cfs->get_u2_fast(); 1789 const u2 length = cfs->get_u2_fast(); 1790 const u2 name_index = cfs->get_u2_fast(); 1791 const u2 descriptor_index = cfs->get_u2_fast(); 1792 const u2 index = cfs->get_u2_fast(); 1793 // Assign to a u4 to avoid overflow 1794 const u4 end_pc = (u4)start_pc + (u4)length; 1795 1796 if (start_pc >= code_length) { 1797 classfile_parse_error( 1798 "Invalid start_pc %u in %s in class file %s", 1799 start_pc, tbl_name, THREAD); 1800 return nullptr; 1801 } 1802 if (end_pc > code_length) { 1803 classfile_parse_error( 1804 "Invalid length %u in %s in class file %s", 1805 length, tbl_name, THREAD); 1806 return nullptr; 1807 } 1808 const int cp_size = cp->length(); 1809 guarantee_property(valid_symbol_at(name_index), 1810 "Name index %u in %s has bad constant type in class file %s", 1811 name_index, tbl_name, CHECK_NULL); 1812 guarantee_property(valid_symbol_at(descriptor_index), 1813 "Signature index %u in %s has bad constant type in class file %s", 1814 descriptor_index, tbl_name, CHECK_NULL); 1815 1816 const Symbol* const name = cp->symbol_at(name_index); 1817 const Symbol* const sig = cp->symbol_at(descriptor_index); 1818 verify_legal_field_name(name, CHECK_NULL); 1819 u2 extra_slot = 0; 1820 if (!isLVTT) { 1821 verify_legal_field_signature(name, sig, CHECK_NULL); 1822 1823 // 4894874: check special cases for double and long local variables 1824 if (sig == vmSymbols::type_signature(T_DOUBLE) || 1825 sig == vmSymbols::type_signature(T_LONG)) { 1826 extra_slot = 1; 1827 } 1828 } 1829 guarantee_property((index + extra_slot) < max_locals, 1830 "Invalid index %u in %s in class file %s", 1831 index, tbl_name, CHECK_NULL); 1832 } 1833 } 1834 return localvariable_table_start; 1835 } 1836 1837 static const u1* parse_stackmap_table(const ClassFileStream* const cfs, 1838 u4 code_attribute_length, 1839 TRAPS) { 1840 assert(cfs != nullptr, "invariant"); 1841 1842 if (0 == code_attribute_length) { 1843 return nullptr; 1844 } 1845 1846 const u1* const stackmap_table_start = cfs->current(); 1847 assert(stackmap_table_start != nullptr, "null stackmap table"); 1848 1849 // check code_attribute_length 1850 cfs->skip_u1(code_attribute_length, CHECK_NULL); 1851 1852 return stackmap_table_start; 1853 } 1854 1855 const ClassFileParser::unsafe_u2* ClassFileParser::parse_checked_exceptions(const ClassFileStream* const cfs, 1856 u2* const checked_exceptions_length, 1857 u4 method_attribute_length, 1858 TRAPS) { 1859 assert(cfs != nullptr, "invariant"); 1860 assert(checked_exceptions_length != nullptr, "invariant"); 1861 1862 cfs->guarantee_more(2, CHECK_NULL); // checked_exceptions_length 1863 *checked_exceptions_length = cfs->get_u2_fast(); 1864 const unsigned int size = 1865 (*checked_exceptions_length) * sizeof(CheckedExceptionElement) / sizeof(u2); 1866 const unsafe_u2* const checked_exceptions_start = cfs->current(); 1867 assert(checked_exceptions_start != nullptr, "null checked exceptions"); 1868 if (!_need_verify) { 1869 cfs->skip_u2_fast(size); 1870 } else { 1871 // Verify each value in the checked exception table 1872 u2 checked_exception; 1873 const u2 len = *checked_exceptions_length; 1874 cfs->guarantee_more(2 * len, CHECK_NULL); 1875 for (int i = 0; i < len; i++) { 1876 checked_exception = cfs->get_u2_fast(); 1877 guarantee_property( 1878 valid_klass_reference_at(checked_exception), 1879 "Exception name has bad type at constant pool %u in class file %s", 1880 checked_exception, CHECK_NULL); 1881 } 1882 } 1883 // check exceptions attribute length 1884 if (_need_verify) { 1885 guarantee_property(method_attribute_length == (sizeof(*checked_exceptions_length) + 1886 sizeof(u2) * size), 1887 "Exceptions attribute has wrong length in class file %s", CHECK_NULL); 1888 } 1889 return checked_exceptions_start; 1890 } 1891 1892 void ClassFileParser::throwIllegalSignature(const char* type, 1893 const Symbol* name, 1894 const Symbol* sig, 1895 TRAPS) const { 1896 assert(name != nullptr, "invariant"); 1897 assert(sig != nullptr, "invariant"); 1898 1899 ResourceMark rm(THREAD); 1900 // Names are all known to be < 64k so we know this formatted message is not excessively large. 1901 Exceptions::fthrow(THREAD_AND_LOCATION, 1902 vmSymbols::java_lang_ClassFormatError(), 1903 "%s \"%s\" in class %s has illegal signature \"%s\"", type, 1904 name->as_C_string(), _class_name->as_C_string(), sig->as_C_string()); 1905 } 1906 1907 AnnotationCollector::ID 1908 AnnotationCollector::annotation_index(const ClassLoaderData* loader_data, 1909 const Symbol* name, 1910 const bool can_access_vm_annotations) { 1911 const vmSymbolID sid = vmSymbols::find_sid(name); 1912 // Privileged code can use all annotations. Other code silently drops some. 1913 const bool privileged = loader_data->is_boot_class_loader_data() || 1914 loader_data->is_platform_class_loader_data() || 1915 can_access_vm_annotations; 1916 switch (sid) { 1917 case VM_SYMBOL_ENUM_NAME(reflect_CallerSensitive_signature): { 1918 if (_location != _in_method) break; // only allow for methods 1919 if (!privileged) break; // only allow in privileged code 1920 return _method_CallerSensitive; 1921 } 1922 case VM_SYMBOL_ENUM_NAME(jdk_internal_vm_annotation_ForceInline_signature): { 1923 if (_location != _in_method) break; // only allow for methods 1924 if (!privileged) break; // only allow in privileged code 1925 return _method_ForceInline; 1926 } 1927 case VM_SYMBOL_ENUM_NAME(jdk_internal_vm_annotation_DontInline_signature): { 1928 if (_location != _in_method) break; // only allow for methods 1929 if (!privileged) break; // only allow in privileged code 1930 return _method_DontInline; 1931 } 1932 case VM_SYMBOL_ENUM_NAME(jdk_internal_vm_annotation_ChangesCurrentThread_signature): { 1933 if (_location != _in_method) break; // only allow for methods 1934 if (!privileged) break; // only allow in privileged code 1935 return _method_ChangesCurrentThread; 1936 } 1937 case VM_SYMBOL_ENUM_NAME(jdk_internal_vm_annotation_JvmtiHideEvents_signature): { 1938 if (_location != _in_method) break; // only allow for methods 1939 if (!privileged) break; // only allow in privileged code 1940 return _method_JvmtiHideEvents; 1941 } 1942 case VM_SYMBOL_ENUM_NAME(jdk_internal_vm_annotation_JvmtiMountTransition_signature): { 1943 if (_location != _in_method) break; // only allow for methods 1944 if (!privileged) break; // only allow in privileged code 1945 return _method_JvmtiMountTransition; 1946 } 1947 case VM_SYMBOL_ENUM_NAME(java_lang_invoke_InjectedProfile_signature): { 1948 if (_location != _in_method) break; // only allow for methods 1949 if (!privileged) break; // only allow in privileged code 1950 return _method_InjectedProfile; 1951 } 1952 case VM_SYMBOL_ENUM_NAME(java_lang_invoke_LambdaForm_Compiled_signature): { 1953 if (_location != _in_method) break; // only allow for methods 1954 if (!privileged) break; // only allow in privileged code 1955 return _method_LambdaForm_Compiled; 1956 } 1957 case VM_SYMBOL_ENUM_NAME(jdk_internal_vm_annotation_Hidden_signature): { 1958 if (_location != _in_method) break; // only allow for methods 1959 if (!privileged) break; // only allow in privileged code 1960 return _method_Hidden; 1961 } 1962 case VM_SYMBOL_ENUM_NAME(jdk_internal_misc_Scoped_signature): { 1963 if (_location != _in_method) break; // only allow for methods 1964 if (!privileged) break; // only allow in privileged code 1965 return _method_Scoped; 1966 } 1967 case VM_SYMBOL_ENUM_NAME(jdk_internal_vm_annotation_IntrinsicCandidate_signature): { 1968 if (_location != _in_method) break; // only allow for methods 1969 if (!privileged) break; // only allow in privileged code 1970 return _method_IntrinsicCandidate; 1971 } 1972 case VM_SYMBOL_ENUM_NAME(jdk_internal_vm_annotation_Stable_signature): { 1973 if (_location != _in_field) break; // only allow for fields 1974 if (!privileged) break; // only allow in privileged code 1975 return _field_Stable; 1976 } 1977 case VM_SYMBOL_ENUM_NAME(jdk_internal_vm_annotation_TrustFinalFields_signature): { 1978 if (_location != _in_class) break; // only allow for classes 1979 if (!privileged) break; // only allow in privileged code 1980 return _jdk_internal_vm_annotation_TrustFinalFields; 1981 } 1982 case VM_SYMBOL_ENUM_NAME(jdk_internal_vm_annotation_Contended_signature): { 1983 if (_location != _in_field && _location != _in_class) { 1984 break; // only allow for fields and classes 1985 } 1986 if (!EnableContended || (RestrictContended && !privileged)) { 1987 break; // honor privileges 1988 } 1989 return _jdk_internal_vm_annotation_Contended; 1990 } 1991 case VM_SYMBOL_ENUM_NAME(jdk_internal_vm_annotation_ReservedStackAccess_signature): { 1992 if (_location != _in_method) break; // only allow for methods 1993 if (RestrictReservedStack && !privileged) break; // honor privileges 1994 return _jdk_internal_vm_annotation_ReservedStackAccess; 1995 } 1996 case VM_SYMBOL_ENUM_NAME(jdk_internal_ValueBased_signature): { 1997 if (_location != _in_class) break; // only allow for classes 1998 if (!privileged) break; // only allow in privileged code 1999 return _jdk_internal_ValueBased; 2000 } 2001 case VM_SYMBOL_ENUM_NAME(jdk_internal_vm_annotation_LooselyConsistentValue_signature): { 2002 if (_location != _in_class) break; // only allow for classes 2003 return _jdk_internal_LooselyConsistentValue; 2004 } 2005 case VM_SYMBOL_ENUM_NAME(jdk_internal_vm_annotation_NullRestricted_signature): { 2006 if (_location != _in_field) break; // only allow for fields 2007 return _jdk_internal_NullRestricted; 2008 } 2009 case VM_SYMBOL_ENUM_NAME(java_lang_Deprecated): { 2010 return _java_lang_Deprecated; 2011 } 2012 case VM_SYMBOL_ENUM_NAME(jdk_internal_vm_annotation_AOTSafeClassInitializer_signature): { 2013 if (_location != _in_class) break; // only allow for classes 2014 if (!privileged) break; // only allow in privileged code 2015 return _jdk_internal_vm_annotation_AOTSafeClassInitializer; 2016 } 2017 case VM_SYMBOL_ENUM_NAME(jdk_internal_vm_annotation_AOTRuntimeSetup_signature): { 2018 if (_location != _in_method) break; // only allow for methods 2019 if (!privileged) break; // only allow in privileged code 2020 return _method_AOTRuntimeSetup; 2021 } 2022 default: { 2023 break; 2024 } 2025 } 2026 return AnnotationCollector::_unknown; 2027 } 2028 2029 void ClassFileParser::FieldAnnotationCollector::apply_to(FieldInfo* f) { 2030 if (is_contended()) 2031 // Setting the contended group also sets the contended bit in field flags 2032 f->set_contended_group(contended_group()); 2033 if (is_stable()) 2034 (f->field_flags_addr())->update_stable(true); 2035 } 2036 2037 ClassFileParser::FieldAnnotationCollector::~FieldAnnotationCollector() { 2038 // If there's an error deallocate metadata for field annotations 2039 MetadataFactory::free_array<u1>(_loader_data, _field_annotations); 2040 MetadataFactory::free_array<u1>(_loader_data, _field_type_annotations); 2041 } 2042 2043 void MethodAnnotationCollector::apply_to(const methodHandle& m) { 2044 if (has_annotation(_method_CallerSensitive)) 2045 m->set_caller_sensitive(); 2046 if (has_annotation(_method_ForceInline)) 2047 m->set_force_inline(); 2048 if (has_annotation(_method_DontInline)) 2049 m->set_dont_inline(); 2050 if (has_annotation(_method_ChangesCurrentThread)) 2051 m->set_changes_current_thread(); 2052 if (has_annotation(_method_JvmtiHideEvents)) 2053 m->set_jvmti_hide_events(); 2054 if (has_annotation(_method_JvmtiMountTransition)) 2055 m->set_jvmti_mount_transition(); 2056 if (has_annotation(_method_InjectedProfile)) 2057 m->set_has_injected_profile(); 2058 if (has_annotation(_method_LambdaForm_Compiled) && m->intrinsic_id() == vmIntrinsics::_none) 2059 m->set_intrinsic_id(vmIntrinsics::_compiledLambdaForm); 2060 if (has_annotation(_method_Hidden)) 2061 m->set_is_hidden(); 2062 if (has_annotation(_method_Scoped)) 2063 m->set_scoped(); 2064 if (has_annotation(_method_IntrinsicCandidate) && !m->is_synthetic()) 2065 m->set_intrinsic_candidate(); 2066 if (has_annotation(_jdk_internal_vm_annotation_ReservedStackAccess)) 2067 m->set_has_reserved_stack_access(); 2068 if (has_annotation(_java_lang_Deprecated)) 2069 m->set_deprecated(); 2070 if (has_annotation(_java_lang_Deprecated_for_removal)) 2071 m->set_deprecated_for_removal(); 2072 } 2073 2074 void ClassFileParser::ClassAnnotationCollector::apply_to(InstanceKlass* ik) { 2075 assert(ik != nullptr, "invariant"); 2076 if (has_annotation(_jdk_internal_vm_annotation_Contended)) { 2077 ik->set_is_contended(is_contended()); 2078 } 2079 if (has_annotation(_jdk_internal_ValueBased)) { 2080 ik->set_has_value_based_class_annotation(); 2081 if (DiagnoseSyncOnValueBasedClasses) { 2082 ik->set_is_value_based(); 2083 } 2084 } 2085 if (has_annotation(_java_lang_Deprecated)) { 2086 Array<Method*>* methods = ik->methods(); 2087 int length = ik->methods()->length(); 2088 for (int i = 0; i < length; i++) { 2089 Method* m = methods->at(i); 2090 m->set_deprecated(); 2091 } 2092 } 2093 if (has_annotation(_java_lang_Deprecated_for_removal)) { 2094 Array<Method*>* methods = ik->methods(); 2095 int length = ik->methods()->length(); 2096 for (int i = 0; i < length; i++) { 2097 Method* m = methods->at(i); 2098 m->set_deprecated_for_removal(); 2099 } 2100 } 2101 if (has_annotation(_jdk_internal_vm_annotation_AOTSafeClassInitializer)) { 2102 ik->set_has_aot_safe_initializer(); 2103 } 2104 if (has_annotation(_jdk_internal_vm_annotation_TrustFinalFields)) { 2105 ik->set_trust_final_fields(true); 2106 } 2107 } 2108 2109 #define MAX_ARGS_SIZE 255 2110 #define MAX_CODE_SIZE 65535 2111 #define INITIAL_MAX_LVT_NUMBER 256 2112 2113 /* Copy class file LVT's/LVTT's into the HotSpot internal LVT. 2114 * 2115 * Rules for LVT's and LVTT's are: 2116 * - There can be any number of LVT's and LVTT's. 2117 * - If there are n LVT's, it is the same as if there was just 2118 * one LVT containing all the entries from the n LVT's. 2119 * - There may be no more than one LVT entry per local variable. 2120 * Two LVT entries are 'equal' if these fields are the same: 2121 * start_pc, length, name, slot 2122 * - There may be no more than one LVTT entry per each LVT entry. 2123 * Each LVTT entry has to match some LVT entry. 2124 * - HotSpot internal LVT keeps natural ordering of class file LVT entries. 2125 */ 2126 void ClassFileParser::copy_localvariable_table(const ConstMethod* cm, 2127 int lvt_cnt, 2128 u2* const localvariable_table_length, 2129 const unsafe_u2** const localvariable_table_start, 2130 int lvtt_cnt, 2131 u2* const localvariable_type_table_length, 2132 const unsafe_u2** const localvariable_type_table_start, 2133 TRAPS) { 2134 2135 ResourceMark rm(THREAD); 2136 2137 typedef HashTable<LocalVariableTableElement, LocalVariableTableElement*, 2138 256, AnyObj::RESOURCE_AREA, mtInternal, 2139 &LVT_Hash::hash, &LVT_Hash::equals> LVT_HashTable; 2140 2141 LVT_HashTable* const table = new LVT_HashTable(); 2142 2143 // To fill LocalVariableTable in 2144 const Classfile_LVT_Element* cf_lvt; 2145 LocalVariableTableElement* lvt = cm->localvariable_table_start(); 2146 2147 for (int tbl_no = 0; tbl_no < lvt_cnt; tbl_no++) { 2148 cf_lvt = (Classfile_LVT_Element *) localvariable_table_start[tbl_no]; 2149 for (int idx = 0; idx < localvariable_table_length[tbl_no]; idx++, lvt++) { 2150 copy_lvt_element(&cf_lvt[idx], lvt); 2151 // If no duplicates, add LVT elem in hashtable. 2152 if (table->put(*lvt, lvt) == false 2153 && _need_verify 2154 && _major_version >= JAVA_1_5_VERSION) { 2155 classfile_parse_error("Duplicated LocalVariableTable attribute " 2156 "entry for '%s' in class file %s", 2157 _cp->symbol_at(lvt->name_cp_index)->as_utf8(), 2158 THREAD); 2159 return; 2160 } 2161 } 2162 } 2163 2164 // To merge LocalVariableTable and LocalVariableTypeTable 2165 const Classfile_LVT_Element* cf_lvtt; 2166 LocalVariableTableElement lvtt_elem; 2167 2168 for (int tbl_no = 0; tbl_no < lvtt_cnt; tbl_no++) { 2169 cf_lvtt = (Classfile_LVT_Element *) localvariable_type_table_start[tbl_no]; 2170 for (int idx = 0; idx < localvariable_type_table_length[tbl_no]; idx++) { 2171 copy_lvt_element(&cf_lvtt[idx], &lvtt_elem); 2172 LocalVariableTableElement** entry = table->get(lvtt_elem); 2173 if (entry == nullptr) { 2174 if (_need_verify) { 2175 classfile_parse_error("LVTT entry for '%s' in class file %s " 2176 "does not match any LVT entry", 2177 _cp->symbol_at(lvtt_elem.name_cp_index)->as_utf8(), 2178 THREAD); 2179 return; 2180 } 2181 } else if ((*entry)->signature_cp_index != 0 && _need_verify) { 2182 classfile_parse_error("Duplicated LocalVariableTypeTable attribute " 2183 "entry for '%s' in class file %s", 2184 _cp->symbol_at(lvtt_elem.name_cp_index)->as_utf8(), 2185 THREAD); 2186 return; 2187 } else { 2188 // to add generic signatures into LocalVariableTable 2189 (*entry)->signature_cp_index = lvtt_elem.descriptor_cp_index; 2190 } 2191 } 2192 } 2193 } 2194 2195 2196 void ClassFileParser::copy_method_annotations(ConstMethod* cm, 2197 const u1* runtime_visible_annotations, 2198 int runtime_visible_annotations_length, 2199 const u1* runtime_visible_parameter_annotations, 2200 int runtime_visible_parameter_annotations_length, 2201 const u1* runtime_visible_type_annotations, 2202 int runtime_visible_type_annotations_length, 2203 const u1* annotation_default, 2204 int annotation_default_length, 2205 TRAPS) { 2206 2207 AnnotationArray* a; 2208 2209 if (runtime_visible_annotations_length > 0) { 2210 a = allocate_annotations(runtime_visible_annotations, 2211 runtime_visible_annotations_length, 2212 CHECK); 2213 cm->set_method_annotations(a); 2214 } 2215 2216 if (runtime_visible_parameter_annotations_length > 0) { 2217 a = allocate_annotations(runtime_visible_parameter_annotations, 2218 runtime_visible_parameter_annotations_length, 2219 CHECK); 2220 cm->set_parameter_annotations(a); 2221 } 2222 2223 if (annotation_default_length > 0) { 2224 a = allocate_annotations(annotation_default, 2225 annotation_default_length, 2226 CHECK); 2227 cm->set_default_annotations(a); 2228 } 2229 2230 if (runtime_visible_type_annotations_length > 0) { 2231 a = allocate_annotations(runtime_visible_type_annotations, 2232 runtime_visible_type_annotations_length, 2233 CHECK); 2234 cm->set_type_annotations(a); 2235 } 2236 } 2237 2238 2239 // Note: the parse_method below is big and clunky because all parsing of the code and exceptions 2240 // attribute is inlined. This is cumbersome to avoid since we inline most of the parts in the 2241 // Method* to save footprint, so we only know the size of the resulting Method* when the 2242 // entire method attribute is parsed. 2243 // 2244 // The has_localvariable_table parameter is used to pass up the value to InstanceKlass. 2245 2246 Method* ClassFileParser::parse_method(const ClassFileStream* const cfs, 2247 bool is_interface, 2248 const ConstantPool* cp, 2249 bool* const has_localvariable_table, 2250 TRAPS) { 2251 assert(cfs != nullptr, "invariant"); 2252 assert(cp != nullptr, "invariant"); 2253 assert(has_localvariable_table != nullptr, "invariant"); 2254 2255 ResourceMark rm(THREAD); 2256 // Parse fixed parts: 2257 // access_flags, name_index, descriptor_index, attributes_count 2258 cfs->guarantee_more(8, CHECK_NULL); 2259 2260 u2 flags = cfs->get_u2_fast(); 2261 const u2 name_index = cfs->get_u2_fast(); 2262 const int cp_size = cp->length(); 2263 guarantee_property( 2264 valid_symbol_at(name_index), 2265 "Illegal constant pool index %u for method name in class file %s", 2266 name_index, CHECK_NULL); 2267 const Symbol* const name = cp->symbol_at(name_index); 2268 verify_legal_method_name(name, CHECK_NULL); 2269 2270 const u2 signature_index = cfs->get_u2_fast(); 2271 guarantee_property( 2272 valid_symbol_at(signature_index), 2273 "Illegal constant pool index %u for method signature in class file %s", 2274 signature_index, CHECK_NULL); 2275 const Symbol* const signature = cp->symbol_at(signature_index); 2276 2277 if (name == vmSymbols::class_initializer_name()) { 2278 // We ignore the other access flags for a valid class initializer. 2279 // (JVM Spec 2nd ed., chapter 4.6) 2280 if (_major_version < 51) { // backward compatibility 2281 flags = JVM_ACC_STATIC; 2282 } else if ((flags & JVM_ACC_STATIC) == JVM_ACC_STATIC) { 2283 flags &= JVM_ACC_STATIC | (_major_version <= JAVA_16_VERSION ? JVM_ACC_STRICT : 0); 2284 } else { 2285 classfile_parse_error("Method <clinit> is not static in class file %s", THREAD); 2286 return nullptr; 2287 } 2288 } else { 2289 verify_legal_method_modifiers(flags, access_flags(), name, CHECK_NULL); 2290 } 2291 2292 if (name == vmSymbols::object_initializer_name() && is_interface) { 2293 classfile_parse_error("Interface cannot have a method named <init>, class file %s", THREAD); 2294 return nullptr; 2295 } 2296 2297 if (Arguments::is_valhalla_enabled()) { 2298 if (((flags & JVM_ACC_SYNCHRONIZED) == JVM_ACC_SYNCHRONIZED) 2299 && ((flags & JVM_ACC_STATIC) == 0 ) 2300 && !_access_flags.is_identity_class()) { 2301 classfile_parse_error("Invalid synchronized method in non-identity class %s", THREAD); 2302 return nullptr; 2303 } 2304 } 2305 2306 int args_size = -1; // only used when _need_verify is true 2307 if (_need_verify) { 2308 verify_legal_name_with_signature(name, signature, CHECK_NULL); 2309 args_size = ((flags & JVM_ACC_STATIC) ? 0 : 1) + 2310 verify_legal_method_signature(name, signature, CHECK_NULL); 2311 if (args_size > MAX_ARGS_SIZE) { 2312 classfile_parse_error("Too many arguments in method signature in class file %s", THREAD); 2313 return nullptr; 2314 } 2315 } 2316 2317 AccessFlags access_flags(flags & JVM_RECOGNIZED_METHOD_MODIFIERS); 2318 2319 // Default values for code and exceptions attribute elements 2320 u2 max_stack = 0; 2321 u2 max_locals = 0; 2322 u4 code_length = 0; 2323 const u1* code_start = nullptr; 2324 u2 exception_table_length = 0; 2325 const unsafe_u2* exception_table_start = nullptr; // (potentially unaligned) pointer to array of u2 elements 2326 Array<int>* exception_handlers = Universe::the_empty_int_array(); 2327 u2 checked_exceptions_length = 0; 2328 const unsafe_u2* checked_exceptions_start = nullptr; // (potentially unaligned) pointer to array of u2 elements 2329 CompressedLineNumberWriteStream* linenumber_table = nullptr; 2330 int linenumber_table_length = 0; 2331 int total_lvt_length = 0; 2332 u2 lvt_cnt = 0; 2333 u2 lvtt_cnt = 0; 2334 bool lvt_allocated = false; 2335 u2 max_lvt_cnt = INITIAL_MAX_LVT_NUMBER; 2336 u2 max_lvtt_cnt = INITIAL_MAX_LVT_NUMBER; 2337 u2* localvariable_table_length = nullptr; 2338 const unsafe_u2** localvariable_table_start = nullptr; // (potentially unaligned) pointer to array of LVT attributes 2339 u2* localvariable_type_table_length = nullptr; 2340 const unsafe_u2** localvariable_type_table_start = nullptr; // (potentially unaligned) pointer to LVTT attributes 2341 int method_parameters_length = -1; 2342 const u1* method_parameters_data = nullptr; 2343 bool method_parameters_seen = false; 2344 bool parsed_code_attribute = false; 2345 bool parsed_checked_exceptions_attribute = false; 2346 bool parsed_stackmap_attribute = false; 2347 // stackmap attribute - JDK1.5 2348 const u1* stackmap_data = nullptr; 2349 int stackmap_data_length = 0; 2350 u2 generic_signature_index = 0; 2351 MethodAnnotationCollector parsed_annotations; 2352 const u1* runtime_visible_annotations = nullptr; 2353 int runtime_visible_annotations_length = 0; 2354 const u1* runtime_visible_parameter_annotations = nullptr; 2355 int runtime_visible_parameter_annotations_length = 0; 2356 const u1* runtime_visible_type_annotations = nullptr; 2357 int runtime_visible_type_annotations_length = 0; 2358 bool runtime_invisible_annotations_exists = false; 2359 bool runtime_invisible_type_annotations_exists = false; 2360 bool runtime_invisible_parameter_annotations_exists = false; 2361 const u1* annotation_default = nullptr; 2362 int annotation_default_length = 0; 2363 2364 // Parse code and exceptions attribute 2365 u2 method_attributes_count = cfs->get_u2_fast(); 2366 while (method_attributes_count--) { 2367 cfs->guarantee_more(6, CHECK_NULL); // method_attribute_name_index, method_attribute_length 2368 const u2 method_attribute_name_index = cfs->get_u2_fast(); 2369 const u4 method_attribute_length = cfs->get_u4_fast(); 2370 guarantee_property( 2371 valid_symbol_at(method_attribute_name_index), 2372 "Invalid method attribute name index %u in class file %s", 2373 method_attribute_name_index, CHECK_NULL); 2374 2375 const Symbol* const method_attribute_name = cp->symbol_at(method_attribute_name_index); 2376 if (method_attribute_name == vmSymbols::tag_code()) { 2377 // Parse Code attribute 2378 if (_need_verify) { 2379 guarantee_property( 2380 !access_flags.is_native() && !access_flags.is_abstract(), 2381 "Code attribute in native or abstract methods in class file %s", 2382 CHECK_NULL); 2383 } 2384 if (parsed_code_attribute) { 2385 classfile_parse_error("Multiple Code attributes in class file %s", 2386 THREAD); 2387 return nullptr; 2388 } 2389 parsed_code_attribute = true; 2390 2391 // Stack size, locals size, and code size 2392 cfs->guarantee_more(8, CHECK_NULL); 2393 max_stack = cfs->get_u2_fast(); 2394 max_locals = cfs->get_u2_fast(); 2395 code_length = cfs->get_u4_fast(); 2396 if (_need_verify) { 2397 guarantee_property(args_size <= max_locals, 2398 "Arguments can't fit into locals in class file %s", 2399 CHECK_NULL); 2400 guarantee_property(code_length > 0 && code_length <= MAX_CODE_SIZE, 2401 "Invalid method Code length %u in class file %s", 2402 code_length, CHECK_NULL); 2403 } 2404 // Code pointer 2405 code_start = cfs->current(); 2406 assert(code_start != nullptr, "null code start"); 2407 cfs->guarantee_more(code_length, CHECK_NULL); 2408 cfs->skip_u1_fast(code_length); 2409 2410 // Exception handler table 2411 cfs->guarantee_more(2, CHECK_NULL); // exception_table_length 2412 exception_table_length = cfs->get_u2_fast(); 2413 if (exception_table_length > 0) { 2414 exception_table_start = parse_exception_table(cfs, 2415 code_length, 2416 exception_table_length, 2417 CHECK_NULL); 2418 } 2419 2420 // Parse additional attributes in code attribute 2421 cfs->guarantee_more(2, CHECK_NULL); // code_attributes_count 2422 u2 code_attributes_count = cfs->get_u2_fast(); 2423 2424 unsigned int calculated_attribute_length = 0; 2425 2426 calculated_attribute_length = 2427 sizeof(max_stack) + sizeof(max_locals) + sizeof(code_length); 2428 calculated_attribute_length += checked_cast<unsigned int>( 2429 code_length + 2430 sizeof(exception_table_length) + 2431 sizeof(code_attributes_count) + 2432 exception_table_length * 2433 ( sizeof(u2) + // start_pc 2434 sizeof(u2) + // end_pc 2435 sizeof(u2) + // handler_pc 2436 sizeof(u2) )); // catch_type_index 2437 2438 while (code_attributes_count--) { 2439 cfs->guarantee_more(6, CHECK_NULL); // code_attribute_name_index, code_attribute_length 2440 const u2 code_attribute_name_index = cfs->get_u2_fast(); 2441 const u4 code_attribute_length = cfs->get_u4_fast(); 2442 calculated_attribute_length += code_attribute_length + 2443 (unsigned)sizeof(code_attribute_name_index) + 2444 (unsigned)sizeof(code_attribute_length); 2445 guarantee_property(valid_symbol_at(code_attribute_name_index), 2446 "Invalid code attribute name index %u in class file %s", 2447 code_attribute_name_index, 2448 CHECK_NULL); 2449 if (LoadLineNumberTables && 2450 cp->symbol_at(code_attribute_name_index) == vmSymbols::tag_line_number_table()) { 2451 // Parse and compress line number table 2452 parse_linenumber_table(code_attribute_length, 2453 code_length, 2454 &linenumber_table, 2455 CHECK_NULL); 2456 2457 } else if (LoadLocalVariableTables && 2458 cp->symbol_at(code_attribute_name_index) == vmSymbols::tag_local_variable_table()) { 2459 // Parse local variable table 2460 if (!lvt_allocated) { 2461 localvariable_table_length = NEW_RESOURCE_ARRAY_IN_THREAD( 2462 THREAD, u2, INITIAL_MAX_LVT_NUMBER); 2463 localvariable_table_start = NEW_RESOURCE_ARRAY_IN_THREAD( 2464 THREAD, const unsafe_u2*, INITIAL_MAX_LVT_NUMBER); 2465 localvariable_type_table_length = NEW_RESOURCE_ARRAY_IN_THREAD( 2466 THREAD, u2, INITIAL_MAX_LVT_NUMBER); 2467 localvariable_type_table_start = NEW_RESOURCE_ARRAY_IN_THREAD( 2468 THREAD, const unsafe_u2*, INITIAL_MAX_LVT_NUMBER); 2469 lvt_allocated = true; 2470 } 2471 if (lvt_cnt == max_lvt_cnt) { 2472 max_lvt_cnt <<= 1; 2473 localvariable_table_length = REALLOC_RESOURCE_ARRAY(localvariable_table_length, lvt_cnt, max_lvt_cnt); 2474 localvariable_table_start = REALLOC_RESOURCE_ARRAY(localvariable_table_start, lvt_cnt, max_lvt_cnt); 2475 } 2476 localvariable_table_start[lvt_cnt] = 2477 parse_localvariable_table(cfs, 2478 code_length, 2479 max_locals, 2480 code_attribute_length, 2481 &localvariable_table_length[lvt_cnt], 2482 false, // is not LVTT 2483 CHECK_NULL); 2484 total_lvt_length += localvariable_table_length[lvt_cnt]; 2485 lvt_cnt++; 2486 } else if (LoadLocalVariableTypeTables && 2487 _major_version >= JAVA_1_5_VERSION && 2488 cp->symbol_at(code_attribute_name_index) == vmSymbols::tag_local_variable_type_table()) { 2489 if (!lvt_allocated) { 2490 localvariable_table_length = NEW_RESOURCE_ARRAY_IN_THREAD( 2491 THREAD, u2, INITIAL_MAX_LVT_NUMBER); 2492 localvariable_table_start = NEW_RESOURCE_ARRAY_IN_THREAD( 2493 THREAD, const unsafe_u2*, INITIAL_MAX_LVT_NUMBER); 2494 localvariable_type_table_length = NEW_RESOURCE_ARRAY_IN_THREAD( 2495 THREAD, u2, INITIAL_MAX_LVT_NUMBER); 2496 localvariable_type_table_start = NEW_RESOURCE_ARRAY_IN_THREAD( 2497 THREAD, const unsafe_u2*, INITIAL_MAX_LVT_NUMBER); 2498 lvt_allocated = true; 2499 } 2500 // Parse local variable type table 2501 if (lvtt_cnt == max_lvtt_cnt) { 2502 max_lvtt_cnt <<= 1; 2503 localvariable_type_table_length = REALLOC_RESOURCE_ARRAY(localvariable_type_table_length, lvtt_cnt, max_lvtt_cnt); 2504 localvariable_type_table_start = REALLOC_RESOURCE_ARRAY(localvariable_type_table_start, lvtt_cnt, max_lvtt_cnt); 2505 } 2506 localvariable_type_table_start[lvtt_cnt] = 2507 parse_localvariable_table(cfs, 2508 code_length, 2509 max_locals, 2510 code_attribute_length, 2511 &localvariable_type_table_length[lvtt_cnt], 2512 true, // is LVTT 2513 CHECK_NULL); 2514 lvtt_cnt++; 2515 } else if (_major_version >= Verifier::STACKMAP_ATTRIBUTE_MAJOR_VERSION && 2516 cp->symbol_at(code_attribute_name_index) == vmSymbols::tag_stack_map_table()) { 2517 // Stack map is only needed by the new verifier in JDK1.5. 2518 if (parsed_stackmap_attribute) { 2519 classfile_parse_error("Multiple StackMapTable attributes in class file %s", THREAD); 2520 return nullptr; 2521 } 2522 stackmap_data = parse_stackmap_table(cfs, code_attribute_length, CHECK_NULL); 2523 stackmap_data_length = code_attribute_length; 2524 parsed_stackmap_attribute = true; 2525 } else { 2526 // Skip unknown attributes 2527 cfs->skip_u1(code_attribute_length, CHECK_NULL); 2528 } 2529 } 2530 // check method attribute length 2531 if (_need_verify) { 2532 guarantee_property(method_attribute_length == calculated_attribute_length, 2533 "Code segment has wrong length in class file %s", 2534 CHECK_NULL); 2535 } 2536 } else if (method_attribute_name == vmSymbols::tag_exceptions()) { 2537 // Parse Exceptions attribute 2538 if (parsed_checked_exceptions_attribute) { 2539 classfile_parse_error("Multiple Exceptions attributes in class file %s", 2540 THREAD); 2541 return nullptr; 2542 } 2543 parsed_checked_exceptions_attribute = true; 2544 checked_exceptions_start = 2545 parse_checked_exceptions(cfs, 2546 &checked_exceptions_length, 2547 method_attribute_length, 2548 CHECK_NULL); 2549 } else if (method_attribute_name == vmSymbols::tag_method_parameters()) { 2550 // reject multiple method parameters 2551 if (method_parameters_seen) { 2552 classfile_parse_error("Multiple MethodParameters attributes in class file %s", 2553 THREAD); 2554 return nullptr; 2555 } 2556 method_parameters_seen = true; 2557 method_parameters_length = cfs->get_u1_fast(); 2558 const u4 real_length = (method_parameters_length * 4u) + 1u; 2559 if (method_attribute_length != real_length) { 2560 classfile_parse_error( 2561 "Invalid MethodParameters method attribute length %u in class file", 2562 method_attribute_length, THREAD); 2563 return nullptr; 2564 } 2565 method_parameters_data = cfs->current(); 2566 cfs->skip_u2_fast(method_parameters_length); 2567 cfs->skip_u2_fast(method_parameters_length); 2568 // ignore this attribute if it cannot be reflected 2569 if (!vmClasses::reflect_Parameter_klass_is_loaded()) 2570 method_parameters_length = -1; 2571 } else if (method_attribute_name == vmSymbols::tag_synthetic()) { 2572 if (method_attribute_length != 0) { 2573 classfile_parse_error( 2574 "Invalid Synthetic method attribute length %u in class file %s", 2575 method_attribute_length, THREAD); 2576 return nullptr; 2577 } 2578 // Should we check that there hasn't already been a synthetic attribute? 2579 access_flags.set_is_synthetic(); 2580 } else if (method_attribute_name == vmSymbols::tag_deprecated()) { // 4276120 2581 if (method_attribute_length != 0) { 2582 classfile_parse_error( 2583 "Invalid Deprecated method attribute length %u in class file %s", 2584 method_attribute_length, THREAD); 2585 return nullptr; 2586 } 2587 } else if (_major_version >= JAVA_1_5_VERSION) { 2588 if (method_attribute_name == vmSymbols::tag_signature()) { 2589 if (generic_signature_index != 0) { 2590 classfile_parse_error( 2591 "Multiple Signature attributes for method in class file %s", 2592 THREAD); 2593 return nullptr; 2594 } 2595 if (method_attribute_length != 2) { 2596 classfile_parse_error( 2597 "Invalid Signature attribute length %u in class file %s", 2598 method_attribute_length, THREAD); 2599 return nullptr; 2600 } 2601 generic_signature_index = parse_generic_signature_attribute(cfs, CHECK_NULL); 2602 } else if (method_attribute_name == vmSymbols::tag_runtime_visible_annotations()) { 2603 if (runtime_visible_annotations != nullptr) { 2604 classfile_parse_error( 2605 "Multiple RuntimeVisibleAnnotations attributes for method in class file %s", 2606 THREAD); 2607 return nullptr; 2608 } 2609 runtime_visible_annotations_length = method_attribute_length; 2610 runtime_visible_annotations = cfs->current(); 2611 assert(runtime_visible_annotations != nullptr, "null visible annotations"); 2612 cfs->guarantee_more(runtime_visible_annotations_length, CHECK_NULL); 2613 parse_annotations(cp, 2614 runtime_visible_annotations, 2615 runtime_visible_annotations_length, 2616 &parsed_annotations, 2617 _loader_data, 2618 _can_access_vm_annotations); 2619 cfs->skip_u1_fast(runtime_visible_annotations_length); 2620 } else if (method_attribute_name == vmSymbols::tag_runtime_invisible_annotations()) { 2621 if (runtime_invisible_annotations_exists) { 2622 classfile_parse_error( 2623 "Multiple RuntimeInvisibleAnnotations attributes for method in class file %s", 2624 THREAD); 2625 return nullptr; 2626 } 2627 runtime_invisible_annotations_exists = true; 2628 cfs->skip_u1(method_attribute_length, CHECK_NULL); 2629 } else if (method_attribute_name == vmSymbols::tag_runtime_visible_parameter_annotations()) { 2630 if (runtime_visible_parameter_annotations != nullptr) { 2631 classfile_parse_error( 2632 "Multiple RuntimeVisibleParameterAnnotations attributes for method in class file %s", 2633 THREAD); 2634 return nullptr; 2635 } 2636 runtime_visible_parameter_annotations_length = method_attribute_length; 2637 runtime_visible_parameter_annotations = cfs->current(); 2638 assert(runtime_visible_parameter_annotations != nullptr, "null visible parameter annotations"); 2639 cfs->skip_u1(runtime_visible_parameter_annotations_length, CHECK_NULL); 2640 } else if (method_attribute_name == vmSymbols::tag_runtime_invisible_parameter_annotations()) { 2641 if (runtime_invisible_parameter_annotations_exists) { 2642 classfile_parse_error( 2643 "Multiple RuntimeInvisibleParameterAnnotations attributes for method in class file %s", 2644 THREAD); 2645 return nullptr; 2646 } 2647 runtime_invisible_parameter_annotations_exists = true; 2648 cfs->skip_u1(method_attribute_length, CHECK_NULL); 2649 } else if (method_attribute_name == vmSymbols::tag_annotation_default()) { 2650 if (annotation_default != nullptr) { 2651 classfile_parse_error( 2652 "Multiple AnnotationDefault attributes for method in class file %s", 2653 THREAD); 2654 return nullptr; 2655 } 2656 annotation_default_length = method_attribute_length; 2657 annotation_default = cfs->current(); 2658 assert(annotation_default != nullptr, "null annotation default"); 2659 cfs->skip_u1(annotation_default_length, CHECK_NULL); 2660 } else if (method_attribute_name == vmSymbols::tag_runtime_visible_type_annotations()) { 2661 if (runtime_visible_type_annotations != nullptr) { 2662 classfile_parse_error( 2663 "Multiple RuntimeVisibleTypeAnnotations attributes for method in class file %s", 2664 THREAD); 2665 return nullptr; 2666 } 2667 runtime_visible_type_annotations_length = method_attribute_length; 2668 runtime_visible_type_annotations = cfs->current(); 2669 assert(runtime_visible_type_annotations != nullptr, "null visible type annotations"); 2670 // No need for the VM to parse Type annotations 2671 cfs->skip_u1(runtime_visible_type_annotations_length, CHECK_NULL); 2672 } else if (method_attribute_name == vmSymbols::tag_runtime_invisible_type_annotations()) { 2673 if (runtime_invisible_type_annotations_exists) { 2674 classfile_parse_error( 2675 "Multiple RuntimeInvisibleTypeAnnotations attributes for method in class file %s", 2676 THREAD); 2677 return nullptr; 2678 } 2679 runtime_invisible_type_annotations_exists = true; 2680 cfs->skip_u1(method_attribute_length, CHECK_NULL); 2681 } else { 2682 // Skip unknown attributes 2683 cfs->skip_u1(method_attribute_length, CHECK_NULL); 2684 } 2685 } else { 2686 // Skip unknown attributes 2687 cfs->skip_u1(method_attribute_length, CHECK_NULL); 2688 } 2689 } 2690 2691 if (linenumber_table != nullptr) { 2692 linenumber_table->write_terminator(); 2693 linenumber_table_length = linenumber_table->position(); 2694 } 2695 2696 // Make sure there's at least one Code attribute in non-native/non-abstract method 2697 if (_need_verify) { 2698 guarantee_property(access_flags.is_native() || 2699 access_flags.is_abstract() || 2700 parsed_code_attribute, 2701 "Absent Code attribute in method that is not native or abstract in class file %s", 2702 CHECK_NULL); 2703 } 2704 2705 // All sizing information for a Method* is finally available, now create it 2706 InlineTableSizes sizes( 2707 total_lvt_length, 2708 linenumber_table_length, 2709 exception_table_length, 2710 checked_exceptions_length, 2711 method_parameters_length, 2712 generic_signature_index, 2713 runtime_visible_annotations_length, 2714 runtime_visible_parameter_annotations_length, 2715 runtime_visible_type_annotations_length, 2716 annotation_default_length, 2717 0); 2718 2719 Method* const m = Method::allocate(_loader_data, 2720 code_length, 2721 access_flags, 2722 &sizes, 2723 ConstMethod::NORMAL, 2724 _cp->symbol_at(name_index), 2725 CHECK_NULL); 2726 2727 ClassLoadingService::add_class_method_size(m->size()*wordSize); 2728 2729 // Fill in information from fixed part (access_flags already set) 2730 m->set_constants(_cp); 2731 m->set_name_index(name_index); 2732 m->set_signature_index(signature_index); 2733 m->constMethod()->compute_from_signature(cp->symbol_at(signature_index), access_flags.is_static()); 2734 assert(args_size < 0 || args_size == m->size_of_parameters(), ""); 2735 2736 // Fill in code attribute information 2737 m->set_max_stack(max_stack); 2738 m->set_max_locals(max_locals); 2739 if (stackmap_data != nullptr) { 2740 m->constMethod()->copy_stackmap_data(_loader_data, 2741 (u1*)stackmap_data, 2742 stackmap_data_length, 2743 CHECK_NULL); 2744 } 2745 2746 // Copy byte codes 2747 m->set_code((u1*)code_start); 2748 2749 // Copy line number table 2750 if (linenumber_table != nullptr) { 2751 memcpy(m->compressed_linenumber_table(), 2752 linenumber_table->buffer(), 2753 linenumber_table_length); 2754 } 2755 2756 // Copy exception table 2757 if (exception_table_length > 0) { 2758 Copy::conjoint_swap_if_needed<Endian::JAVA>(exception_table_start, 2759 m->exception_table_start(), 2760 exception_table_length * sizeof(ExceptionTableElement), 2761 sizeof(u2)); 2762 } 2763 2764 // Copy method parameters 2765 if (method_parameters_length > 0) { 2766 MethodParametersElement* elem = m->constMethod()->method_parameters_start(); 2767 for (int i = 0; i < method_parameters_length; i++) { 2768 elem[i].name_cp_index = Bytes::get_Java_u2((address)method_parameters_data); 2769 method_parameters_data += 2; 2770 elem[i].flags = Bytes::get_Java_u2((address)method_parameters_data); 2771 method_parameters_data += 2; 2772 } 2773 } 2774 2775 // Copy checked exceptions 2776 if (checked_exceptions_length > 0) { 2777 Copy::conjoint_swap_if_needed<Endian::JAVA>(checked_exceptions_start, 2778 m->checked_exceptions_start(), 2779 checked_exceptions_length * sizeof(CheckedExceptionElement), 2780 sizeof(u2)); 2781 } 2782 2783 // Copy class file LVT's/LVTT's into the HotSpot internal LVT. 2784 if (total_lvt_length > 0) { 2785 *has_localvariable_table = true; 2786 copy_localvariable_table(m->constMethod(), 2787 lvt_cnt, 2788 localvariable_table_length, 2789 localvariable_table_start, 2790 lvtt_cnt, 2791 localvariable_type_table_length, 2792 localvariable_type_table_start, 2793 CHECK_NULL); 2794 } 2795 2796 if (parsed_annotations.has_any_annotations()) 2797 parsed_annotations.apply_to(methodHandle(THREAD, m)); 2798 2799 if (is_hidden()) { // Mark methods in hidden classes as 'hidden'. 2800 m->set_is_hidden(); 2801 } 2802 if (parsed_annotations.has_aot_runtime_setup()) { 2803 if (name != vmSymbols::runtimeSetup() || signature != vmSymbols::void_method_signature() || 2804 !access_flags.is_private() || !access_flags.is_static()) { 2805 classfile_parse_error("@AOTRuntimeSetup method must be declared private static void runtimeSetup() for class %s", CHECK_NULL); 2806 } 2807 _has_aot_runtime_setup_method = true; 2808 } 2809 2810 // Copy annotations 2811 copy_method_annotations(m->constMethod(), 2812 runtime_visible_annotations, 2813 runtime_visible_annotations_length, 2814 runtime_visible_parameter_annotations, 2815 runtime_visible_parameter_annotations_length, 2816 runtime_visible_type_annotations, 2817 runtime_visible_type_annotations_length, 2818 annotation_default, 2819 annotation_default_length, 2820 CHECK_NULL); 2821 2822 if (InstanceKlass::is_finalization_enabled() && 2823 name == vmSymbols::finalize_method_name() && 2824 signature == vmSymbols::void_method_signature()) { 2825 if (m->is_empty_method()) { 2826 _has_empty_finalizer = true; 2827 } else { 2828 _has_finalizer = true; 2829 } 2830 } 2831 2832 NOT_PRODUCT(m->verify()); 2833 return m; 2834 } 2835 2836 2837 // Side-effects: populates the _methods field in the parser 2838 void ClassFileParser::parse_methods(const ClassFileStream* const cfs, 2839 bool is_interface, 2840 bool* const has_localvariable_table, 2841 bool* has_final_method, 2842 bool* declares_nonstatic_concrete_methods, 2843 TRAPS) { 2844 assert(cfs != nullptr, "invariant"); 2845 assert(has_localvariable_table != nullptr, "invariant"); 2846 assert(has_final_method != nullptr, "invariant"); 2847 assert(declares_nonstatic_concrete_methods != nullptr, "invariant"); 2848 2849 assert(nullptr == _methods, "invariant"); 2850 2851 cfs->guarantee_more(2, CHECK); // length 2852 const u2 length = cfs->get_u2_fast(); 2853 if (length == 0) { 2854 _methods = Universe::the_empty_method_array(); 2855 } else { 2856 _methods = MetadataFactory::new_array<Method*>(_loader_data, 2857 length, 2858 nullptr, 2859 CHECK); 2860 2861 for (int index = 0; index < length; index++) { 2862 Method* method = parse_method(cfs, 2863 is_interface, 2864 _cp, 2865 has_localvariable_table, 2866 CHECK); 2867 2868 if (method->is_final()) { 2869 *has_final_method = true; 2870 } 2871 // declares_nonstatic_concrete_methods: declares concrete instance methods, any access flags 2872 // used for interface initialization, and default method inheritance analysis 2873 if (is_interface && !(*declares_nonstatic_concrete_methods) 2874 && !method->is_abstract() && !method->is_static()) { 2875 *declares_nonstatic_concrete_methods = true; 2876 } 2877 _methods->at_put(index, method); 2878 } 2879 2880 if (_need_verify && length > 1) { 2881 // Check duplicated methods 2882 ResourceMark rm(THREAD); 2883 // Set containing name-signature pairs 2884 NameSigHashtable* names_and_sigs = new NameSigHashtable(); 2885 for (int i = 0; i < length; i++) { 2886 const Method* const m = _methods->at(i); 2887 NameSigHash name_and_sig(m->name(), m->signature()); 2888 // If no duplicates, add name/signature in hashtable names_and_sigs. 2889 if(!names_and_sigs->put(name_and_sig, 0)) { 2890 classfile_parse_error("Duplicate method name \"%s\" with signature \"%s\" in class file %s", 2891 name_and_sig._name->as_C_string(), name_and_sig._sig->as_klass_external_name(), THREAD); 2892 return; 2893 } 2894 } 2895 } 2896 } 2897 } 2898 2899 static const intArray* sort_methods(Array<Method*>* methods) { 2900 const int length = methods->length(); 2901 // If JVMTI original method ordering or sharing is enabled we have to 2902 // remember the original class file ordering. 2903 // We temporarily use the vtable_index field in the Method* to store the 2904 // class file index, so we can read in after calling qsort. 2905 // Put the method ordering in the shared archive. 2906 if (JvmtiExport::can_maintain_original_method_order() || CDSConfig::is_dumping_archive()) { 2907 for (int index = 0; index < length; index++) { 2908 Method* const m = methods->at(index); 2909 assert(!m->valid_vtable_index(), "vtable index should not be set"); 2910 m->set_vtable_index(index); 2911 } 2912 } 2913 // Sort method array by ascending method name (for faster lookups & vtable construction) 2914 // Note that the ordering is not alphabetical, see Symbol::fast_compare 2915 Method::sort_methods(methods); 2916 2917 intArray* method_ordering = nullptr; 2918 // If JVMTI original method ordering or sharing is enabled construct int 2919 // array remembering the original ordering 2920 if (JvmtiExport::can_maintain_original_method_order() || CDSConfig::is_dumping_archive()) { 2921 method_ordering = new intArray(length, length, -1); 2922 for (int index = 0; index < length; index++) { 2923 Method* const m = methods->at(index); 2924 const int old_index = m->vtable_index(); 2925 assert(old_index >= 0 && old_index < length, "invalid method index"); 2926 method_ordering->at_put(index, old_index); 2927 m->set_vtable_index(Method::invalid_vtable_index); 2928 } 2929 } 2930 return method_ordering; 2931 } 2932 2933 // Parse generic_signature attribute for methods and fields 2934 u2 ClassFileParser::parse_generic_signature_attribute(const ClassFileStream* const cfs, 2935 TRAPS) { 2936 assert(cfs != nullptr, "invariant"); 2937 2938 cfs->guarantee_more(2, CHECK_0); // generic_signature_index 2939 const u2 generic_signature_index = cfs->get_u2_fast(); 2940 guarantee_property( 2941 valid_symbol_at(generic_signature_index), 2942 "Invalid Signature attribute at constant pool index %u in class file %s", 2943 generic_signature_index, CHECK_0); 2944 return generic_signature_index; 2945 } 2946 2947 void ClassFileParser::parse_classfile_sourcefile_attribute(const ClassFileStream* const cfs, 2948 TRAPS) { 2949 2950 assert(cfs != nullptr, "invariant"); 2951 2952 cfs->guarantee_more(2, CHECK); // sourcefile_index 2953 const u2 sourcefile_index = cfs->get_u2_fast(); 2954 guarantee_property( 2955 valid_symbol_at(sourcefile_index), 2956 "Invalid SourceFile attribute at constant pool index %u in class file %s", 2957 sourcefile_index, CHECK); 2958 set_class_sourcefile_index(sourcefile_index); 2959 } 2960 2961 void ClassFileParser::parse_classfile_source_debug_extension_attribute(const ClassFileStream* const cfs, 2962 int length, 2963 TRAPS) { 2964 assert(cfs != nullptr, "invariant"); 2965 2966 const u1* const sde_buffer = cfs->current(); 2967 assert(sde_buffer != nullptr, "null sde buffer"); 2968 2969 // Don't bother storing it if there is no way to retrieve it 2970 if (JvmtiExport::can_get_source_debug_extension()) { 2971 assert((length+1) > length, "Overflow checking"); 2972 u1* const sde = NEW_RESOURCE_ARRAY_IN_THREAD(THREAD, u1, length+1); 2973 for (int i = 0; i < length; i++) { 2974 sde[i] = sde_buffer[i]; 2975 } 2976 sde[length] = '\0'; 2977 set_class_sde_buffer((const char*)sde, length); 2978 } 2979 // Got utf8 string, set stream position forward 2980 cfs->skip_u1(length, CHECK); 2981 } 2982 2983 2984 // Inner classes can be static, private or protected (classic VM does this) 2985 #define RECOGNIZED_INNER_CLASS_MODIFIERS ( JVM_RECOGNIZED_CLASS_MODIFIERS | \ 2986 JVM_ACC_PRIVATE | \ 2987 JVM_ACC_PROTECTED | \ 2988 JVM_ACC_STATIC \ 2989 ) 2990 2991 // Find index of the InnerClasses entry for the specified inner_class_info_index. 2992 // Return -1 if none is found. 2993 static int inner_classes_find_index(const Array<u2>* inner_classes, int inner, const ConstantPool* cp, int length) { 2994 Symbol* cp_klass_name = cp->klass_name_at(inner); 2995 for (int idx = 0; idx < length; idx += InstanceKlass::inner_class_next_offset) { 2996 int idx_inner = inner_classes->at(idx + InstanceKlass::inner_class_inner_class_info_offset); 2997 if (cp->klass_name_at(idx_inner) == cp_klass_name) { 2998 return idx; 2999 } 3000 } 3001 return -1; 3002 } 3003 3004 // Return the outer_class_info_index for the InnerClasses entry containing the 3005 // specified inner_class_info_index. Return -1 if no InnerClasses entry is found. 3006 static int inner_classes_jump_to_outer(const Array<u2>* inner_classes, int inner, const ConstantPool* cp, int length) { 3007 if (inner == 0) return -1; 3008 int idx = inner_classes_find_index(inner_classes, inner, cp, length); 3009 if (idx == -1) return -1; 3010 int result = inner_classes->at(idx + InstanceKlass::inner_class_outer_class_info_offset); 3011 return result; 3012 } 3013 3014 // Return true if circularity is found, false if no circularity is found. 3015 // Use Floyd's cycle finding algorithm. 3016 static bool inner_classes_check_loop_through_outer(const Array<u2>* inner_classes, int idx, const ConstantPool* cp, int length) { 3017 int slow = inner_classes->at(idx + InstanceKlass::inner_class_inner_class_info_offset); 3018 int fast = inner_classes->at(idx + InstanceKlass::inner_class_outer_class_info_offset); 3019 3020 while (fast != -1 && fast != 0) { 3021 if (slow != 0 && (cp->klass_name_at(slow) == cp->klass_name_at(fast))) { 3022 return true; // found a circularity 3023 } 3024 fast = inner_classes_jump_to_outer(inner_classes, fast, cp, length); 3025 if (fast == -1) return false; 3026 fast = inner_classes_jump_to_outer(inner_classes, fast, cp, length); 3027 if (fast == -1) return false; 3028 slow = inner_classes_jump_to_outer(inner_classes, slow, cp, length); 3029 assert(slow != -1, "sanity check"); 3030 } 3031 return false; 3032 } 3033 3034 // Loop through each InnerClasses entry checking for circularities and duplications 3035 // with other entries. If duplicate entries are found then throw CFE. Otherwise, 3036 // return true if a circularity or entries with duplicate inner_class_info_indexes 3037 // are found. 3038 bool ClassFileParser::check_inner_classes_circularity(const ConstantPool* cp, int length, TRAPS) { 3039 // Loop through each InnerClasses entry. 3040 for (int idx = 0; idx < length; idx += InstanceKlass::inner_class_next_offset) { 3041 // Return true if there are circular entries. 3042 if (inner_classes_check_loop_through_outer(_inner_classes, idx, cp, length)) { 3043 return true; 3044 } 3045 // Check if there are duplicate entries or entries with the same inner_class_info_index. 3046 for (int y = idx + InstanceKlass::inner_class_next_offset; y < length; 3047 y += InstanceKlass::inner_class_next_offset) { 3048 3049 // 4347400: make sure there's no duplicate entry in the classes array 3050 if (_major_version >= JAVA_1_5_VERSION) { 3051 guarantee_property((_inner_classes->at(idx) != _inner_classes->at(y) || 3052 _inner_classes->at(idx+1) != _inner_classes->at(y+1) || 3053 _inner_classes->at(idx+2) != _inner_classes->at(y+2) || 3054 _inner_classes->at(idx+3) != _inner_classes->at(y+3)), 3055 "Duplicate entry in InnerClasses attribute in class file %s", 3056 CHECK_(true)); 3057 } 3058 // Return true if there are two entries with the same inner_class_info_index. 3059 if (_inner_classes->at(y) == _inner_classes->at(idx)) { 3060 return true; 3061 } 3062 } 3063 } 3064 return false; 3065 } 3066 3067 // Return number of classes in the inner classes attribute table 3068 u2 ClassFileParser::parse_classfile_inner_classes_attribute(const ClassFileStream* const cfs, 3069 const ConstantPool* cp, 3070 const u1* const inner_classes_attribute_start, 3071 bool parsed_enclosingmethod_attribute, 3072 u2 enclosing_method_class_index, 3073 u2 enclosing_method_method_index, 3074 TRAPS) { 3075 const u1* const current_mark = cfs->current(); 3076 u2 length = 0; 3077 if (inner_classes_attribute_start != nullptr) { 3078 cfs->set_current(inner_classes_attribute_start); 3079 cfs->guarantee_more(2, CHECK_0); // length 3080 length = cfs->get_u2_fast(); 3081 } 3082 3083 // 4-tuples of shorts of inner classes data and 2 shorts of enclosing 3084 // method data: 3085 // [inner_class_info_index, 3086 // outer_class_info_index, 3087 // inner_name_index, 3088 // inner_class_access_flags, 3089 // ... 3090 // enclosing_method_class_index, 3091 // enclosing_method_method_index] 3092 const int size = length * 4 + (parsed_enclosingmethod_attribute ? 2 : 0); 3093 Array<u2>* inner_classes = MetadataFactory::new_array<u2>(_loader_data, size, CHECK_0); 3094 _inner_classes = inner_classes; 3095 3096 int index = 0; 3097 cfs->guarantee_more(8 * length, CHECK_0); // 4-tuples of u2 3098 for (int n = 0; n < length; n++) { 3099 // Inner class index 3100 const u2 inner_class_info_index = cfs->get_u2_fast(); 3101 guarantee_property( 3102 valid_klass_reference_at(inner_class_info_index), 3103 "inner_class_info_index %u has bad constant type in class file %s", 3104 inner_class_info_index, CHECK_0); 3105 // Outer class index 3106 const u2 outer_class_info_index = cfs->get_u2_fast(); 3107 guarantee_property( 3108 outer_class_info_index == 0 || 3109 valid_klass_reference_at(outer_class_info_index), 3110 "outer_class_info_index %u has bad constant type in class file %s", 3111 outer_class_info_index, CHECK_0); 3112 3113 if (outer_class_info_index != 0) { 3114 const Symbol* const outer_class_name = cp->klass_name_at(outer_class_info_index); 3115 char* bytes = (char*)outer_class_name->bytes(); 3116 guarantee_property(bytes[0] != JVM_SIGNATURE_ARRAY, 3117 "Outer class is an array class in class file %s", CHECK_0); 3118 } 3119 // Inner class name 3120 const u2 inner_name_index = cfs->get_u2_fast(); 3121 guarantee_property( 3122 inner_name_index == 0 || valid_symbol_at(inner_name_index), 3123 "inner_name_index %u has bad constant type in class file %s", 3124 inner_name_index, CHECK_0); 3125 if (_need_verify) { 3126 guarantee_property(inner_class_info_index != outer_class_info_index, 3127 "Class is both outer and inner class in class file %s", CHECK_0); 3128 } 3129 3130 // Access flags 3131 u2 flags; 3132 // JVM_ACC_MODULE is defined in JDK-9 and later. 3133 if (_major_version >= JAVA_9_VERSION) { 3134 flags = cfs->get_u2_fast() & (RECOGNIZED_INNER_CLASS_MODIFIERS | JVM_ACC_MODULE); 3135 } else { 3136 flags = cfs->get_u2_fast() & RECOGNIZED_INNER_CLASS_MODIFIERS; 3137 } 3138 3139 if ((flags & JVM_ACC_INTERFACE) && _major_version < JAVA_6_VERSION) { 3140 // Set abstract bit for old class files for backward compatibility 3141 flags |= JVM_ACC_ABSTRACT; 3142 } 3143 3144 if (!supports_inline_types()) { 3145 const bool is_module = (flags & JVM_ACC_MODULE) != 0; 3146 const bool is_interface = (flags & JVM_ACC_INTERFACE) != 0; 3147 if (!is_module && !is_interface) { 3148 flags |= JVM_ACC_IDENTITY; 3149 } 3150 } 3151 3152 Symbol* inner_name_symbol = inner_name_index == 0 ? nullptr : cp->symbol_at(inner_name_index); 3153 verify_legal_class_modifiers(flags, inner_name_symbol, inner_name_index == 0, CHECK_0); 3154 AccessFlags inner_access_flags(flags); 3155 3156 inner_classes->at_put(index++, inner_class_info_index); 3157 inner_classes->at_put(index++, outer_class_info_index); 3158 inner_classes->at_put(index++, inner_name_index); 3159 inner_classes->at_put(index++, inner_access_flags.as_unsigned_short()); 3160 } 3161 3162 // Check for circular and duplicate entries. 3163 bool has_circularity = false; 3164 if (_need_verify) { 3165 has_circularity = check_inner_classes_circularity(cp, length * 4, CHECK_0); 3166 if (has_circularity) { 3167 // If circularity check failed then ignore InnerClasses attribute. 3168 MetadataFactory::free_array<u2>(_loader_data, _inner_classes); 3169 index = 0; 3170 if (parsed_enclosingmethod_attribute) { 3171 inner_classes = MetadataFactory::new_array<u2>(_loader_data, 2, CHECK_0); 3172 _inner_classes = inner_classes; 3173 } else { 3174 _inner_classes = Universe::the_empty_short_array(); 3175 } 3176 } 3177 } 3178 // Set EnclosingMethod class and method indexes. 3179 if (parsed_enclosingmethod_attribute) { 3180 inner_classes->at_put(index++, enclosing_method_class_index); 3181 inner_classes->at_put(index++, enclosing_method_method_index); 3182 } 3183 assert(index == size || has_circularity, "wrong size"); 3184 3185 // Restore buffer's current position. 3186 cfs->set_current(current_mark); 3187 3188 return length; 3189 } 3190 3191 u2 ClassFileParser::parse_classfile_nest_members_attribute(const ClassFileStream* const cfs, 3192 const u1* const nest_members_attribute_start, 3193 TRAPS) { 3194 const u1* const current_mark = cfs->current(); 3195 u2 length = 0; 3196 if (nest_members_attribute_start != nullptr) { 3197 cfs->set_current(nest_members_attribute_start); 3198 cfs->guarantee_more(2, CHECK_0); // length 3199 length = cfs->get_u2_fast(); 3200 } 3201 const int size = length; 3202 Array<u2>* const nest_members = MetadataFactory::new_array<u2>(_loader_data, size, CHECK_0); 3203 _nest_members = nest_members; 3204 3205 int index = 0; 3206 cfs->guarantee_more(2 * length, CHECK_0); 3207 for (int n = 0; n < length; n++) { 3208 const u2 class_info_index = cfs->get_u2_fast(); 3209 guarantee_property( 3210 valid_klass_reference_at(class_info_index), 3211 "Nest member class_info_index %u has bad constant type in class file %s", 3212 class_info_index, CHECK_0); 3213 nest_members->at_put(index++, class_info_index); 3214 } 3215 assert(index == size, "wrong size"); 3216 3217 // Restore buffer's current position. 3218 cfs->set_current(current_mark); 3219 3220 return length; 3221 } 3222 3223 u2 ClassFileParser::parse_classfile_permitted_subclasses_attribute(const ClassFileStream* const cfs, 3224 const u1* const permitted_subclasses_attribute_start, 3225 TRAPS) { 3226 const u1* const current_mark = cfs->current(); 3227 u2 length = 0; 3228 if (permitted_subclasses_attribute_start != nullptr) { 3229 cfs->set_current(permitted_subclasses_attribute_start); 3230 cfs->guarantee_more(2, CHECK_0); // length 3231 length = cfs->get_u2_fast(); 3232 } 3233 const int size = length; 3234 Array<u2>* const permitted_subclasses = MetadataFactory::new_array<u2>(_loader_data, size, CHECK_0); 3235 _permitted_subclasses = permitted_subclasses; 3236 3237 if (length > 0) { 3238 int index = 0; 3239 cfs->guarantee_more(2 * length, CHECK_0); 3240 for (int n = 0; n < length; n++) { 3241 const u2 class_info_index = cfs->get_u2_fast(); 3242 guarantee_property( 3243 valid_klass_reference_at(class_info_index), 3244 "Permitted subclass class_info_index %u has bad constant type in class file %s", 3245 class_info_index, CHECK_0); 3246 permitted_subclasses->at_put(index++, class_info_index); 3247 } 3248 assert(index == size, "wrong size"); 3249 } 3250 3251 // Restore buffer's current position. 3252 cfs->set_current(current_mark); 3253 3254 return length; 3255 } 3256 3257 u2 ClassFileParser::parse_classfile_loadable_descriptors_attribute(const ClassFileStream* const cfs, 3258 const u1* const loadable_descriptors_attribute_start, 3259 TRAPS) { 3260 const u1* const current_mark = cfs->current(); 3261 u2 length = 0; 3262 if (loadable_descriptors_attribute_start != nullptr) { 3263 cfs->set_current(loadable_descriptors_attribute_start); 3264 cfs->guarantee_more(2, CHECK_0); // length 3265 length = cfs->get_u2_fast(); 3266 } 3267 const int size = length; 3268 Array<u2>* const loadable_descriptors = MetadataFactory::new_array<u2>(_loader_data, size, CHECK_0); 3269 _loadable_descriptors = loadable_descriptors; 3270 if (length > 0) { 3271 int index = 0; 3272 cfs->guarantee_more(2 * length, CHECK_0); 3273 for (int n = 0; n < length; n++) { 3274 const u2 descriptor_index = cfs->get_u2_fast(); 3275 guarantee_property( 3276 valid_symbol_at(descriptor_index), 3277 "LoadableDescriptors descriptor_index %u has bad constant type in class file %s", 3278 descriptor_index, CHECK_0); 3279 Symbol* descriptor = _cp->symbol_at(descriptor_index); 3280 bool valid = legal_field_signature(descriptor, CHECK_0); 3281 if(!valid) { 3282 ResourceMark rm(THREAD); 3283 Exceptions::fthrow(THREAD_AND_LOCATION, 3284 vmSymbols::java_lang_ClassFormatError(), 3285 "Descriptor from LoadableDescriptors attribute at index \"%d\" in class %s has illegal signature \"%s\"", 3286 descriptor_index, _class_name->as_C_string(), descriptor->as_C_string()); 3287 return 0; 3288 } 3289 loadable_descriptors->at_put(index++, descriptor_index); 3290 } 3291 assert(index == size, "wrong size"); 3292 } 3293 3294 // Restore buffer's current position. 3295 cfs->set_current(current_mark); 3296 3297 return length; 3298 } 3299 3300 // Record { 3301 // u2 attribute_name_index; 3302 // u4 attribute_length; 3303 // u2 components_count; 3304 // component_info components[components_count]; 3305 // } 3306 // component_info { 3307 // u2 name_index; 3308 // u2 descriptor_index 3309 // u2 attributes_count; 3310 // attribute_info_attributes[attributes_count]; 3311 // } 3312 u4 ClassFileParser::parse_classfile_record_attribute(const ClassFileStream* const cfs, 3313 const ConstantPool* cp, 3314 const u1* const record_attribute_start, 3315 TRAPS) { 3316 const u1* const current_mark = cfs->current(); 3317 int components_count = 0; 3318 unsigned int calculate_attr_size = 0; 3319 if (record_attribute_start != nullptr) { 3320 cfs->set_current(record_attribute_start); 3321 cfs->guarantee_more(2, CHECK_0); // num of components 3322 components_count = (int)cfs->get_u2_fast(); 3323 calculate_attr_size = 2; 3324 } 3325 3326 Array<RecordComponent*>* const record_components = 3327 MetadataFactory::new_array<RecordComponent*>(_loader_data, components_count, nullptr, CHECK_0); 3328 _record_components = record_components; 3329 3330 for (int x = 0; x < components_count; x++) { 3331 cfs->guarantee_more(6, CHECK_0); // name_index, descriptor_index, attributes_count 3332 3333 const u2 name_index = cfs->get_u2_fast(); 3334 guarantee_property(valid_symbol_at(name_index), 3335 "Invalid constant pool index %u for name in Record attribute in class file %s", 3336 name_index, CHECK_0); 3337 const Symbol* const name = cp->symbol_at(name_index); 3338 verify_legal_field_name(name, CHECK_0); 3339 3340 const u2 descriptor_index = cfs->get_u2_fast(); 3341 guarantee_property(valid_symbol_at(descriptor_index), 3342 "Invalid constant pool index %u for descriptor in Record attribute in class file %s", 3343 descriptor_index, CHECK_0); 3344 const Symbol* const descr = cp->symbol_at(descriptor_index); 3345 verify_legal_field_signature(name, descr, CHECK_0); 3346 3347 const u2 attributes_count = cfs->get_u2_fast(); 3348 calculate_attr_size += 6; 3349 u2 generic_sig_index = 0; 3350 const u1* runtime_visible_annotations = nullptr; 3351 int runtime_visible_annotations_length = 0; 3352 bool runtime_invisible_annotations_exists = false; 3353 const u1* runtime_visible_type_annotations = nullptr; 3354 int runtime_visible_type_annotations_length = 0; 3355 bool runtime_invisible_type_annotations_exists = false; 3356 3357 // Expected attributes for record components are Signature, Runtime(In)VisibleAnnotations, 3358 // and Runtime(In)VisibleTypeAnnotations. Other attributes are ignored. 3359 for (int y = 0; y < attributes_count; y++) { 3360 cfs->guarantee_more(6, CHECK_0); // attribute_name_index, attribute_length 3361 const u2 attribute_name_index = cfs->get_u2_fast(); 3362 const u4 attribute_length = cfs->get_u4_fast(); 3363 calculate_attr_size += 6; 3364 guarantee_property( 3365 valid_symbol_at(attribute_name_index), 3366 "Invalid Record attribute name index %u in class file %s", 3367 attribute_name_index, CHECK_0); 3368 3369 const Symbol* const attribute_name = cp->symbol_at(attribute_name_index); 3370 if (attribute_name == vmSymbols::tag_signature()) { 3371 if (generic_sig_index != 0) { 3372 classfile_parse_error( 3373 "Multiple Signature attributes for Record component in class file %s", 3374 THREAD); 3375 return 0; 3376 } 3377 if (attribute_length != 2) { 3378 classfile_parse_error( 3379 "Invalid Signature attribute length %u in Record component in class file %s", 3380 attribute_length, THREAD); 3381 return 0; 3382 } 3383 generic_sig_index = parse_generic_signature_attribute(cfs, CHECK_0); 3384 3385 } else if (attribute_name == vmSymbols::tag_runtime_visible_annotations()) { 3386 if (runtime_visible_annotations != nullptr) { 3387 classfile_parse_error( 3388 "Multiple RuntimeVisibleAnnotations attributes for Record component in class file %s", THREAD); 3389 return 0; 3390 } 3391 runtime_visible_annotations_length = attribute_length; 3392 runtime_visible_annotations = cfs->current(); 3393 3394 assert(runtime_visible_annotations != nullptr, "null record component visible annotation"); 3395 cfs->guarantee_more(runtime_visible_annotations_length, CHECK_0); 3396 cfs->skip_u1_fast(runtime_visible_annotations_length); 3397 3398 } else if (attribute_name == vmSymbols::tag_runtime_invisible_annotations()) { 3399 if (runtime_invisible_annotations_exists) { 3400 classfile_parse_error( 3401 "Multiple RuntimeInvisibleAnnotations attributes for Record component in class file %s", THREAD); 3402 return 0; 3403 } 3404 runtime_invisible_annotations_exists = true; 3405 cfs->skip_u1(attribute_length, CHECK_0); 3406 3407 } else if (attribute_name == vmSymbols::tag_runtime_visible_type_annotations()) { 3408 if (runtime_visible_type_annotations != nullptr) { 3409 classfile_parse_error( 3410 "Multiple RuntimeVisibleTypeAnnotations attributes for Record component in class file %s", THREAD); 3411 return 0; 3412 } 3413 runtime_visible_type_annotations_length = attribute_length; 3414 runtime_visible_type_annotations = cfs->current(); 3415 3416 assert(runtime_visible_type_annotations != nullptr, "null record component visible type annotation"); 3417 cfs->guarantee_more(runtime_visible_type_annotations_length, CHECK_0); 3418 cfs->skip_u1_fast(runtime_visible_type_annotations_length); 3419 3420 } else if (attribute_name == vmSymbols::tag_runtime_invisible_type_annotations()) { 3421 if (runtime_invisible_type_annotations_exists) { 3422 classfile_parse_error( 3423 "Multiple RuntimeInvisibleTypeAnnotations attributes for Record component in class file %s", THREAD); 3424 return 0; 3425 } 3426 runtime_invisible_type_annotations_exists = true; 3427 cfs->skip_u1(attribute_length, CHECK_0); 3428 3429 } else { 3430 // Skip unknown attributes 3431 cfs->skip_u1(attribute_length, CHECK_0); 3432 } 3433 calculate_attr_size += attribute_length; 3434 } // End of attributes For loop 3435 3436 AnnotationArray* annotations = allocate_annotations(runtime_visible_annotations, 3437 runtime_visible_annotations_length, 3438 CHECK_0); 3439 AnnotationArray* type_annotations = allocate_annotations(runtime_visible_type_annotations, 3440 runtime_visible_type_annotations_length, 3441 CHECK_0); 3442 3443 RecordComponent* record_component = 3444 RecordComponent::allocate(_loader_data, name_index, descriptor_index, generic_sig_index, 3445 annotations, type_annotations, CHECK_0); 3446 record_components->at_put(x, record_component); 3447 } // End of component processing loop 3448 3449 // Restore buffer's current position. 3450 cfs->set_current(current_mark); 3451 return calculate_attr_size; 3452 } 3453 3454 void ClassFileParser::parse_classfile_synthetic_attribute() { 3455 set_class_synthetic_flag(true); 3456 } 3457 3458 void ClassFileParser::parse_classfile_signature_attribute(const ClassFileStream* const cfs, TRAPS) { 3459 assert(cfs != nullptr, "invariant"); 3460 3461 const u2 signature_index = cfs->get_u2(CHECK); 3462 guarantee_property( 3463 valid_symbol_at(signature_index), 3464 "Invalid constant pool index %u in Signature attribute in class file %s", 3465 signature_index, CHECK); 3466 set_class_generic_signature_index(signature_index); 3467 } 3468 3469 void ClassFileParser::parse_classfile_bootstrap_methods_attribute(const ClassFileStream* const cfs, 3470 ConstantPool* cp, 3471 u4 attribute_byte_length, 3472 TRAPS) { 3473 assert(cfs != nullptr, "invariant"); 3474 assert(cp != nullptr, "invariant"); 3475 const int cp_size = cp->length(); 3476 3477 const u1* const current_before_parsing = cfs->current(); 3478 3479 guarantee_property(attribute_byte_length >= sizeof(u2), 3480 "Invalid BootstrapMethods attribute length %u in class file %s", 3481 attribute_byte_length, 3482 CHECK); 3483 3484 cfs->guarantee_more(attribute_byte_length, CHECK); 3485 3486 const int num_bootstrap_methods = cfs->get_u2_fast(); 3487 3488 guarantee_property(_max_bootstrap_specifier_index < num_bootstrap_methods, 3489 "Short length on BootstrapMethods in class file %s", 3490 CHECK); 3491 3492 const u4 bootstrap_methods_u2_len = (attribute_byte_length - sizeof(u2)) / sizeof(u2); 3493 3494 // Eagerly assign the arrays so that they will be deallocated with the constant 3495 // pool if there is an error. 3496 BSMAttributeEntries::InsertionIterator iter = 3497 cp->bsm_entries().start_extension(num_bootstrap_methods, 3498 bootstrap_methods_u2_len, 3499 _loader_data, 3500 CHECK); 3501 3502 for (int i = 0; i < num_bootstrap_methods; i++) { 3503 cfs->guarantee_more(sizeof(u2) * 2, CHECK); // bsm, argc 3504 u2 bootstrap_method_ref = cfs->get_u2_fast(); 3505 u2 num_bootstrap_arguments = cfs->get_u2_fast(); 3506 guarantee_property( 3507 valid_cp_range(bootstrap_method_ref, cp_size) && 3508 cp->tag_at(bootstrap_method_ref).is_method_handle(), 3509 "bootstrap_method_index %u has bad constant type in class file %s", 3510 bootstrap_method_ref, 3511 CHECK); 3512 cfs->guarantee_more(sizeof(u2) * num_bootstrap_arguments, CHECK); // argv[argc] 3513 3514 BSMAttributeEntry* entry = iter.reserve_new_entry(bootstrap_method_ref, num_bootstrap_arguments); 3515 guarantee_property(entry != nullptr, 3516 "Invalid BootstrapMethods num_bootstrap_methods." 3517 " The total amount of space reserved for the BootstrapMethod attribute was not sufficient", CHECK); 3518 3519 for (int argi = 0; argi < num_bootstrap_arguments; argi++) { 3520 const u2 argument_index = cfs->get_u2_fast(); 3521 guarantee_property( 3522 valid_cp_range(argument_index, cp_size) && 3523 cp->tag_at(argument_index).is_loadable_constant(), 3524 "argument_index %u has bad constant type in class file %s", 3525 argument_index, 3526 CHECK); 3527 entry->set_argument(argi, argument_index); 3528 } 3529 } 3530 cp->bsm_entries().end_extension(iter, _loader_data, CHECK); 3531 guarantee_property(current_before_parsing + attribute_byte_length == cfs->current(), 3532 "Bad length on BootstrapMethods in class file %s", 3533 CHECK); 3534 } 3535 3536 void ClassFileParser::parse_classfile_attributes(const ClassFileStream* const cfs, 3537 ConstantPool* cp, 3538 ClassFileParser::ClassAnnotationCollector* parsed_annotations, 3539 TRAPS) { 3540 assert(cfs != nullptr, "invariant"); 3541 assert(cp != nullptr, "invariant"); 3542 assert(parsed_annotations != nullptr, "invariant"); 3543 3544 // Set inner classes attribute to default sentinel 3545 _inner_classes = Universe::the_empty_short_array(); 3546 // Set nest members attribute to default sentinel 3547 _nest_members = Universe::the_empty_short_array(); 3548 // Set _permitted_subclasses attribute to default sentinel 3549 _permitted_subclasses = Universe::the_empty_short_array(); 3550 // Set _loadable_descriptors attribute to default sentinel 3551 _loadable_descriptors = Universe::the_empty_short_array(); 3552 cfs->guarantee_more(2, CHECK); // attributes_count 3553 u2 attributes_count = cfs->get_u2_fast(); 3554 bool parsed_sourcefile_attribute = false; 3555 bool parsed_innerclasses_attribute = false; 3556 bool parsed_nest_members_attribute = false; 3557 bool parsed_permitted_subclasses_attribute = false; 3558 bool parsed_loadable_descriptors_attribute = false; 3559 bool parsed_nest_host_attribute = false; 3560 bool parsed_record_attribute = false; 3561 bool parsed_enclosingmethod_attribute = false; 3562 bool parsed_bootstrap_methods_attribute = false; 3563 const u1* runtime_visible_annotations = nullptr; 3564 int runtime_visible_annotations_length = 0; 3565 const u1* runtime_visible_type_annotations = nullptr; 3566 int runtime_visible_type_annotations_length = 0; 3567 bool runtime_invisible_type_annotations_exists = false; 3568 bool runtime_invisible_annotations_exists = false; 3569 bool parsed_source_debug_ext_annotations_exist = false; 3570 const u1* inner_classes_attribute_start = nullptr; 3571 u4 inner_classes_attribute_length = 0; 3572 u2 enclosing_method_class_index = 0; 3573 u2 enclosing_method_method_index = 0; 3574 const u1* nest_members_attribute_start = nullptr; 3575 u4 nest_members_attribute_length = 0; 3576 const u1* record_attribute_start = nullptr; 3577 u4 record_attribute_length = 0; 3578 const u1* permitted_subclasses_attribute_start = nullptr; 3579 u4 permitted_subclasses_attribute_length = 0; 3580 const u1* loadable_descriptors_attribute_start = nullptr; 3581 u4 loadable_descriptors_attribute_length = 0; 3582 3583 // Iterate over attributes 3584 while (attributes_count--) { 3585 cfs->guarantee_more(6, CHECK); // attribute_name_index, attribute_length 3586 const u2 attribute_name_index = cfs->get_u2_fast(); 3587 const u4 attribute_length = cfs->get_u4_fast(); 3588 guarantee_property( 3589 valid_symbol_at(attribute_name_index), 3590 "Attribute name has bad constant pool index %u in class file %s", 3591 attribute_name_index, CHECK); 3592 const Symbol* const tag = cp->symbol_at(attribute_name_index); 3593 if (tag == vmSymbols::tag_source_file()) { 3594 // Check for SourceFile tag 3595 if (_need_verify) { 3596 guarantee_property(attribute_length == 2, "Wrong SourceFile attribute length in class file %s", CHECK); 3597 } 3598 if (parsed_sourcefile_attribute) { 3599 classfile_parse_error("Multiple SourceFile attributes in class file %s", THREAD); 3600 return; 3601 } else { 3602 parsed_sourcefile_attribute = true; 3603 } 3604 parse_classfile_sourcefile_attribute(cfs, CHECK); 3605 } else if (tag == vmSymbols::tag_source_debug_extension()) { 3606 // Check for SourceDebugExtension tag 3607 if (parsed_source_debug_ext_annotations_exist) { 3608 classfile_parse_error( 3609 "Multiple SourceDebugExtension attributes in class file %s", THREAD); 3610 return; 3611 } 3612 parsed_source_debug_ext_annotations_exist = true; 3613 parse_classfile_source_debug_extension_attribute(cfs, (int)attribute_length, CHECK); 3614 } else if (tag == vmSymbols::tag_inner_classes()) { 3615 // Check for InnerClasses tag 3616 if (parsed_innerclasses_attribute) { 3617 classfile_parse_error("Multiple InnerClasses attributes in class file %s", THREAD); 3618 return; 3619 } else { 3620 parsed_innerclasses_attribute = true; 3621 } 3622 inner_classes_attribute_start = cfs->current(); 3623 inner_classes_attribute_length = attribute_length; 3624 cfs->skip_u1(inner_classes_attribute_length, CHECK); 3625 } else if (tag == vmSymbols::tag_synthetic()) { 3626 // Check for Synthetic tag 3627 // Shouldn't we check that the synthetic flags wasn't already set? - not required in spec 3628 if (attribute_length != 0) { 3629 classfile_parse_error( 3630 "Invalid Synthetic classfile attribute length %u in class file %s", 3631 attribute_length, THREAD); 3632 return; 3633 } 3634 parse_classfile_synthetic_attribute(); 3635 } else if (tag == vmSymbols::tag_deprecated()) { 3636 // Check for Deprecated tag - 4276120 3637 if (attribute_length != 0) { 3638 classfile_parse_error( 3639 "Invalid Deprecated classfile attribute length %u in class file %s", 3640 attribute_length, THREAD); 3641 return; 3642 } 3643 } else if (_major_version >= JAVA_1_5_VERSION) { 3644 if (tag == vmSymbols::tag_signature()) { 3645 if (_generic_signature_index != 0) { 3646 classfile_parse_error( 3647 "Multiple Signature attributes in class file %s", THREAD); 3648 return; 3649 } 3650 if (attribute_length != 2) { 3651 classfile_parse_error( 3652 "Wrong Signature attribute length %u in class file %s", 3653 attribute_length, THREAD); 3654 return; 3655 } 3656 parse_classfile_signature_attribute(cfs, CHECK); 3657 } else if (tag == vmSymbols::tag_runtime_visible_annotations()) { 3658 if (runtime_visible_annotations != nullptr) { 3659 classfile_parse_error( 3660 "Multiple RuntimeVisibleAnnotations attributes in class file %s", THREAD); 3661 return; 3662 } 3663 runtime_visible_annotations_length = attribute_length; 3664 runtime_visible_annotations = cfs->current(); 3665 assert(runtime_visible_annotations != nullptr, "null visible annotations"); 3666 cfs->guarantee_more(runtime_visible_annotations_length, CHECK); 3667 parse_annotations(cp, 3668 runtime_visible_annotations, 3669 runtime_visible_annotations_length, 3670 parsed_annotations, 3671 _loader_data, 3672 _can_access_vm_annotations); 3673 cfs->skip_u1_fast(runtime_visible_annotations_length); 3674 } else if (tag == vmSymbols::tag_runtime_invisible_annotations()) { 3675 if (runtime_invisible_annotations_exists) { 3676 classfile_parse_error( 3677 "Multiple RuntimeInvisibleAnnotations attributes in class file %s", THREAD); 3678 return; 3679 } 3680 runtime_invisible_annotations_exists = true; 3681 cfs->skip_u1(attribute_length, CHECK); 3682 } else if (tag == vmSymbols::tag_enclosing_method()) { 3683 if (parsed_enclosingmethod_attribute) { 3684 classfile_parse_error("Multiple EnclosingMethod attributes in class file %s", THREAD); 3685 return; 3686 } else { 3687 parsed_enclosingmethod_attribute = true; 3688 } 3689 guarantee_property(attribute_length == 4, 3690 "Wrong EnclosingMethod attribute length %u in class file %s", 3691 attribute_length, CHECK); 3692 cfs->guarantee_more(4, CHECK); // class_index, method_index 3693 enclosing_method_class_index = cfs->get_u2_fast(); 3694 enclosing_method_method_index = cfs->get_u2_fast(); 3695 if (enclosing_method_class_index == 0) { 3696 classfile_parse_error("Invalid class index in EnclosingMethod attribute in class file %s", THREAD); 3697 return; 3698 } 3699 // Validate the constant pool indices and types 3700 guarantee_property(valid_klass_reference_at(enclosing_method_class_index), 3701 "Invalid or out-of-bounds class index in EnclosingMethod attribute in class file %s", CHECK); 3702 if (enclosing_method_method_index != 0 && 3703 (!cp->is_within_bounds(enclosing_method_method_index) || 3704 !cp->tag_at(enclosing_method_method_index).is_name_and_type())) { 3705 classfile_parse_error("Invalid or out-of-bounds method index in EnclosingMethod attribute in class file %s", THREAD); 3706 return; 3707 } 3708 } else if (tag == vmSymbols::tag_bootstrap_methods() && 3709 _major_version >= Verifier::INVOKEDYNAMIC_MAJOR_VERSION) { 3710 if (parsed_bootstrap_methods_attribute) { 3711 classfile_parse_error("Multiple BootstrapMethods attributes in class file %s", THREAD); 3712 return; 3713 } 3714 parsed_bootstrap_methods_attribute = true; 3715 parse_classfile_bootstrap_methods_attribute(cfs, cp, attribute_length, CHECK); 3716 } else if (tag == vmSymbols::tag_runtime_visible_type_annotations()) { 3717 if (runtime_visible_type_annotations != nullptr) { 3718 classfile_parse_error( 3719 "Multiple RuntimeVisibleTypeAnnotations attributes in class file %s", THREAD); 3720 return; 3721 } 3722 runtime_visible_type_annotations_length = attribute_length; 3723 runtime_visible_type_annotations = cfs->current(); 3724 assert(runtime_visible_type_annotations != nullptr, "null visible type annotations"); 3725 // No need for the VM to parse Type annotations 3726 cfs->skip_u1(runtime_visible_type_annotations_length, CHECK); 3727 } else if (tag == vmSymbols::tag_runtime_invisible_type_annotations()) { 3728 if (runtime_invisible_type_annotations_exists) { 3729 classfile_parse_error( 3730 "Multiple RuntimeInvisibleTypeAnnotations attributes in class file %s", THREAD); 3731 return; 3732 } 3733 runtime_invisible_type_annotations_exists = true; 3734 cfs->skip_u1(attribute_length, CHECK); 3735 } else if (_major_version >= JAVA_11_VERSION) { 3736 if (tag == vmSymbols::tag_nest_members()) { 3737 // Check for NestMembers tag 3738 if (parsed_nest_members_attribute) { 3739 classfile_parse_error("Multiple NestMembers attributes in class file %s", THREAD); 3740 return; 3741 } else { 3742 parsed_nest_members_attribute = true; 3743 } 3744 if (parsed_nest_host_attribute) { 3745 classfile_parse_error("Conflicting NestHost and NestMembers attributes in class file %s", THREAD); 3746 return; 3747 } 3748 nest_members_attribute_start = cfs->current(); 3749 nest_members_attribute_length = attribute_length; 3750 cfs->skip_u1(nest_members_attribute_length, CHECK); 3751 } else if (tag == vmSymbols::tag_nest_host()) { 3752 if (parsed_nest_host_attribute) { 3753 classfile_parse_error("Multiple NestHost attributes in class file %s", THREAD); 3754 return; 3755 } else { 3756 parsed_nest_host_attribute = true; 3757 } 3758 if (parsed_nest_members_attribute) { 3759 classfile_parse_error("Conflicting NestMembers and NestHost attributes in class file %s", THREAD); 3760 return; 3761 } 3762 if (_need_verify) { 3763 guarantee_property(attribute_length == 2, "Wrong NestHost attribute length in class file %s", CHECK); 3764 } 3765 cfs->guarantee_more(2, CHECK); 3766 u2 class_info_index = cfs->get_u2_fast(); 3767 guarantee_property( 3768 valid_klass_reference_at(class_info_index), 3769 "Nest-host class_info_index %u has bad constant type in class file %s", 3770 class_info_index, CHECK); 3771 _nest_host = class_info_index; 3772 3773 } else if (_major_version >= JAVA_16_VERSION) { 3774 if (tag == vmSymbols::tag_record()) { 3775 if (parsed_record_attribute) { 3776 classfile_parse_error("Multiple Record attributes in class file %s", THREAD); 3777 return; 3778 } 3779 parsed_record_attribute = true; 3780 record_attribute_start = cfs->current(); 3781 record_attribute_length = attribute_length; 3782 } else if (_major_version >= JAVA_17_VERSION) { 3783 if (tag == vmSymbols::tag_permitted_subclasses()) { 3784 if (parsed_permitted_subclasses_attribute) { 3785 classfile_parse_error("Multiple PermittedSubclasses attributes in class file %s", CHECK); 3786 return; 3787 } 3788 // Classes marked ACC_FINAL cannot have a PermittedSubclasses attribute. 3789 if (_access_flags.is_final()) { 3790 classfile_parse_error("PermittedSubclasses attribute in final class file %s", CHECK); 3791 return; 3792 } 3793 parsed_permitted_subclasses_attribute = true; 3794 permitted_subclasses_attribute_start = cfs->current(); 3795 permitted_subclasses_attribute_length = attribute_length; 3796 } 3797 if (Arguments::is_valhalla_enabled() && tag == vmSymbols::tag_loadable_descriptors()) { 3798 if (parsed_loadable_descriptors_attribute) { 3799 classfile_parse_error("Multiple LoadableDescriptors attributes in class file %s", CHECK); 3800 return; 3801 } 3802 parsed_loadable_descriptors_attribute = true; 3803 loadable_descriptors_attribute_start = cfs->current(); 3804 loadable_descriptors_attribute_length = attribute_length; 3805 } 3806 } 3807 // Skip attribute_length for any attribute where major_verson >= JAVA_17_VERSION 3808 cfs->skip_u1(attribute_length, CHECK); 3809 } else { 3810 // Unknown attribute 3811 cfs->skip_u1(attribute_length, CHECK); 3812 } 3813 } else { 3814 // Unknown attribute 3815 cfs->skip_u1(attribute_length, CHECK); 3816 } 3817 } else { 3818 // Unknown attribute 3819 cfs->skip_u1(attribute_length, CHECK); 3820 } 3821 } 3822 _class_annotations = allocate_annotations(runtime_visible_annotations, 3823 runtime_visible_annotations_length, 3824 CHECK); 3825 _class_type_annotations = allocate_annotations(runtime_visible_type_annotations, 3826 runtime_visible_type_annotations_length, 3827 CHECK); 3828 3829 if (parsed_innerclasses_attribute || parsed_enclosingmethod_attribute) { 3830 const u2 num_of_classes = parse_classfile_inner_classes_attribute( 3831 cfs, 3832 cp, 3833 inner_classes_attribute_start, 3834 parsed_innerclasses_attribute, 3835 enclosing_method_class_index, 3836 enclosing_method_method_index, 3837 CHECK); 3838 if (parsed_innerclasses_attribute && _need_verify && _major_version >= JAVA_1_5_VERSION) { 3839 guarantee_property( 3840 inner_classes_attribute_length == sizeof(num_of_classes) + 4 * sizeof(u2) * num_of_classes, 3841 "Wrong InnerClasses attribute length in class file %s", CHECK); 3842 } 3843 } 3844 3845 if (parsed_nest_members_attribute) { 3846 const u2 num_of_classes = parse_classfile_nest_members_attribute( 3847 cfs, 3848 nest_members_attribute_start, 3849 CHECK); 3850 if (_need_verify) { 3851 guarantee_property( 3852 nest_members_attribute_length == sizeof(num_of_classes) + sizeof(u2) * num_of_classes, 3853 "Wrong NestMembers attribute length in class file %s", CHECK); 3854 } 3855 } 3856 3857 if (parsed_record_attribute) { 3858 const unsigned int calculated_attr_length = parse_classfile_record_attribute( 3859 cfs, 3860 cp, 3861 record_attribute_start, 3862 CHECK); 3863 if (_need_verify) { 3864 guarantee_property(record_attribute_length == calculated_attr_length, 3865 "Record attribute has wrong length in class file %s", 3866 CHECK); 3867 } 3868 } 3869 3870 if (parsed_permitted_subclasses_attribute) { 3871 const u2 num_subclasses = parse_classfile_permitted_subclasses_attribute( 3872 cfs, 3873 permitted_subclasses_attribute_start, 3874 CHECK); 3875 if (_need_verify) { 3876 guarantee_property( 3877 permitted_subclasses_attribute_length == sizeof(num_subclasses) + sizeof(u2) * num_subclasses, 3878 "Wrong PermittedSubclasses attribute length in class file %s", CHECK); 3879 } 3880 } 3881 3882 if (parsed_loadable_descriptors_attribute) { 3883 const u2 num_classes = parse_classfile_loadable_descriptors_attribute( 3884 cfs, 3885 loadable_descriptors_attribute_start, 3886 CHECK); 3887 if (_need_verify) { 3888 guarantee_property( 3889 loadable_descriptors_attribute_length == sizeof(num_classes) + sizeof(u2) * num_classes, 3890 "Wrong LoadableDescriptors attribute length in class file %s", CHECK); 3891 } 3892 } 3893 3894 if (_max_bootstrap_specifier_index >= 0) { 3895 guarantee_property(parsed_bootstrap_methods_attribute, 3896 "Missing BootstrapMethods attribute in class file %s", CHECK); 3897 } 3898 } 3899 3900 void ClassFileParser::apply_parsed_class_attributes(InstanceKlass* k) { 3901 assert(k != nullptr, "invariant"); 3902 3903 if (_synthetic_flag) 3904 k->set_is_synthetic(); 3905 if (_sourcefile_index != 0) { 3906 k->set_source_file_name_index(_sourcefile_index); 3907 } 3908 if (_generic_signature_index != 0) { 3909 k->set_generic_signature_index(_generic_signature_index); 3910 } 3911 if (_sde_buffer != nullptr) { 3912 k->set_source_debug_extension(_sde_buffer, _sde_length); 3913 } 3914 } 3915 3916 // Create the Annotations object that will 3917 // hold the annotations array for the Klass. 3918 void ClassFileParser::create_combined_annotations(TRAPS) { 3919 if (_class_annotations == nullptr && 3920 _class_type_annotations == nullptr && 3921 _fields_annotations == nullptr && 3922 _fields_type_annotations == nullptr) { 3923 // Don't create the Annotations object unnecessarily. 3924 return; 3925 } 3926 3927 Annotations* const annotations = Annotations::allocate(_loader_data, CHECK); 3928 annotations->set_class_annotations(_class_annotations); 3929 annotations->set_class_type_annotations(_class_type_annotations); 3930 annotations->set_fields_annotations(_fields_annotations); 3931 annotations->set_fields_type_annotations(_fields_type_annotations); 3932 3933 // This is the Annotations object that will be 3934 // assigned to InstanceKlass being constructed. 3935 _combined_annotations = annotations; 3936 3937 // The annotations arrays below has been transferred the 3938 // _combined_annotations so these fields can now be cleared. 3939 _class_annotations = nullptr; 3940 _class_type_annotations = nullptr; 3941 _fields_annotations = nullptr; 3942 _fields_type_annotations = nullptr; 3943 } 3944 3945 // Transfer ownership of metadata allocated to the InstanceKlass. 3946 void ClassFileParser::apply_parsed_class_metadata( 3947 InstanceKlass* this_klass, 3948 int java_fields_count) { 3949 assert(this_klass != nullptr, "invariant"); 3950 3951 _cp->set_pool_holder(this_klass); 3952 this_klass->set_constants(_cp); 3953 this_klass->set_fieldinfo_stream(_fieldinfo_stream); 3954 this_klass->set_fieldinfo_search_table(_fieldinfo_search_table); 3955 this_klass->set_fields_status(_fields_status); 3956 this_klass->set_methods(_methods); 3957 this_klass->set_inner_classes(_inner_classes); 3958 this_klass->set_nest_members(_nest_members); 3959 this_klass->set_nest_host_index(_nest_host); 3960 this_klass->set_loadable_descriptors(_loadable_descriptors); 3961 this_klass->set_annotations(_combined_annotations); 3962 this_klass->set_permitted_subclasses(_permitted_subclasses); 3963 this_klass->set_record_components(_record_components); 3964 this_klass->set_inline_layout_info_array(_inline_layout_info_array); 3965 3966 DEBUG_ONLY(FieldInfoStream::validate_search_table(_cp, _fieldinfo_stream, _fieldinfo_search_table)); 3967 3968 // Delay the setting of _local_interfaces and _transitive_interfaces until after 3969 // initialize_supers() in fill_instance_klass(). It is because the _local_interfaces could 3970 // be shared with _transitive_interfaces and _transitive_interfaces may be shared with 3971 // its _super. If an OOM occurs while loading the current klass, its _super field 3972 // may not have been set. When GC tries to free the klass, the _transitive_interfaces 3973 // may be deallocated mistakenly in InstanceKlass::deallocate_interfaces(). Subsequent 3974 // dereferences to the deallocated _transitive_interfaces will result in a crash. 3975 3976 // Clear out these fields so they don't get deallocated by the destructor 3977 clear_class_metadata(); 3978 } 3979 3980 AnnotationArray* ClassFileParser::allocate_annotations(const u1* const anno, 3981 int anno_length, 3982 TRAPS) { 3983 AnnotationArray* annotations = nullptr; 3984 if (anno != nullptr) { 3985 annotations = MetadataFactory::new_array<u1>(_loader_data, 3986 anno_length, 3987 CHECK_(annotations)); 3988 for (int i = 0; i < anno_length; i++) { 3989 annotations->at_put(i, anno[i]); 3990 } 3991 } 3992 return annotations; 3993 } 3994 3995 void ClassFileParser::check_super_class(ConstantPool* const cp, 3996 const int super_class_index, 3997 const bool need_verify, 3998 TRAPS) { 3999 assert(cp != nullptr, "invariant"); 4000 4001 if (super_class_index == 0) { 4002 guarantee_property(_class_name == vmSymbols::java_lang_Object(), 4003 "Invalid superclass index 0 in class file %s", 4004 CHECK); 4005 } else { 4006 guarantee_property(valid_klass_reference_at(super_class_index), 4007 "Invalid superclass index %u in class file %s", 4008 super_class_index, 4009 CHECK); 4010 4011 // The class name should be legal because it is checked when parsing constant pool. 4012 // However, make sure it is not an array type. 4013 if (need_verify) { 4014 guarantee_property(cp->klass_name_at(super_class_index)->char_at(0) != JVM_SIGNATURE_ARRAY, 4015 "Bad superclass name in class file %s", CHECK); 4016 } 4017 } 4018 } 4019 4020 OopMapBlocksBuilder::OopMapBlocksBuilder(unsigned int max_blocks) { 4021 _max_nonstatic_oop_maps = max_blocks; 4022 _nonstatic_oop_map_count = 0; 4023 if (max_blocks == 0) { 4024 _nonstatic_oop_maps = nullptr; 4025 } else { 4026 _nonstatic_oop_maps = 4027 NEW_RESOURCE_ARRAY(OopMapBlock, _max_nonstatic_oop_maps); 4028 memset(_nonstatic_oop_maps, 0, sizeof(OopMapBlock) * max_blocks); 4029 } 4030 } 4031 4032 OopMapBlock* OopMapBlocksBuilder::last_oop_map() const { 4033 assert(_nonstatic_oop_map_count > 0, "Has no oop maps"); 4034 return _nonstatic_oop_maps + (_nonstatic_oop_map_count - 1); 4035 } 4036 4037 // addition of super oop maps 4038 void OopMapBlocksBuilder::initialize_inherited_blocks(OopMapBlock* blocks, unsigned int nof_blocks) { 4039 assert(nof_blocks && _nonstatic_oop_map_count == 0 && 4040 nof_blocks <= _max_nonstatic_oop_maps, "invariant"); 4041 4042 memcpy(_nonstatic_oop_maps, blocks, sizeof(OopMapBlock) * nof_blocks); 4043 _nonstatic_oop_map_count += nof_blocks; 4044 } 4045 4046 // collection of oops 4047 void OopMapBlocksBuilder::add(int offset, int count) { 4048 if (_nonstatic_oop_map_count == 0) { 4049 _nonstatic_oop_map_count++; 4050 } 4051 OopMapBlock* nonstatic_oop_map = last_oop_map(); 4052 if (nonstatic_oop_map->count() == 0) { // Unused map, set it up 4053 nonstatic_oop_map->set_offset(offset); 4054 nonstatic_oop_map->set_count(count); 4055 } else if (nonstatic_oop_map->is_contiguous(offset)) { // contiguous, add 4056 nonstatic_oop_map->increment_count(count); 4057 } else { // Need a new one... 4058 _nonstatic_oop_map_count++; 4059 assert(_nonstatic_oop_map_count <= _max_nonstatic_oop_maps, "range check"); 4060 nonstatic_oop_map = last_oop_map(); 4061 nonstatic_oop_map->set_offset(offset); 4062 nonstatic_oop_map->set_count(count); 4063 } 4064 } 4065 4066 // general purpose copy, e.g. into allocated instanceKlass 4067 void OopMapBlocksBuilder::copy(OopMapBlock* dst) { 4068 if (_nonstatic_oop_map_count != 0) { 4069 memcpy(dst, _nonstatic_oop_maps, sizeof(OopMapBlock) * _nonstatic_oop_map_count); 4070 } 4071 } 4072 4073 // Sort and compact adjacent blocks 4074 void OopMapBlocksBuilder::compact() { 4075 if (_nonstatic_oop_map_count <= 1) { 4076 return; 4077 } 4078 /* 4079 * Since field layout sneaks in oops before values, we will be able to condense 4080 * blocks. There is potential to compact between super, own refs and values 4081 * containing refs. 4082 * 4083 * Currently compaction is slightly limited due to values being 8 byte aligned. 4084 * This may well change: FixMe if it doesn't, the code below is fairly general purpose 4085 * and maybe it doesn't need to be. 4086 */ 4087 qsort(_nonstatic_oop_maps, _nonstatic_oop_map_count, sizeof(OopMapBlock), 4088 (_sort_Fn)OopMapBlock::compare_offset); 4089 if (_nonstatic_oop_map_count < 2) { 4090 return; 4091 } 4092 4093 // Make a temp copy, and iterate through and copy back into the original 4094 ResourceMark rm; 4095 OopMapBlock* oop_maps_copy = 4096 NEW_RESOURCE_ARRAY(OopMapBlock, _nonstatic_oop_map_count); 4097 OopMapBlock* oop_maps_copy_end = oop_maps_copy + _nonstatic_oop_map_count; 4098 copy(oop_maps_copy); 4099 OopMapBlock* nonstatic_oop_map = _nonstatic_oop_maps; 4100 unsigned int new_count = 1; 4101 oop_maps_copy++; 4102 while(oop_maps_copy < oop_maps_copy_end) { 4103 assert(nonstatic_oop_map->offset() < oop_maps_copy->offset(), "invariant"); 4104 if (nonstatic_oop_map->is_contiguous(oop_maps_copy->offset())) { 4105 nonstatic_oop_map->increment_count(oop_maps_copy->count()); 4106 } else { 4107 nonstatic_oop_map++; 4108 new_count++; 4109 nonstatic_oop_map->set_offset(oop_maps_copy->offset()); 4110 nonstatic_oop_map->set_count(oop_maps_copy->count()); 4111 } 4112 oop_maps_copy++; 4113 } 4114 assert(new_count <= _nonstatic_oop_map_count, "end up with more maps after compact() ?"); 4115 _nonstatic_oop_map_count = new_count; 4116 } 4117 4118 void OopMapBlocksBuilder::print_on(outputStream* st) const { 4119 st->print_cr(" OopMapBlocks: %3d /%3d", _nonstatic_oop_map_count, _max_nonstatic_oop_maps); 4120 if (_nonstatic_oop_map_count > 0) { 4121 OopMapBlock* map = _nonstatic_oop_maps; 4122 OopMapBlock* last_map = last_oop_map(); 4123 assert(map <= last_map, "Last less than first"); 4124 while (map <= last_map) { 4125 st->print_cr(" Offset: %3d -%3d Count: %3d", map->offset(), 4126 map->offset() + map->offset_span() - heapOopSize, map->count()); 4127 map++; 4128 } 4129 } 4130 } 4131 4132 void OopMapBlocksBuilder::print_value_on(outputStream* st) const { 4133 print_on(st); 4134 } 4135 4136 void ClassFileParser::set_precomputed_flags(InstanceKlass* ik) { 4137 assert(ik != nullptr, "invariant"); 4138 4139 const InstanceKlass* const super = ik->super(); 4140 4141 // Check if this klass has an empty finalize method (i.e. one with return bytecode only), 4142 // in which case we don't have to register objects as finalizable 4143 if (!_has_empty_finalizer) { 4144 if (_has_finalizer || 4145 (super != nullptr && super->has_finalizer())) { 4146 ik->set_has_finalizer(); 4147 } 4148 } 4149 4150 #ifdef ASSERT 4151 bool f = false; 4152 const Method* const m = ik->lookup_method(vmSymbols::finalize_method_name(), 4153 vmSymbols::void_method_signature()); 4154 if (InstanceKlass::is_finalization_enabled() && 4155 (m != nullptr) && !m->is_empty_method()) { 4156 f = true; 4157 } 4158 4159 // Spec doesn't prevent agent from redefinition of empty finalizer. 4160 // Despite the fact that it's generally bad idea and redefined finalizer 4161 // will not work as expected we shouldn't abort vm in this case 4162 if (!ik->has_redefined_this_or_super()) { 4163 assert(ik->has_finalizer() == f, "inconsistent has_finalizer"); 4164 } 4165 #endif 4166 4167 // Check if this klass supports the java.lang.Cloneable interface 4168 if (vmClasses::Cloneable_klass_is_loaded()) { 4169 if (ik->is_subtype_of(vmClasses::Cloneable_klass())) { 4170 ik->set_is_cloneable(); 4171 } 4172 } 4173 4174 // If it cannot be fast-path allocated, set a bit in the layout helper. 4175 // See documentation of InstanceKlass::can_be_fastpath_allocated(). 4176 assert(ik->size_helper() > 0, "layout_helper is initialized"); 4177 if (ik->is_abstract() || ik->is_interface() 4178 || (ik->name() == vmSymbols::java_lang_Class() && ik->class_loader() == nullptr) 4179 || ik->size_helper() >= FastAllocateSizeLimit) { 4180 // Forbid fast-path allocation. 4181 const jint lh = Klass::instance_layout_helper(ik->size_helper(), true); 4182 ik->set_layout_helper(lh); 4183 } 4184 4185 // Propagate the AOT runtimeSetup method discovery 4186 if (_has_aot_runtime_setup_method) { 4187 ik->set_is_runtime_setup_required(); 4188 if (log_is_enabled(Info, aot, init)) { 4189 ResourceMark rm; 4190 log_info(aot, init)("Found @AOTRuntimeSetup class %s", ik->external_name()); 4191 } 4192 } 4193 } 4194 4195 bool ClassFileParser::supports_inline_types() const { 4196 // Inline types are only supported by class file version 71.65535 and later 4197 return _major_version > JAVA_27_VERSION || 4198 (_major_version == JAVA_27_VERSION && _minor_version == JAVA_PREVIEW_MINOR_VERSION); 4199 } 4200 4201 // utility methods for appending an array with check for duplicates 4202 4203 static void append_interfaces(GrowableArray<InstanceKlass*>* result, 4204 const Array<InstanceKlass*>* const ifs) { 4205 // iterate over new interfaces 4206 for (int i = 0; i < ifs->length(); i++) { 4207 InstanceKlass* const e = ifs->at(i); 4208 assert(e->is_klass() && e->is_interface(), "just checking"); 4209 // add new interface 4210 result->append_if_missing(e); 4211 } 4212 } 4213 4214 static Array<InstanceKlass*>* compute_transitive_interfaces(const InstanceKlass* super, 4215 Array<InstanceKlass*>* local_ifs, 4216 ClassLoaderData* loader_data, 4217 TRAPS) { 4218 assert(local_ifs != nullptr, "invariant"); 4219 assert(loader_data != nullptr, "invariant"); 4220 4221 // Compute maximum size for transitive interfaces 4222 int max_transitive_size = 0; 4223 int super_size = 0; 4224 // Add superclass transitive interfaces size 4225 if (super != nullptr) { 4226 super_size = super->transitive_interfaces()->length(); 4227 max_transitive_size += super_size; 4228 } 4229 // Add local interfaces' super interfaces 4230 const int local_size = local_ifs->length(); 4231 for (int i = 0; i < local_size; i++) { 4232 InstanceKlass* const l = local_ifs->at(i); 4233 max_transitive_size += l->transitive_interfaces()->length(); 4234 } 4235 // Finally add local interfaces 4236 max_transitive_size += local_size; 4237 // Construct array 4238 if (max_transitive_size == 0) { 4239 // no interfaces, use canonicalized array 4240 return Universe::the_empty_instance_klass_array(); 4241 } else if (max_transitive_size == super_size) { 4242 // no new local interfaces added, share superklass' transitive interface array 4243 return super->transitive_interfaces(); 4244 } else if (max_transitive_size == local_size) { 4245 // only local interfaces added, share local interface array 4246 return local_ifs; 4247 } else { 4248 ResourceMark rm; 4249 GrowableArray<InstanceKlass*>* const result = new GrowableArray<InstanceKlass*>(max_transitive_size); 4250 4251 // Copy down from superclass 4252 if (super != nullptr) { 4253 append_interfaces(result, super->transitive_interfaces()); 4254 } 4255 4256 // Copy down from local interfaces' superinterfaces 4257 for (int i = 0; i < local_size; i++) { 4258 InstanceKlass* const l = local_ifs->at(i); 4259 append_interfaces(result, l->transitive_interfaces()); 4260 } 4261 // Finally add local interfaces 4262 append_interfaces(result, local_ifs); 4263 4264 // length will be less than the max_transitive_size if duplicates were removed 4265 const int length = result->length(); 4266 assert(length <= max_transitive_size, "just checking"); 4267 4268 Array<InstanceKlass*>* const new_result = 4269 MetadataFactory::new_array<InstanceKlass*>(loader_data, length, CHECK_NULL); 4270 for (int i = 0; i < length; i++) { 4271 InstanceKlass* const e = result->at(i); 4272 assert(e != nullptr, "just checking"); 4273 new_result->at_put(i, e); 4274 } 4275 return new_result; 4276 } 4277 } 4278 4279 void ClassFileParser::check_super_class_access(const InstanceKlass* this_klass, TRAPS) { 4280 assert(this_klass != nullptr, "invariant"); 4281 const InstanceKlass* const super = this_klass->super(); 4282 4283 if (super != nullptr) { 4284 if (super->is_final()) { 4285 classfile_icce_error("class %s cannot inherit from final class %s", super, THREAD); 4286 return; 4287 } 4288 4289 if (super->is_sealed()) { 4290 stringStream ss; 4291 ResourceMark rm(THREAD); 4292 if (!super->has_as_permitted_subclass(this_klass, ss)) { 4293 classfile_icce_error(ss.as_string(), THREAD); 4294 return; 4295 } 4296 } 4297 4298 // The JVMS says that super classes for value types must not have the ACC_IDENTITY 4299 // flag set. But, java.lang.Object must still be allowed to be a direct super class 4300 // for a value classes. So, it is treated as a special case for now. 4301 if (!this_klass->access_flags().is_identity_class() && 4302 super->name() != vmSymbols::java_lang_Object() && 4303 super->is_identity_class()) { 4304 classfile_icce_error("value class %s cannot inherit from class %s", super, THREAD); 4305 return; 4306 } 4307 4308 Reflection::VerifyClassAccessResults vca_result = 4309 Reflection::verify_class_access(this_klass, super, false); 4310 if (vca_result != Reflection::ACCESS_OK) { 4311 ResourceMark rm(THREAD); 4312 char* msg = Reflection::verify_class_access_msg(this_klass, 4313 super, 4314 vca_result); 4315 4316 // Names are all known to be < 64k so we know this formatted message is not excessively large. 4317 if (msg == nullptr) { 4318 bool same_module = (this_klass->module() == super->module()); 4319 Exceptions::fthrow( 4320 THREAD_AND_LOCATION, 4321 vmSymbols::java_lang_IllegalAccessError(), 4322 "class %s cannot access its %ssuperclass %s (%s%s%s)", 4323 this_klass->external_name(), 4324 super->is_abstract() ? "abstract " : "", 4325 super->external_name(), 4326 (same_module) ? this_klass->joint_in_module_of_loader(super) : this_klass->class_in_module_of_loader(), 4327 (same_module) ? "" : "; ", 4328 (same_module) ? "" : super->class_in_module_of_loader()); 4329 } else { 4330 // Add additional message content. 4331 Exceptions::fthrow( 4332 THREAD_AND_LOCATION, 4333 vmSymbols::java_lang_IllegalAccessError(), 4334 "superclass access check failed: %s", 4335 msg); 4336 } 4337 } 4338 } 4339 } 4340 4341 4342 void ClassFileParser::check_super_interface_access(const InstanceKlass* this_klass, TRAPS) { 4343 assert(this_klass != nullptr, "invariant"); 4344 const Array<InstanceKlass*>* const local_interfaces = this_klass->local_interfaces(); 4345 const int lng = local_interfaces->length(); 4346 for (int i = lng - 1; i >= 0; i--) { 4347 InstanceKlass* const k = local_interfaces->at(i); 4348 assert (k != nullptr && k->is_interface(), "invalid interface"); 4349 4350 if (k->is_sealed()) { 4351 stringStream ss; 4352 ResourceMark rm(THREAD); 4353 if (!k->has_as_permitted_subclass(this_klass, ss)) { 4354 classfile_icce_error(ss.as_string(), THREAD); 4355 return; 4356 } 4357 } 4358 4359 Reflection::VerifyClassAccessResults vca_result = 4360 Reflection::verify_class_access(this_klass, k, false); 4361 if (vca_result != Reflection::ACCESS_OK) { 4362 ResourceMark rm(THREAD); 4363 char* msg = Reflection::verify_class_access_msg(this_klass, 4364 k, 4365 vca_result); 4366 4367 // Names are all known to be < 64k so we know this formatted message is not excessively large. 4368 if (msg == nullptr) { 4369 bool same_module = (this_klass->module() == k->module()); 4370 Exceptions::fthrow( 4371 THREAD_AND_LOCATION, 4372 vmSymbols::java_lang_IllegalAccessError(), 4373 "class %s cannot access its superinterface %s (%s%s%s)", 4374 this_klass->external_name(), 4375 k->external_name(), 4376 (same_module) ? this_klass->joint_in_module_of_loader(k) : this_klass->class_in_module_of_loader(), 4377 (same_module) ? "" : "; ", 4378 (same_module) ? "" : k->class_in_module_of_loader()); 4379 return; 4380 } else { 4381 // Add additional message content. 4382 Exceptions::fthrow( 4383 THREAD_AND_LOCATION, 4384 vmSymbols::java_lang_IllegalAccessError(), 4385 "superinterface check failed: %s", 4386 msg); 4387 return; 4388 } 4389 } 4390 } 4391 } 4392 4393 4394 static void check_final_method_override(const InstanceKlass* this_klass, TRAPS) { 4395 assert(this_klass != nullptr, "invariant"); 4396 const Array<Method*>* const methods = this_klass->methods(); 4397 const int num_methods = methods->length(); 4398 4399 // go thru each method and check if it overrides a final method 4400 for (int index = 0; index < num_methods; index++) { 4401 const Method* const m = methods->at(index); 4402 4403 // skip private, static, and <init> methods 4404 if ((!m->is_private() && !m->is_static()) && 4405 (m->name() != vmSymbols::object_initializer_name())) { 4406 4407 const Symbol* const name = m->name(); 4408 const Symbol* const signature = m->signature(); 4409 const InstanceKlass* k = this_klass->super(); 4410 const Method* super_m = nullptr; 4411 while (k != nullptr) { 4412 // skip supers that don't have final methods. 4413 if (k->has_final_method()) { 4414 // lookup a matching method in the super class hierarchy 4415 super_m = k->lookup_method(name, signature); 4416 if (super_m == nullptr) { 4417 break; // didn't find any match; get out 4418 } 4419 4420 if (super_m->is_final() && !super_m->is_static() && 4421 !super_m->access_flags().is_private()) { 4422 // matching method in super is final, and not static or private 4423 bool can_access = Reflection::verify_member_access(this_klass, 4424 super_m->method_holder(), 4425 super_m->method_holder(), 4426 super_m->access_flags(), 4427 false, false, CHECK); 4428 if (can_access) { 4429 // this class can access super final method and therefore override 4430 ResourceMark rm(THREAD); 4431 THROW_MSG(vmSymbols::java_lang_IncompatibleClassChangeError(), 4432 err_msg("class %s overrides final method %s.%s%s", 4433 this_klass->external_name(), 4434 super_m->method_holder()->external_name(), 4435 name->as_C_string(), 4436 signature->as_C_string())); 4437 } 4438 } 4439 4440 // continue to look from super_m's holder's super. 4441 k = super_m->method_holder()->super(); 4442 continue; 4443 } 4444 4445 k = k->super(); 4446 } 4447 } 4448 } 4449 } 4450 4451 4452 // assumes that this_klass is an interface 4453 static void check_illegal_static_method(const InstanceKlass* this_klass, TRAPS) { 4454 assert(this_klass != nullptr, "invariant"); 4455 assert(this_klass->is_interface(), "not an interface"); 4456 const Array<Method*>* methods = this_klass->methods(); 4457 const int num_methods = methods->length(); 4458 4459 for (int index = 0; index < num_methods; index++) { 4460 const Method* const m = methods->at(index); 4461 // if m is static and not the init method, throw a verify error 4462 if ((m->is_static()) && (m->name() != vmSymbols::class_initializer_name())) { 4463 ResourceMark rm(THREAD); 4464 4465 // Names are all known to be < 64k so we know this formatted message is not excessively large. 4466 Exceptions::fthrow( 4467 THREAD_AND_LOCATION, 4468 vmSymbols::java_lang_VerifyError(), 4469 "Illegal static method %s in interface %s", 4470 m->name()->as_C_string(), 4471 this_klass->external_name() 4472 ); 4473 return; 4474 } 4475 } 4476 } 4477 4478 // utility methods for format checking 4479 4480 // Verify the class modifiers for the current class, or an inner class if inner_name is non-null. 4481 void ClassFileParser::verify_legal_class_modifiers(jint flags, Symbol* inner_name, bool is_anonymous_inner_class, TRAPS) const { 4482 const bool is_module = (flags & JVM_ACC_MODULE) != 0; 4483 assert(_major_version >= JAVA_9_VERSION || !is_module, "JVM_ACC_MODULE should not be set"); 4484 if (is_module) { 4485 ResourceMark rm(THREAD); 4486 // Names are all known to be < 64k so we know this formatted message is not excessively large. 4487 Exceptions::fthrow( 4488 THREAD_AND_LOCATION, 4489 vmSymbols::java_lang_NoClassDefFoundError(), 4490 "%s is not a class because access_flag ACC_MODULE is set", 4491 _class_name->as_C_string()); 4492 return; 4493 } 4494 4495 if (!_need_verify) { return; } 4496 4497 const bool is_interface = (flags & JVM_ACC_INTERFACE) != 0; 4498 const bool is_abstract = (flags & JVM_ACC_ABSTRACT) != 0; 4499 const bool is_final = (flags & JVM_ACC_FINAL) != 0; 4500 const bool is_identity = (flags & JVM_ACC_IDENTITY) != 0; 4501 const bool is_enum = (flags & JVM_ACC_ENUM) != 0; 4502 const bool is_annotation = (flags & JVM_ACC_ANNOTATION) != 0; 4503 const bool major_gte_1_5 = _major_version >= JAVA_1_5_VERSION; 4504 const bool valid_value_class = is_identity || is_interface || (supports_inline_types() && (is_abstract || is_final)); 4505 4506 if ((is_abstract && is_final) || 4507 (is_interface && !is_abstract) || 4508 (is_interface && major_gte_1_5 && (is_identity || is_enum)) || // ACC_SUPER (now ACC_IDENTITY) was illegal for interfaces 4509 (!is_interface && major_gte_1_5 && is_annotation) || 4510 (!valid_value_class)) { 4511 ResourceMark rm(THREAD); 4512 // Names are all known to be < 64k so we know this formatted message is not excessively large. 4513 if (inner_name == nullptr && !is_anonymous_inner_class) { 4514 Exceptions::fthrow( 4515 THREAD_AND_LOCATION, 4516 vmSymbols::java_lang_ClassFormatError(), 4517 "Illegal class modifiers in class %s: 0x%X", 4518 _class_name->as_C_string(), flags 4519 ); 4520 } else { 4521 if (is_anonymous_inner_class) { 4522 Exceptions::fthrow( 4523 THREAD_AND_LOCATION, 4524 vmSymbols::java_lang_ClassFormatError(), 4525 "Illegal class modifiers in anonymous inner class of class %s: 0x%X", 4526 _class_name->as_C_string(), flags 4527 ); 4528 } else { 4529 Exceptions::fthrow( 4530 THREAD_AND_LOCATION, 4531 vmSymbols::java_lang_ClassFormatError(), 4532 "Illegal class modifiers in inner class %s of class %s: 0x%X", 4533 inner_name->as_C_string(), _class_name->as_C_string(), flags 4534 ); 4535 } 4536 } 4537 return; 4538 } 4539 } 4540 4541 static bool has_illegal_visibility(jint flags) { 4542 const bool is_public = (flags & JVM_ACC_PUBLIC) != 0; 4543 const bool is_protected = (flags & JVM_ACC_PROTECTED) != 0; 4544 const bool is_private = (flags & JVM_ACC_PRIVATE) != 0; 4545 4546 return ((is_public && is_protected) || 4547 (is_public && is_private) || 4548 (is_protected && is_private)); 4549 } 4550 4551 // A legal major_version.minor_version must be one of the following: 4552 // 4553 // Major_version >= 45 and major_version < 56, any minor_version. 4554 // Major_version >= 56 and major_version <= JVM_CLASSFILE_MAJOR_VERSION and minor_version = 0. 4555 // Major_version = JVM_CLASSFILE_MAJOR_VERSION and minor_version = 65535 and --enable-preview is present. 4556 // 4557 void ClassFileParser::verify_class_version(u2 major, u2 minor, Symbol* class_name, TRAPS){ 4558 ResourceMark rm(THREAD); 4559 const u2 max_version = JVM_CLASSFILE_MAJOR_VERSION; 4560 if (major < JAVA_MIN_SUPPORTED_VERSION) { 4561 classfile_ucve_error("%s (class file version %u.%u) was compiled with an invalid major version", 4562 class_name, major, minor, THREAD); 4563 return; 4564 } 4565 4566 if (major > max_version) { 4567 // Names are all known to be < 64k so we know this formatted message is not excessively large. 4568 Exceptions::fthrow( 4569 THREAD_AND_LOCATION, 4570 vmSymbols::java_lang_UnsupportedClassVersionError(), 4571 "%s has been compiled by a more recent version of the Java Runtime (class file version %u.%u), " 4572 "this version of the Java Runtime only recognizes class file versions up to %u.0", 4573 class_name->as_C_string(), major, minor, JVM_CLASSFILE_MAJOR_VERSION); 4574 return; 4575 } 4576 4577 if (major < JAVA_12_VERSION || minor == 0) { 4578 return; 4579 } 4580 4581 if (minor == JAVA_PREVIEW_MINOR_VERSION) { 4582 if (major != max_version) { 4583 // Names are all known to be < 64k so we know this formatted message is not excessively large. 4584 Exceptions::fthrow( 4585 THREAD_AND_LOCATION, 4586 vmSymbols::java_lang_UnsupportedClassVersionError(), 4587 "%s (class file version %u.%u) was compiled with preview features that are unsupported. " 4588 "This version of the Java Runtime only recognizes preview features for class file version %u.%u", 4589 class_name->as_C_string(), major, minor, JVM_CLASSFILE_MAJOR_VERSION, JAVA_PREVIEW_MINOR_VERSION); 4590 return; 4591 } 4592 4593 if (!Arguments::enable_preview()) { 4594 classfile_ucve_error("Preview features are not enabled for %s (class file version %u.%u). Try running with '--enable-preview'", 4595 class_name, major, minor, THREAD); 4596 return; 4597 } 4598 4599 } else { // minor != JAVA_PREVIEW_MINOR_VERSION 4600 classfile_ucve_error("%s (class file version %u.%u) was compiled with an invalid non-zero minor version", 4601 class_name, major, minor, THREAD); 4602 } 4603 } 4604 4605 void ClassFileParser:: verify_legal_field_modifiers(jint flags, 4606 AccessFlags class_access_flags, 4607 TRAPS) const { 4608 if (!_need_verify) { return; } 4609 4610 const bool is_public = (flags & JVM_ACC_PUBLIC) != 0; 4611 const bool is_protected = (flags & JVM_ACC_PROTECTED) != 0; 4612 const bool is_private = (flags & JVM_ACC_PRIVATE) != 0; 4613 const bool is_static = (flags & JVM_ACC_STATIC) != 0; 4614 const bool is_final = (flags & JVM_ACC_FINAL) != 0; 4615 const bool is_volatile = (flags & JVM_ACC_VOLATILE) != 0; 4616 const bool is_transient = (flags & JVM_ACC_TRANSIENT) != 0; 4617 const bool is_enum = (flags & JVM_ACC_ENUM) != 0; 4618 const bool is_strict = (flags & JVM_ACC_STRICT_INIT) != 0; 4619 const bool major_gte_1_5 = _major_version >= JAVA_1_5_VERSION; 4620 4621 const bool is_interface = class_access_flags.is_interface(); 4622 const bool is_identity_class = class_access_flags.is_identity_class(); 4623 4624 bool is_illegal = false; 4625 const char* error_msg = ""; 4626 4627 // There is some overlap in the checks that apply, for example interface fields 4628 // must be static, static fields can't be strict, and therefore interfaces can't 4629 // have strict fields. So we don't have to check every possible invalid combination 4630 // individually as long as all are covered. Once we have found an illegal combination 4631 // we can stop checking. 4632 4633 if (!is_illegal) { 4634 if (is_interface) { 4635 if (!is_public || !is_static || !is_final || is_private || 4636 is_protected || is_volatile || is_transient || 4637 (major_gte_1_5 && is_enum)) { 4638 is_illegal = true; 4639 error_msg = "interface fields must be public, static and final, and may be synthetic"; 4640 } 4641 } else { // not interface 4642 if (has_illegal_visibility(flags)) { 4643 is_illegal = true; 4644 error_msg = "invalid visibility flags for class field"; 4645 } else if (is_final && is_volatile) { 4646 is_illegal = true; 4647 error_msg = "fields cannot be final and volatile"; 4648 } else if (supports_inline_types()) { 4649 if (!is_identity_class && !is_static && (!is_strict || !is_final)) { 4650 is_illegal = true; 4651 error_msg = "value class fields must be either non-static final and strict, or static"; 4652 } 4653 } 4654 } 4655 } 4656 4657 if (is_illegal) { 4658 ResourceMark rm(THREAD); 4659 // Names are all known to be < 64k so we know this formatted message is not excessively large. 4660 Exceptions::fthrow( 4661 THREAD_AND_LOCATION, 4662 vmSymbols::java_lang_ClassFormatError(), 4663 "Illegal field modifiers (%s) in class %s: 0x%X", 4664 error_msg, _class_name->as_C_string(), flags); 4665 return; 4666 } 4667 } 4668 4669 void ClassFileParser::verify_legal_method_modifiers(jint flags, 4670 AccessFlags class_access_flags, 4671 const Symbol* name, 4672 TRAPS) const { 4673 if (!_need_verify) { return; } 4674 4675 const bool is_public = (flags & JVM_ACC_PUBLIC) != 0; 4676 const bool is_private = (flags & JVM_ACC_PRIVATE) != 0; 4677 const bool is_static = (flags & JVM_ACC_STATIC) != 0; 4678 const bool is_final = (flags & JVM_ACC_FINAL) != 0; 4679 const bool is_native = (flags & JVM_ACC_NATIVE) != 0; 4680 const bool is_abstract = (flags & JVM_ACC_ABSTRACT) != 0; 4681 const bool is_bridge = (flags & JVM_ACC_BRIDGE) != 0; 4682 const bool is_strict = (flags & JVM_ACC_STRICT) != 0; 4683 const bool is_synchronized = (flags & JVM_ACC_SYNCHRONIZED) != 0; 4684 const bool is_protected = (flags & JVM_ACC_PROTECTED) != 0; 4685 const bool major_gte_1_5 = _major_version >= JAVA_1_5_VERSION; 4686 const bool major_gte_8 = _major_version >= JAVA_8_VERSION; 4687 const bool major_gte_17 = _major_version >= JAVA_17_VERSION; 4688 const bool is_initializer = (name == vmSymbols::object_initializer_name()); 4689 const bool is_interface = class_access_flags.is_interface(); 4690 const bool is_identity_class = class_access_flags.is_identity_class(); 4691 4692 bool is_illegal = false; 4693 const char* class_note = ""; 4694 4695 if (is_interface) { 4696 if (major_gte_8) { 4697 // Class file version is JAVA_8_VERSION or later Methods of 4698 // interfaces may set any of the flags except ACC_PROTECTED, 4699 // ACC_FINAL, ACC_NATIVE, and ACC_SYNCHRONIZED; they must 4700 // have exactly one of the ACC_PUBLIC or ACC_PRIVATE flags set. 4701 if ((is_public == is_private) || /* Only one of private and public should be true - XNOR */ 4702 (is_native || is_protected || is_final || is_synchronized) || 4703 // If a specific method of a class or interface has its 4704 // ACC_ABSTRACT flag set, it must not have any of its 4705 // ACC_FINAL, ACC_NATIVE, ACC_PRIVATE, ACC_STATIC, 4706 // ACC_STRICT, or ACC_SYNCHRONIZED flags set. No need to 4707 // check for ACC_FINAL, ACC_NATIVE or ACC_SYNCHRONIZED as 4708 // those flags are illegal irrespective of ACC_ABSTRACT being set or not. 4709 (is_abstract && (is_private || is_static || (!major_gte_17 && is_strict)))) { 4710 is_illegal = true; 4711 } 4712 } else if (major_gte_1_5) { 4713 // Class file version in the interval [JAVA_1_5_VERSION, JAVA_8_VERSION) 4714 if (!is_public || is_private || is_protected || is_static || is_final || 4715 is_synchronized || is_native || !is_abstract || is_strict) { 4716 is_illegal = true; 4717 } 4718 } else { 4719 // Class file version is pre-JAVA_1_5_VERSION 4720 if (!is_public || is_static || is_final || is_native || !is_abstract) { 4721 is_illegal = true; 4722 } 4723 } 4724 } else { // not interface 4725 if (has_illegal_visibility(flags)) { 4726 is_illegal = true; 4727 } else { 4728 if (is_initializer) { 4729 if (is_static || is_final || is_synchronized || is_native || 4730 is_abstract || (major_gte_1_5 && is_bridge)) { 4731 is_illegal = true; 4732 } 4733 } else { // not initializer 4734 if (!is_identity_class && is_synchronized && !is_static) { 4735 is_illegal = true; 4736 class_note = " (not an identity class)"; 4737 } else { 4738 if (is_abstract) { 4739 if ((is_final || is_native || is_private || is_static || 4740 (major_gte_1_5 && (is_synchronized || (!major_gte_17 && is_strict))))) { 4741 is_illegal = true; 4742 } 4743 } 4744 } 4745 } 4746 } 4747 } 4748 4749 if (is_illegal) { 4750 ResourceMark rm(THREAD); 4751 // Names are all known to be < 64k so we know this formatted message is not excessively large. 4752 Exceptions::fthrow( 4753 THREAD_AND_LOCATION, 4754 vmSymbols::java_lang_ClassFormatError(), 4755 "Method %s in class %s%s has illegal modifiers: 0x%X", 4756 name->as_C_string(), _class_name->as_C_string(), class_note, flags); 4757 return; 4758 } 4759 } 4760 4761 void ClassFileParser::verify_legal_utf8(const unsigned char* buffer, 4762 int length, 4763 TRAPS) const { 4764 assert(_need_verify, "only called when _need_verify is true"); 4765 // Note: 0 <= length < 64K, as it comes from a u2 entry in the CP. 4766 if (!UTF8::is_legal_utf8(buffer, static_cast<size_t>(length), _major_version <= 47)) { 4767 classfile_parse_error("Illegal UTF8 string in constant pool in class file %s", THREAD); 4768 } 4769 } 4770 4771 // Unqualified names may not contain the characters '.', ';', '[', or '/'. 4772 // In class names, '/' separates unqualified names. This is verified in this function also. 4773 // Method names also may not contain the characters '<' or '>', unless <init> 4774 // or <clinit>. Note that method names may not be <init> or <clinit> in this 4775 // method. Because these names have been checked as special cases before 4776 // calling this method in verify_legal_method_name. 4777 // 4778 // This method is also called from the modular system APIs in modules.cpp 4779 // to verify the validity of module and package names. 4780 bool ClassFileParser::verify_unqualified_name(const char* name, 4781 unsigned int length, 4782 int type) { 4783 if (length == 0) return false; // Must have at least one char. 4784 for (const char* p = name; p != name + length; p++) { 4785 switch(*p) { 4786 case JVM_SIGNATURE_DOT: 4787 case JVM_SIGNATURE_ENDCLASS: 4788 case JVM_SIGNATURE_ARRAY: 4789 // do not permit '.', ';', or '[' 4790 return false; 4791 case JVM_SIGNATURE_SLASH: 4792 // check for '//' or leading or trailing '/' which are not legal 4793 // unqualified name must not be empty 4794 if (type == ClassFileParser::LegalClass) { 4795 if (p == name || p+1 >= name+length || 4796 *(p+1) == JVM_SIGNATURE_SLASH) { 4797 return false; 4798 } 4799 } else { 4800 return false; // do not permit '/' unless it's class name 4801 } 4802 break; 4803 case JVM_SIGNATURE_SPECIAL: 4804 case JVM_SIGNATURE_ENDSPECIAL: 4805 // do not permit '<' or '>' in method names 4806 if (type == ClassFileParser::LegalMethod) { 4807 return false; 4808 } 4809 } 4810 } 4811 return true; 4812 } 4813 4814 bool ClassFileParser::is_class_in_loadable_descriptors_attribute(Symbol *klass) { 4815 if (_loadable_descriptors == nullptr) return false; 4816 for (int i = 0; i < _loadable_descriptors->length(); i++) { 4817 Symbol* class_name = _cp->symbol_at(_loadable_descriptors->at(i)); 4818 if (class_name == klass) return true; 4819 } 4820 return false; 4821 } 4822 4823 // Take pointer to a UTF8 byte string (not NUL-terminated). 4824 // Skip over the longest part of the string that could 4825 // be taken as a fieldname. Allow non-trailing '/'s if slash_ok is true. 4826 // Return a pointer to just past the fieldname. 4827 // Return null if no fieldname at all was found, or in the case of slash_ok 4828 // being true, we saw consecutive slashes (meaning we were looking for a 4829 // qualified path but found something that was badly-formed). 4830 static const char* skip_over_field_name(const char* const name, 4831 bool slash_ok, 4832 unsigned int length) { 4833 const char* p; 4834 jboolean last_is_slash = false; 4835 jboolean not_first_ch = false; 4836 4837 for (p = name; p != name + length; not_first_ch = true) { 4838 const char* old_p = p; 4839 jchar ch = *p; 4840 if (ch < 128) { 4841 p++; 4842 // quick check for ascii 4843 if ((ch >= 'a' && ch <= 'z') || 4844 (ch >= 'A' && ch <= 'Z') || 4845 (ch == '_' || ch == '$') || 4846 (not_first_ch && ch >= '0' && ch <= '9')) { 4847 last_is_slash = false; 4848 continue; 4849 } 4850 if (slash_ok && ch == JVM_SIGNATURE_SLASH) { 4851 if (last_is_slash) { 4852 return nullptr; // Don't permit consecutive slashes 4853 } 4854 last_is_slash = true; 4855 continue; 4856 } 4857 } 4858 else { 4859 jint unicode_ch; 4860 char* tmp_p = UTF8::next_character(p, &unicode_ch); 4861 p = tmp_p; 4862 last_is_slash = false; 4863 // Check if ch is Java identifier start or is Java identifier part 4864 // 4672820: call java.lang.Character methods directly without generating separate tables. 4865 EXCEPTION_MARK; 4866 // return value 4867 JavaValue result(T_BOOLEAN); 4868 // Set up the arguments to isJavaIdentifierStart or isJavaIdentifierPart 4869 JavaCallArguments args; 4870 args.push_int(unicode_ch); 4871 4872 if (not_first_ch) { 4873 // public static boolean isJavaIdentifierPart(char ch); 4874 JavaCalls::call_static(&result, 4875 vmClasses::Character_klass(), 4876 vmSymbols::isJavaIdentifierPart_name(), 4877 vmSymbols::int_bool_signature(), 4878 &args, 4879 THREAD); 4880 } else { 4881 // public static boolean isJavaIdentifierStart(char ch); 4882 JavaCalls::call_static(&result, 4883 vmClasses::Character_klass(), 4884 vmSymbols::isJavaIdentifierStart_name(), 4885 vmSymbols::int_bool_signature(), 4886 &args, 4887 THREAD); 4888 } 4889 if (HAS_PENDING_EXCEPTION) { 4890 CLEAR_PENDING_EXCEPTION; 4891 return nullptr; 4892 } 4893 if(result.get_jboolean()) { 4894 continue; 4895 } 4896 } 4897 return (not_first_ch) ? old_p : nullptr; 4898 } 4899 return (not_first_ch && !last_is_slash) ? p : nullptr; 4900 } 4901 4902 // Take pointer to a UTF8 byte string (not NUL-terminated). 4903 // Skip over the longest part of the string that could 4904 // be taken as a field signature. Allow "void" if void_ok. 4905 // Return a pointer to just past the signature. 4906 // Return null if no legal signature is found. 4907 const char* ClassFileParser::skip_over_field_signature(const char* signature, 4908 bool void_ok, 4909 unsigned int length, 4910 TRAPS) const { 4911 unsigned int array_dim = 0; 4912 while (length > 0) { 4913 switch (signature[0]) { 4914 case JVM_SIGNATURE_VOID: if (!void_ok) { return nullptr; } 4915 case JVM_SIGNATURE_BOOLEAN: 4916 case JVM_SIGNATURE_BYTE: 4917 case JVM_SIGNATURE_CHAR: 4918 case JVM_SIGNATURE_SHORT: 4919 case JVM_SIGNATURE_INT: 4920 case JVM_SIGNATURE_FLOAT: 4921 case JVM_SIGNATURE_LONG: 4922 case JVM_SIGNATURE_DOUBLE: 4923 return signature + 1; 4924 case JVM_SIGNATURE_CLASS: 4925 { 4926 if (_major_version < JAVA_1_5_VERSION) { 4927 signature++; 4928 length--; 4929 // Skip over the class name if one is there 4930 const char* const p = skip_over_field_name(signature, true, length); 4931 assert(p == nullptr || p > signature, "must parse one character at least"); 4932 // The next character better be a semicolon 4933 if (p != nullptr && // Parse of field name succeeded. 4934 p - signature < static_cast<int>(length) && // There is at least one character left to parse. 4935 p[0] == JVM_SIGNATURE_ENDCLASS) { 4936 return p + 1; 4937 } 4938 } 4939 else { 4940 // Skip leading 'L' and ignore first appearance of ';' 4941 signature++; 4942 const char* c = (const char*) memchr(signature, JVM_SIGNATURE_ENDCLASS, length - 1); 4943 // Format check signature 4944 if (c != nullptr) { 4945 int newlen = pointer_delta_as_int(c, (char*) signature); 4946 bool legal = verify_unqualified_name(signature, newlen, LegalClass); 4947 if (!legal) { 4948 classfile_parse_error("Class name is empty or contains illegal character " 4949 "in descriptor in class file %s", 4950 THREAD); 4951 return nullptr; 4952 } 4953 return signature + newlen + 1; 4954 } 4955 } 4956 return nullptr; 4957 } 4958 case JVM_SIGNATURE_ARRAY: 4959 array_dim++; 4960 if (array_dim > 255) { 4961 // 4277370: array descriptor is valid only if it represents 255 or fewer dimensions. 4962 classfile_parse_error("Array type descriptor has more than 255 dimensions in class file %s", THREAD); 4963 return nullptr; 4964 } 4965 // The rest of what's there better be a legal signature 4966 signature++; 4967 length--; 4968 void_ok = false; 4969 break; 4970 default: 4971 return nullptr; 4972 } 4973 } 4974 return nullptr; 4975 } 4976 4977 // Checks if name is a legal class name. 4978 void ClassFileParser::verify_legal_class_name(const Symbol* name, TRAPS) const { 4979 if (!_need_verify) { return; } 4980 4981 assert(name->refcount() > 0, "symbol must be kept alive"); 4982 char* bytes = (char*)name->bytes(); 4983 unsigned int length = name->utf8_length(); 4984 bool legal = false; 4985 4986 if (length > 0) { 4987 const char* p; 4988 if (bytes[0] == JVM_SIGNATURE_ARRAY) { 4989 p = skip_over_field_signature(bytes, false, length, CHECK); 4990 legal = (p != nullptr) && ((p - bytes) == (int)length); 4991 } else if (_major_version < JAVA_1_5_VERSION) { 4992 if (bytes[0] != JVM_SIGNATURE_SPECIAL) { 4993 p = skip_over_field_name(bytes, true, length); 4994 legal = (p != nullptr) && ((p - bytes) == (int)length); 4995 } 4996 } else { 4997 // 4900761: relax the constraints based on JSR202 spec 4998 // Class names may be drawn from the entire Unicode character set. 4999 // Identifiers between '/' must be unqualified names. 5000 // The utf8 string has been verified when parsing cpool entries. 5001 legal = verify_unqualified_name(bytes, length, LegalClass); 5002 } 5003 } 5004 if (!legal) { 5005 ResourceMark rm(THREAD); 5006 assert(_class_name != nullptr, "invariant"); 5007 // Names are all known to be < 64k so we know this formatted message is not excessively large. 5008 Exceptions::fthrow( 5009 THREAD_AND_LOCATION, 5010 vmSymbols::java_lang_ClassFormatError(), 5011 "Illegal class name \"%.*s\" in class file %s", length, bytes, 5012 _class_name->as_C_string() 5013 ); 5014 return; 5015 } 5016 } 5017 5018 // Checks if name is a legal field name. 5019 void ClassFileParser::verify_legal_field_name(const Symbol* name, TRAPS) const { 5020 if (!_need_verify) { return; } 5021 5022 char* bytes = (char*)name->bytes(); 5023 unsigned int length = name->utf8_length(); 5024 bool legal = false; 5025 5026 if (length > 0) { 5027 if (_major_version < JAVA_1_5_VERSION) { 5028 if (bytes[0] != JVM_SIGNATURE_SPECIAL) { 5029 const char* p = skip_over_field_name(bytes, false, length); 5030 legal = (p != nullptr) && ((p - bytes) == (int)length); 5031 } 5032 } else { 5033 // 4881221: relax the constraints based on JSR202 spec 5034 legal = verify_unqualified_name(bytes, length, LegalField); 5035 } 5036 } 5037 5038 if (!legal) { 5039 ResourceMark rm(THREAD); 5040 assert(_class_name != nullptr, "invariant"); 5041 // Names are all known to be < 64k so we know this formatted message is not excessively large. 5042 Exceptions::fthrow( 5043 THREAD_AND_LOCATION, 5044 vmSymbols::java_lang_ClassFormatError(), 5045 "Illegal field name \"%.*s\" in class %s", length, bytes, 5046 _class_name->as_C_string() 5047 ); 5048 return; 5049 } 5050 } 5051 5052 // Checks if name is a legal method name. 5053 void ClassFileParser::verify_legal_method_name(const Symbol* name, TRAPS) const { 5054 if (!_need_verify) { return; } 5055 5056 assert(name != nullptr, "method name is null"); 5057 char* bytes = (char*)name->bytes(); 5058 unsigned int length = name->utf8_length(); 5059 bool legal = false; 5060 5061 if (length > 0) { 5062 if (bytes[0] == JVM_SIGNATURE_SPECIAL) { 5063 if (name == vmSymbols::object_initializer_name() || name == vmSymbols::class_initializer_name()) { 5064 legal = true; 5065 } 5066 } else if (_major_version < JAVA_1_5_VERSION) { 5067 const char* p; 5068 p = skip_over_field_name(bytes, false, length); 5069 legal = (p != nullptr) && ((p - bytes) == (int)length); 5070 } else { 5071 // 4881221: relax the constraints based on JSR202 spec 5072 legal = verify_unqualified_name(bytes, length, LegalMethod); 5073 } 5074 } 5075 5076 if (!legal) { 5077 ResourceMark rm(THREAD); 5078 assert(_class_name != nullptr, "invariant"); 5079 // Names are all known to be < 64k so we know this formatted message is not excessively large. 5080 Exceptions::fthrow( 5081 THREAD_AND_LOCATION, 5082 vmSymbols::java_lang_ClassFormatError(), 5083 "Illegal method name \"%.*s\" in class %s", length, bytes, 5084 _class_name->as_C_string() 5085 ); 5086 return; 5087 } 5088 } 5089 5090 bool ClassFileParser::legal_field_signature(const Symbol* signature, TRAPS) const { 5091 const char* const bytes = (const char*)signature->bytes(); 5092 const unsigned int length = signature->utf8_length(); 5093 const char* const p = skip_over_field_signature(bytes, false, length, CHECK_false); 5094 5095 if (p == nullptr || (p - bytes) != (int)length) { 5096 return false; 5097 } 5098 return true; 5099 } 5100 5101 // Checks if signature is a legal field signature. 5102 void ClassFileParser::verify_legal_field_signature(const Symbol* name, 5103 const Symbol* signature, 5104 TRAPS) const { 5105 if (!_need_verify) { return; } 5106 5107 if (!legal_field_signature(signature, THREAD)) { 5108 CLEAR_PENDING_EXCEPTION; // throw this exception instead 5109 throwIllegalSignature("Field", name, signature, CHECK); 5110 } 5111 } 5112 5113 // Check that the signature is compatible with the method name. For example, 5114 // check that <init> has a void signature. 5115 void ClassFileParser::verify_legal_name_with_signature(const Symbol* name, 5116 const Symbol* signature, 5117 TRAPS) const { 5118 if (!_need_verify) { 5119 return; 5120 } 5121 5122 // Class initializers cannot have args for class format version >= 51. 5123 if (name == vmSymbols::class_initializer_name() && 5124 signature != vmSymbols::void_method_signature() && 5125 _major_version >= JAVA_7_VERSION) { 5126 throwIllegalSignature("Method", name, signature, THREAD); 5127 return; 5128 } 5129 5130 int sig_length = signature->utf8_length(); 5131 if (name->utf8_length() > 0 && 5132 name->char_at(0) == JVM_SIGNATURE_SPECIAL && 5133 sig_length > 0 && 5134 signature->char_at(sig_length - 1) != JVM_SIGNATURE_VOID) { 5135 throwIllegalSignature("Method", name, signature, THREAD); 5136 } 5137 } 5138 5139 // Checks if signature is a legal method signature. 5140 // Returns number of parameters 5141 int ClassFileParser::verify_legal_method_signature(const Symbol* name, 5142 const Symbol* signature, 5143 TRAPS) const { 5144 if (!_need_verify) { 5145 // make sure caller's args_size will be less than 0 even for non-static 5146 // method so it will be recomputed in compute_size_of_parameters(). 5147 return -2; 5148 } 5149 5150 unsigned int args_size = 0; 5151 const char* p = (const char*)signature->bytes(); 5152 unsigned int length = signature->utf8_length(); 5153 const char* nextp; 5154 5155 // The first character must be a '(' 5156 if ((length > 0) && (*p++ == JVM_SIGNATURE_FUNC)) { 5157 length--; 5158 // Skip over legal field signatures 5159 nextp = skip_over_field_signature(p, false, length, CHECK_0); 5160 while ((length > 0) && (nextp != nullptr)) { 5161 args_size++; 5162 if (p[0] == 'J' || p[0] == 'D') { 5163 args_size++; 5164 } 5165 length -= pointer_delta_as_int(nextp, p); 5166 p = nextp; 5167 nextp = skip_over_field_signature(p, false, length, CHECK_0); 5168 } 5169 // The first non-signature thing better be a ')' 5170 if ((length > 0) && (*p++ == JVM_SIGNATURE_ENDFUNC)) { 5171 length--; 5172 // Now we better just have a return value 5173 nextp = skip_over_field_signature(p, true, length, CHECK_0); 5174 if (nextp && ((int)length == (nextp - p))) { 5175 return args_size; 5176 } 5177 } 5178 } 5179 // Report error 5180 throwIllegalSignature("Method", name, signature, THREAD); 5181 return 0; 5182 } 5183 5184 int ClassFileParser::static_field_size() const { 5185 assert(_layout_info != nullptr, "invariant"); 5186 return _layout_info->_static_field_size; 5187 } 5188 5189 int ClassFileParser::total_oop_map_count() const { 5190 assert(_layout_info != nullptr, "invariant"); 5191 return _layout_info->oop_map_blocks->_nonstatic_oop_map_count; 5192 } 5193 5194 jint ClassFileParser::layout_size() const { 5195 assert(_layout_info != nullptr, "invariant"); 5196 return _layout_info->_instance_size; 5197 } 5198 5199 static void check_methods_for_intrinsics(const InstanceKlass* ik, 5200 const Array<Method*>* methods) { 5201 assert(ik != nullptr, "invariant"); 5202 assert(methods != nullptr, "invariant"); 5203 5204 // Set up Method*::intrinsic_id as soon as we know the names of methods. 5205 // (We used to do this lazily, but now we query it in Rewriter, 5206 // which is eagerly done for every method, so we might as well do it now, 5207 // when everything is fresh in memory.) 5208 const vmSymbolID klass_id = Method::klass_id_for_intrinsics(ik); 5209 5210 if (klass_id != vmSymbolID::NO_SID) { 5211 for (int j = 0; j < methods->length(); ++j) { 5212 Method* method = methods->at(j); 5213 method->init_intrinsic_id(klass_id); 5214 5215 if (CheckIntrinsics) { 5216 // Check if an intrinsic is defined for method 'method', 5217 // but the method is not annotated with @IntrinsicCandidate. 5218 if (method->intrinsic_id() != vmIntrinsics::_none && 5219 !method->intrinsic_candidate()) { 5220 tty->print("Compiler intrinsic is defined for method [%s], " 5221 "but the method is not annotated with @IntrinsicCandidate.%s", 5222 method->name_and_sig_as_C_string(), 5223 NOT_DEBUG(" Method will not be inlined.") DEBUG_ONLY(" Exiting.") 5224 ); 5225 tty->cr(); 5226 DEBUG_ONLY(vm_exit(1)); 5227 } 5228 // Check is the method 'method' is annotated with @IntrinsicCandidate, 5229 // but there is no intrinsic available for it. 5230 if (method->intrinsic_candidate() && 5231 method->intrinsic_id() == vmIntrinsics::_none) { 5232 tty->print("Method [%s] is annotated with @IntrinsicCandidate, " 5233 "but no compiler intrinsic is defined for the method.%s", 5234 method->name_and_sig_as_C_string(), 5235 NOT_DEBUG("") DEBUG_ONLY(" Exiting.") 5236 ); 5237 tty->cr(); 5238 DEBUG_ONLY(vm_exit(1)); 5239 } 5240 } 5241 } // end for 5242 5243 #ifdef ASSERT 5244 if (CheckIntrinsics) { 5245 // Check for orphan methods in the current class. A method m 5246 // of a class C is orphan if an intrinsic is defined for method m, 5247 // but class C does not declare m. 5248 // The check is potentially expensive, therefore it is available 5249 // only in debug builds. 5250 5251 for (auto id : EnumRange<vmIntrinsicID>{}) { 5252 if (vmIntrinsics::_compiledLambdaForm == id) { 5253 // The _compiledLamdbdaForm intrinsic is a special marker for bytecode 5254 // generated for the JVM from a LambdaForm and therefore no method 5255 // is defined for it. 5256 continue; 5257 } 5258 if (vmIntrinsics::_blackhole == id) { 5259 // The _blackhole intrinsic is a special marker. No explicit method 5260 // is defined for it. 5261 continue; 5262 } 5263 5264 if (vmIntrinsics::class_for(id) == klass_id) { 5265 // Check if the current class contains a method with the same 5266 // name, flags, signature. 5267 bool match = false; 5268 for (int j = 0; j < methods->length(); ++j) { 5269 const Method* method = methods->at(j); 5270 if (method->intrinsic_id() == id) { 5271 match = true; 5272 break; 5273 } 5274 } 5275 5276 if (!match) { 5277 char buf[1000]; 5278 tty->print("Compiler intrinsic is defined for method [%s], " 5279 "but the method is not available in class [%s].%s", 5280 vmIntrinsics::short_name_as_C_string(id, buf, sizeof(buf)), 5281 ik->name()->as_C_string(), 5282 NOT_DEBUG("") DEBUG_ONLY(" Exiting.") 5283 ); 5284 tty->cr(); 5285 DEBUG_ONLY(vm_exit(1)); 5286 } 5287 } 5288 } // end for 5289 } // CheckIntrinsics 5290 #endif // ASSERT 5291 } 5292 } 5293 5294 InstanceKlass* ClassFileParser::create_instance_klass(bool changed_by_loadhook, 5295 const ClassInstanceInfo& cl_inst_info, 5296 TRAPS) { 5297 if (_klass != nullptr) { 5298 return _klass; 5299 } 5300 5301 InstanceKlass* const ik = 5302 InstanceKlass::allocate_instance_klass(*this, CHECK_NULL); 5303 5304 if (is_hidden()) { 5305 mangle_hidden_class_name(ik); 5306 } 5307 5308 fill_instance_klass(ik, changed_by_loadhook, cl_inst_info, CHECK_NULL); 5309 5310 assert(_klass == ik, "invariant"); 5311 return ik; 5312 } 5313 5314 void ClassFileParser::create_acmp_maps(InstanceKlass* ik, TRAPS) { 5315 ik->set_acmp_maps_offset(_layout_info->_acmp_maps_offset); 5316 // Current format of acmp maps: 5317 // All maps are stored contiguously in a single int array because it might 5318 // be too early to instantiate an Object array (to be investigated) 5319 // Format is: 5320 // [number_of_nonoop_entries][offset0][size0][offset1][size1]...[oop_offset0][oop_offset1]... 5321 // ^ ^ 5322 // | | 5323 // --------------------- Pair of integer describing a segment of 5324 // contiguous non-oop fields 5325 // First element is the number of segment of contiguous non-oop fields 5326 // Then, each segment of contiguous non-oop fields is described by two consecutive elements: 5327 // the offset then the size. 5328 // After the last segment of contiguous non-oop fields, oop fields are described, one element 5329 // per oop field, containing the offset of the field. 5330 int nonoop_acmp_map_size = _layout_info->_nonoop_acmp_map->length() * 2; 5331 int oop_acmp_map_size = _layout_info->_oop_acmp_map->length(); 5332 int acmp_map_size = nonoop_acmp_map_size + oop_acmp_map_size + 1; 5333 5334 typeArrayOop map = oopFactory::new_intArray(acmp_map_size, CHECK); 5335 typeArrayHandle map_h(THREAD, map); 5336 Array<int>* acmp_maps_array = MetadataFactory::new_array<int>(loader_data(), acmp_map_size, CHECK); 5337 5338 map_h->int_at_put(0, _layout_info->_nonoop_acmp_map->length()); 5339 acmp_maps_array->at_put(0, _layout_info->_nonoop_acmp_map->length()); 5340 for (int i = 0; i < _layout_info->_nonoop_acmp_map->length(); i++) { 5341 map_h->int_at_put(i * 2 + 1, _layout_info->_nonoop_acmp_map->at(i)._offset); 5342 map_h->int_at_put(i * 2 + 2, _layout_info->_nonoop_acmp_map->at(i)._size); 5343 5344 // Also store acmp maps as metadata for regeneration when using dynamic archive or AOT training data. 5345 acmp_maps_array->at_put(i * 2 + 1, _layout_info->_nonoop_acmp_map->at(i)._offset); 5346 acmp_maps_array->at_put(i * 2 + 2, _layout_info->_nonoop_acmp_map->at(i)._size); 5347 } 5348 int oop_map_start = nonoop_acmp_map_size + 1; 5349 for (int i = 0; i < _layout_info->_oop_acmp_map->length(); i++) { 5350 map_h->int_at_put(oop_map_start + i, _layout_info->_oop_acmp_map->at(i)); 5351 acmp_maps_array->at_put(oop_map_start + i, _layout_info->_oop_acmp_map->at(i)); 5352 } 5353 assert(acmp_maps_array->length() == map_h->length(), "sanity"); 5354 ik->java_mirror()->obj_field_put(ik->acmp_maps_offset(), map_h()); 5355 ik->set_acmp_maps_array(acmp_maps_array); 5356 } 5357 5358 void ClassFileParser::fill_instance_klass(InstanceKlass* ik, 5359 bool changed_by_loadhook, 5360 const ClassInstanceInfo& cl_inst_info, 5361 TRAPS) { 5362 assert(ik != nullptr, "invariant"); 5363 5364 // Set name and CLD before adding to CLD 5365 ik->set_class_loader_data(_loader_data); 5366 ik->set_class_loader_type(); 5367 ik->set_name(_class_name); 5368 5369 // Add all classes to our internal class loader list here, 5370 // including classes in the bootstrap (null) class loader. 5371 const bool publicize = !is_internal(); 5372 5373 _loader_data->add_class(ik, publicize); 5374 5375 set_klass_to_deallocate(ik); 5376 5377 assert(_layout_info != nullptr, "invariant"); 5378 assert(ik->static_field_size() == _layout_info->_static_field_size, "sanity"); 5379 assert(ik->nonstatic_oop_map_count() == _layout_info->oop_map_blocks->_nonstatic_oop_map_count, 5380 "sanity"); 5381 5382 assert(ik->is_instance_klass(), "sanity"); 5383 assert(ik->size_helper() == _layout_info->_instance_size, "sanity"); 5384 5385 // Fill in information already parsed 5386 ik->set_should_verify_class(_need_verify); 5387 5388 // Not yet: supers are done below to support the new subtype-checking fields 5389 ik->set_nonstatic_field_size(_layout_info->_nonstatic_field_size); 5390 ik->set_has_nonstatic_fields(_layout_info->_has_nonstatic_fields); 5391 ik->set_has_strict_static_fields(_has_strict_static_fields); 5392 5393 if (_layout_info->_is_naturally_atomic) { 5394 ik->set_is_naturally_atomic(); 5395 } 5396 5397 if (_layout_info->_must_be_atomic) { 5398 ik->set_must_be_atomic(); 5399 } 5400 5401 ik->set_static_oop_field_count(_static_oop_count); 5402 5403 // this transfers ownership of a lot of arrays from 5404 // the parser onto the InstanceKlass* 5405 apply_parsed_class_metadata(ik, _java_fields_count); 5406 5407 // can only set dynamic nest-host after static nest information is set 5408 if (cl_inst_info.dynamic_nest_host() != nullptr) { 5409 ik->set_nest_host(cl_inst_info.dynamic_nest_host()); 5410 } 5411 5412 // note that is not safe to use the fields in the parser from this point on 5413 assert(nullptr == _cp, "invariant"); 5414 assert(nullptr == _fieldinfo_stream, "invariant"); 5415 assert(nullptr == _fieldinfo_search_table, "invariant"); 5416 assert(nullptr == _fields_status, "invariant"); 5417 assert(nullptr == _methods, "invariant"); 5418 assert(nullptr == _inner_classes, "invariant"); 5419 assert(nullptr == _nest_members, "invariant"); 5420 assert(nullptr == _loadable_descriptors, "invariant"); 5421 assert(nullptr == _combined_annotations, "invariant"); 5422 assert(nullptr == _record_components, "invariant"); 5423 assert(nullptr == _permitted_subclasses, "invariant"); 5424 assert(nullptr == _inline_layout_info_array, "invariant"); 5425 5426 if (_has_localvariable_table) { 5427 ik->set_has_localvariable_table(true); 5428 } 5429 5430 if (_has_final_method) { 5431 ik->set_has_final_method(); 5432 } 5433 5434 ik->copy_method_ordering(_method_ordering, CHECK); 5435 // The InstanceKlass::_methods_jmethod_ids cache 5436 // is managed on the assumption that the initial cache 5437 // size is equal to the number of methods in the class. If 5438 // that changes, then InstanceKlass::idnum_can_increment() 5439 // has to be changed accordingly. 5440 ik->set_initial_method_idnum(checked_cast<u2>(ik->methods()->length())); 5441 5442 ik->set_this_class_index(_this_class_index); 5443 5444 if (_is_hidden) { 5445 // _this_class_index is a CONSTANT_Class entry that refers to this 5446 // hidden class itself. If this class needs to refer to its own methods 5447 // or fields, it would use a CONSTANT_MethodRef, etc, which would reference 5448 // _this_class_index. However, because this class is hidden (it's 5449 // not stored in SystemDictionary), _this_class_index cannot be resolved 5450 // with ConstantPool::klass_at_impl, which does a SystemDictionary lookup. 5451 // Therefore, we must eagerly resolve _this_class_index now. 5452 ik->constants()->klass_at_put(_this_class_index, ik); 5453 } 5454 5455 ik->set_minor_version(_minor_version); 5456 ik->set_major_version(_major_version); 5457 ik->set_has_nonstatic_concrete_methods(_has_nonstatic_concrete_methods); 5458 ik->set_declares_nonstatic_concrete_methods(_declares_nonstatic_concrete_methods); 5459 5460 assert(!_is_hidden || ik->is_hidden(), "must be set already"); 5461 5462 // Set PackageEntry for this_klass 5463 oop cl = ik->class_loader(); 5464 Handle clh = Handle(THREAD, cl); 5465 ClassLoaderData* cld = ClassLoaderData::class_loader_data_or_null(clh()); 5466 ik->set_package(cld, nullptr, CHECK); 5467 5468 const Array<Method*>* const methods = ik->methods(); 5469 assert(methods != nullptr, "invariant"); 5470 const int methods_len = methods->length(); 5471 5472 check_methods_for_intrinsics(ik, methods); 5473 5474 // Fill in field values obtained by parse_classfile_attributes 5475 if (_parsed_annotations->has_any_annotations()) 5476 _parsed_annotations->apply_to(ik); 5477 5478 apply_parsed_class_attributes(ik); 5479 5480 // Miranda methods 5481 if ((_num_miranda_methods > 0) || 5482 // if this class introduced new miranda methods or 5483 (_super_klass != nullptr && _super_klass->has_miranda_methods()) 5484 // super class exists and this class inherited miranda methods 5485 ) { 5486 ik->set_has_miranda_methods(); // then set a flag 5487 } 5488 5489 // Fill in information needed to compute superclasses. 5490 ik->initialize_supers(const_cast<InstanceKlass*>(_super_klass), _transitive_interfaces, CHECK); 5491 ik->set_transitive_interfaces(_transitive_interfaces); 5492 ik->set_local_interfaces(_local_interfaces); 5493 _transitive_interfaces = nullptr; 5494 _local_interfaces = nullptr; 5495 5496 // Initialize itable offset tables 5497 klassItable::setup_itable_offset_table(ik); 5498 5499 // Compute transitive closure of interfaces this class implements 5500 // Do final class setup 5501 OopMapBlocksBuilder* oop_map_blocks = _layout_info->oop_map_blocks; 5502 if (oop_map_blocks->_nonstatic_oop_map_count > 0) { 5503 oop_map_blocks->copy(ik->start_of_nonstatic_oop_maps()); 5504 } 5505 5506 if (_has_contended_fields || _parsed_annotations->is_contended() || 5507 ( _super_klass != nullptr && _super_klass->has_contended_annotations())) { 5508 ik->set_has_contended_annotations(true); 5509 } 5510 5511 // Fill in has_finalizer and layout_helper 5512 set_precomputed_flags(ik); 5513 5514 // check if this class can access its super class 5515 check_super_class_access(ik, CHECK); 5516 5517 // check if this class can access its superinterfaces 5518 check_super_interface_access(ik, CHECK); 5519 5520 // check if this class overrides any final method 5521 check_final_method_override(ik, CHECK); 5522 5523 // reject static interface methods prior to Java 8 5524 if (ik->is_interface() && _major_version < JAVA_8_VERSION) { 5525 check_illegal_static_method(ik, CHECK); 5526 } 5527 5528 // Obtain this_klass' module entry 5529 ModuleEntry* module_entry = ik->module(); 5530 assert(module_entry != nullptr, "module_entry should always be set"); 5531 5532 // Obtain java.lang.Module 5533 Handle module_handle(THREAD, module_entry->module_oop()); 5534 5535 // Allocate mirror and initialize static fields 5536 java_lang_Class::create_mirror(ik, 5537 Handle(THREAD, _loader_data->class_loader()), 5538 module_handle, 5539 _protection_domain, 5540 cl_inst_info.class_data(), 5541 CHECK); 5542 5543 assert(_all_mirandas != nullptr, "invariant"); 5544 5545 // Generate any default methods - default methods are public interface methods 5546 // that have a default implementation. This is new with Java 8. 5547 if (_has_nonstatic_concrete_methods) { 5548 DefaultMethods::generate_default_methods(ik, 5549 _all_mirandas, 5550 CHECK); 5551 } 5552 5553 // Add read edges to the unnamed modules of the bootstrap and app class loaders. 5554 if (changed_by_loadhook && !module_handle.is_null() && module_entry->is_named() && 5555 !module_entry->has_default_read_edges()) { 5556 if (!module_entry->set_has_default_read_edges()) { 5557 // We won a potential race 5558 JvmtiExport::add_default_read_edges(module_handle, THREAD); 5559 } 5560 } 5561 5562 if (is_inline_type()) { 5563 InlineKlass* vk = InlineKlass::cast(ik); 5564 vk->set_payload_alignment(_layout_info->_payload_alignment); 5565 vk->set_payload_offset(_layout_info->_payload_offset); 5566 vk->set_payload_size_in_bytes(_layout_info->_payload_size_in_bytes); 5567 vk->set_null_free_non_atomic_size_in_bytes(_layout_info->_null_free_non_atomic_size_in_bytes); 5568 vk->set_null_free_non_atomic_alignment(_layout_info->_null_free_non_atomic_alignment); 5569 vk->set_null_free_atomic_size_in_bytes(_layout_info->_null_free_atomic_layout_size_in_bytes); 5570 vk->set_nullable_atomic_size_in_bytes(_layout_info->_nullable_atomic_layout_size_in_bytes); 5571 vk->set_nullable_non_atomic_size_in_bytes(_layout_info->_nullable_non_atomic_layout_size_in_bytes); 5572 vk->set_null_marker_offset(_layout_info->_null_marker_offset); 5573 vk->set_null_reset_value_offset(_layout_info->_null_reset_value_offset); 5574 if (_layout_info->_is_empty_inline_klass) vk->set_is_empty_inline_type(); 5575 vk->initialize_calling_convention(CHECK); 5576 } 5577 5578 if (Arguments::is_valhalla_enabled() && !access_flags().is_identity_class() && !access_flags().is_interface() 5579 && _class_name != vmSymbols::java_lang_Object()) { 5580 // Both abstract and concrete value classes need a field map for acmp 5581 create_acmp_maps(ik, CHECK); 5582 } 5583 5584 ClassLoadingService::notify_class_loaded(ik, false /* not shared class */); 5585 5586 if (!is_internal()) { 5587 ik->print_class_load_logging(_loader_data, module_entry, _stream); 5588 if (CDSConfig::is_dumping_archive()) { 5589 SystemDictionaryShared::check_code_source(ik, _stream); 5590 } 5591 5592 if (ik->minor_version() == JAVA_PREVIEW_MINOR_VERSION && 5593 ik->major_version() == JVM_CLASSFILE_MAJOR_VERSION && 5594 log_is_enabled(Info, class, preview)) { 5595 ResourceMark rm; 5596 log_info(class, preview)("Loading class %s that depends on preview features (class file version %d.65535)", 5597 ik->external_name(), JVM_CLASSFILE_MAJOR_VERSION); 5598 } 5599 5600 if (log_is_enabled(Debug, class, resolve)) { 5601 ResourceMark rm; 5602 // print out the superclass. 5603 const char * from = ik->external_name(); 5604 if (ik->super() != nullptr) { 5605 log_debug(class, resolve)("%s %s (super)", 5606 from, 5607 ik->super()->external_name()); 5608 } 5609 // print out each of the interface classes referred to by this class. 5610 const Array<InstanceKlass*>* const local_interfaces = ik->local_interfaces(); 5611 if (local_interfaces != nullptr) { 5612 const int length = local_interfaces->length(); 5613 for (int i = 0; i < length; i++) { 5614 const InstanceKlass* const k = local_interfaces->at(i); 5615 const char * to = k->external_name(); 5616 log_debug(class, resolve)("%s %s (interface)", from, to); 5617 } 5618 } 5619 } 5620 } 5621 5622 // If we reach here, all is well. 5623 // Now remove the InstanceKlass* from the _klass_to_deallocate field 5624 // in order for it to not be destroyed in the ClassFileParser destructor. 5625 set_klass_to_deallocate(nullptr); 5626 5627 // it's official 5628 set_klass(ik); 5629 5630 DEBUG_ONLY(ik->verify();) 5631 } 5632 5633 void ClassFileParser::update_class_name(Symbol* new_class_name) { 5634 // Decrement the refcount in the old name, since we're clobbering it. 5635 _class_name->decrement_refcount(); 5636 5637 _class_name = new_class_name; 5638 // Increment the refcount of the new name. 5639 // Now the ClassFileParser owns this name and will decrement in 5640 // the destructor. 5641 _class_name->increment_refcount(); 5642 } 5643 5644 ClassFileParser::ClassFileParser(ClassFileStream* stream, 5645 Symbol* name, 5646 ClassLoaderData* loader_data, 5647 const ClassLoadInfo* cl_info, 5648 Publicity pub_level, 5649 TRAPS) : 5650 _stream(stream), 5651 _class_name(nullptr), 5652 _loader_data(loader_data), 5653 _is_hidden(cl_info->is_hidden()), 5654 _can_access_vm_annotations(cl_info->can_access_vm_annotations()), 5655 _orig_cp_size(0), 5656 _static_oop_count(0), 5657 _super_klass(), 5658 _cp(nullptr), 5659 _fieldinfo_stream(nullptr), 5660 _fieldinfo_search_table(nullptr), 5661 _fields_status(nullptr), 5662 _methods(nullptr), 5663 _inner_classes(nullptr), 5664 _nest_members(nullptr), 5665 _nest_host(0), 5666 _permitted_subclasses(nullptr), 5667 _loadable_descriptors(nullptr), 5668 _record_components(nullptr), 5669 _local_interfaces(nullptr), 5670 _transitive_interfaces(nullptr), 5671 _combined_annotations(nullptr), 5672 _class_annotations(nullptr), 5673 _class_type_annotations(nullptr), 5674 _fields_annotations(nullptr), 5675 _fields_type_annotations(nullptr), 5676 _klass(nullptr), 5677 _klass_to_deallocate(nullptr), 5678 _parsed_annotations(nullptr), 5679 _layout_info(nullptr), 5680 _inline_layout_info_array(nullptr), 5681 _temp_field_info(nullptr), 5682 _method_ordering(nullptr), 5683 _all_mirandas(nullptr), 5684 _vtable_size(0), 5685 _itable_size(0), 5686 _num_miranda_methods(0), 5687 _protection_domain(cl_info->protection_domain()), 5688 _access_flags(), 5689 _pub_level(pub_level), 5690 _bad_constant_seen(0), 5691 _synthetic_flag(false), 5692 _sde_length(false), 5693 _sde_buffer(nullptr), 5694 _sourcefile_index(0), 5695 _generic_signature_index(0), 5696 _major_version(0), 5697 _minor_version(0), 5698 _this_class_index(0), 5699 _super_class_index(0), 5700 _itfs_len(0), 5701 _java_fields_count(0), 5702 _need_verify(false), 5703 _has_nonstatic_concrete_methods(false), 5704 _declares_nonstatic_concrete_methods(false), 5705 _has_localvariable_table(false), 5706 _has_final_method(false), 5707 _has_contended_fields(false), 5708 _has_aot_runtime_setup_method(false), 5709 _has_strict_static_fields(false), 5710 _is_naturally_atomic(false), 5711 _must_be_atomic(true), 5712 _has_loosely_consistent_annotation(false), 5713 _has_finalizer(false), 5714 _has_empty_finalizer(false), 5715 _max_bootstrap_specifier_index(-1) { 5716 5717 _class_name = name != nullptr ? name : vmSymbols::unknown_class_name(); 5718 _class_name->increment_refcount(); 5719 5720 assert(_loader_data != nullptr, "invariant"); 5721 assert(stream != nullptr, "invariant"); 5722 assert(_stream != nullptr, "invariant"); 5723 assert(_stream->buffer() == _stream->current(), "invariant"); 5724 assert(_class_name != nullptr, "invariant"); 5725 assert(0 == _access_flags.as_unsigned_short(), "invariant"); 5726 5727 // Figure out whether we can skip format checking (matching classic VM behavior) 5728 // Always verify CFLH bytes from the user agents. 5729 _need_verify = stream->from_class_file_load_hook() ? true : Verifier::should_verify_for(_loader_data->class_loader()); 5730 5731 // synch back verification state to stream to check for truncation. 5732 stream->set_need_verify(_need_verify); 5733 5734 parse_stream(stream, CHECK); 5735 5736 post_process_parsed_stream(stream, _cp, CHECK); 5737 } 5738 5739 void ClassFileParser::clear_class_metadata() { 5740 // metadata created before the instance klass is created. Must be 5741 // deallocated if classfile parsing returns an error. 5742 _cp = nullptr; 5743 _fieldinfo_stream = nullptr; 5744 _fieldinfo_search_table = nullptr; 5745 _fields_status = nullptr; 5746 _methods = nullptr; 5747 _inner_classes = nullptr; 5748 _nest_members = nullptr; 5749 _permitted_subclasses = nullptr; 5750 _loadable_descriptors = nullptr; 5751 _combined_annotations = nullptr; 5752 _class_annotations = _class_type_annotations = nullptr; 5753 _fields_annotations = _fields_type_annotations = nullptr; 5754 _record_components = nullptr; 5755 _inline_layout_info_array = nullptr; 5756 } 5757 5758 // Destructor to clean up 5759 ClassFileParser::~ClassFileParser() { 5760 _class_name->decrement_refcount(); 5761 5762 if (_cp != nullptr) { 5763 MetadataFactory::free_metadata(_loader_data, _cp); 5764 } 5765 5766 if (_fieldinfo_stream != nullptr) { 5767 MetadataFactory::free_array<u1>(_loader_data, _fieldinfo_stream); 5768 } 5769 MetadataFactory::free_array<u1>(_loader_data, _fieldinfo_search_table); 5770 5771 if (_fields_status != nullptr) { 5772 MetadataFactory::free_array<FieldStatus>(_loader_data, _fields_status); 5773 } 5774 5775 if (_inline_layout_info_array != nullptr) { 5776 MetadataFactory::free_array<InlineLayoutInfo>(_loader_data, _inline_layout_info_array); 5777 } 5778 5779 if (_methods != nullptr) { 5780 // Free methods 5781 InstanceKlass::deallocate_methods(_loader_data, _methods); 5782 } 5783 5784 // beware of the Universe::empty_blah_array!! 5785 if (_inner_classes != nullptr && _inner_classes != Universe::the_empty_short_array()) { 5786 MetadataFactory::free_array<u2>(_loader_data, _inner_classes); 5787 } 5788 5789 if (_nest_members != nullptr && _nest_members != Universe::the_empty_short_array()) { 5790 MetadataFactory::free_array<u2>(_loader_data, _nest_members); 5791 } 5792 5793 if (_record_components != nullptr) { 5794 InstanceKlass::deallocate_record_components(_loader_data, _record_components); 5795 } 5796 5797 if (_permitted_subclasses != nullptr && _permitted_subclasses != Universe::the_empty_short_array()) { 5798 MetadataFactory::free_array<u2>(_loader_data, _permitted_subclasses); 5799 } 5800 5801 if (_loadable_descriptors != nullptr && _loadable_descriptors != Universe::the_empty_short_array()) { 5802 MetadataFactory::free_array<u2>(_loader_data, _loadable_descriptors); 5803 } 5804 5805 // Free interfaces 5806 InstanceKlass::deallocate_interfaces(_loader_data, _super_klass, 5807 _local_interfaces, _transitive_interfaces); 5808 5809 if (_combined_annotations != nullptr) { 5810 // After all annotations arrays have been created, they are installed into the 5811 // Annotations object that will be assigned to the InstanceKlass being created. 5812 5813 // Deallocate the Annotations object and the installed annotations arrays. 5814 _combined_annotations->deallocate_contents(_loader_data); 5815 5816 // If the _combined_annotations pointer is non-null, 5817 // then the other annotations fields should have been cleared. 5818 assert(_class_annotations == nullptr, "Should have been cleared"); 5819 assert(_class_type_annotations == nullptr, "Should have been cleared"); 5820 assert(_fields_annotations == nullptr, "Should have been cleared"); 5821 assert(_fields_type_annotations == nullptr, "Should have been cleared"); 5822 } else { 5823 // If the annotations arrays were not installed into the Annotations object, 5824 // then they have to be deallocated explicitly. 5825 MetadataFactory::free_array<u1>(_loader_data, _class_annotations); 5826 MetadataFactory::free_array<u1>(_loader_data, _class_type_annotations); 5827 Annotations::free_contents(_loader_data, _fields_annotations); 5828 Annotations::free_contents(_loader_data, _fields_type_annotations); 5829 } 5830 5831 clear_class_metadata(); 5832 _transitive_interfaces = nullptr; 5833 _local_interfaces = nullptr; 5834 5835 // deallocate the klass if already created. Don't directly deallocate, but add 5836 // to the deallocate list so that the klass is removed from the CLD::_klasses list 5837 // at a safepoint. 5838 if (_klass_to_deallocate != nullptr) { 5839 _loader_data->add_to_deallocate_list(_klass_to_deallocate); 5840 } 5841 } 5842 5843 void ClassFileParser::parse_stream(const ClassFileStream* const stream, 5844 TRAPS) { 5845 5846 assert(stream != nullptr, "invariant"); 5847 assert(_class_name != nullptr, "invariant"); 5848 5849 // BEGIN STREAM PARSING 5850 stream->guarantee_more(8, CHECK); // magic, major, minor 5851 // Magic value 5852 const u4 magic = stream->get_u4_fast(); 5853 guarantee_property(magic == JAVA_CLASSFILE_MAGIC, 5854 "Incompatible magic value %u in class file %s", 5855 magic, CHECK); 5856 5857 // Version numbers 5858 _minor_version = stream->get_u2_fast(); 5859 _major_version = stream->get_u2_fast(); 5860 5861 // Check version numbers - we check this even with verifier off 5862 verify_class_version(_major_version, _minor_version, _class_name, CHECK); 5863 5864 stream->guarantee_more(3, CHECK); // length, first cp tag 5865 u2 cp_size = stream->get_u2_fast(); 5866 5867 guarantee_property( 5868 cp_size >= 1, "Illegal constant pool size %u in class file %s", 5869 cp_size, CHECK); 5870 5871 _orig_cp_size = cp_size; 5872 if (is_hidden()) { // Add a slot for hidden class name. 5873 guarantee_property((u4)cp_size < 0xffff, "Overflow in constant pool size for hidden class %s", CHECK); 5874 cp_size++; 5875 } 5876 5877 _cp = ConstantPool::allocate(_loader_data, 5878 cp_size, 5879 CHECK); 5880 5881 ConstantPool* const cp = _cp; 5882 5883 parse_constant_pool(stream, cp, _orig_cp_size, CHECK); 5884 5885 assert(cp_size == (u2)cp->length(), "invariant"); 5886 5887 // ACCESS FLAGS 5888 stream->guarantee_more(8, CHECK); // flags, this_class, super_class, infs_len 5889 5890 // Access flags 5891 u2 flags; 5892 // JVM_ACC_MODULE is defined in JDK-9 and later. 5893 if (_major_version >= JAVA_9_VERSION) { 5894 flags = stream->get_u2_fast() & (JVM_RECOGNIZED_CLASS_MODIFIERS | JVM_ACC_MODULE); 5895 } else { 5896 flags = stream->get_u2_fast() & JVM_RECOGNIZED_CLASS_MODIFIERS; 5897 } 5898 5899 if ((flags & JVM_ACC_INTERFACE) && _major_version < JAVA_6_VERSION) { 5900 // Set abstract bit for old class files for backward compatibility 5901 flags |= JVM_ACC_ABSTRACT; 5902 } 5903 5904 // Fixing ACC_SUPER/ACC_IDENTITY for old class files 5905 if (!supports_inline_types()) { 5906 const bool is_module = (flags & JVM_ACC_MODULE) != 0; 5907 const bool is_interface = (flags & JVM_ACC_INTERFACE) != 0; 5908 if (!is_module && !is_interface) { 5909 flags |= JVM_ACC_IDENTITY; 5910 } 5911 } 5912 5913 verify_legal_class_modifiers(flags, nullptr, false, CHECK); 5914 5915 short bad_constant = class_bad_constant_seen(); 5916 if (bad_constant != 0) { 5917 // Do not throw CFE until after the access_flags are checked because if 5918 // ACC_MODULE is set in the access flags, then NCDFE must be thrown, not CFE. 5919 classfile_parse_error("Unknown constant tag %u in class file %s", bad_constant, THREAD); 5920 return; 5921 } 5922 5923 _access_flags.set_flags(flags); 5924 5925 // This class and superclass 5926 _this_class_index = stream->get_u2_fast(); 5927 guarantee_property( 5928 valid_cp_range(_this_class_index, cp_size) && 5929 cp->tag_at(_this_class_index).is_unresolved_klass(), 5930 "Invalid this class index %u in constant pool in class file %s", 5931 _this_class_index, CHECK); 5932 5933 Symbol* const class_name_in_cp = cp->klass_name_at(_this_class_index); 5934 assert(class_name_in_cp != nullptr, "class_name can't be null"); 5935 5936 // Don't need to check whether this class name is legal or not. 5937 // It has been checked when constant pool is parsed. 5938 // However, make sure it is not an array type. 5939 if (_need_verify) { 5940 guarantee_property(class_name_in_cp->char_at(0) != JVM_SIGNATURE_ARRAY, 5941 "Bad class name in class file %s", 5942 CHECK); 5943 } 5944 5945 #ifdef ASSERT 5946 // Basic sanity checks 5947 if (_is_hidden) { 5948 assert(_class_name != vmSymbols::unknown_class_name(), "hidden classes should have a special name"); 5949 } 5950 #endif 5951 5952 // Update the _class_name as needed depending on whether this is a named, un-named, or hidden class. 5953 5954 if (_is_hidden) { 5955 assert(_class_name != nullptr, "Unexpected null _class_name"); 5956 #ifdef ASSERT 5957 if (_need_verify) { 5958 verify_legal_class_name(_class_name, CHECK); 5959 } 5960 #endif 5961 5962 } else { 5963 // Check if name in class file matches given name 5964 if (_class_name != class_name_in_cp) { 5965 if (_class_name != vmSymbols::unknown_class_name()) { 5966 ResourceMark rm(THREAD); 5967 // Names are all known to be < 64k so we know this formatted message is not excessively large. 5968 Exceptions::fthrow(THREAD_AND_LOCATION, 5969 vmSymbols::java_lang_NoClassDefFoundError(), 5970 "%s (wrong name: %s)", 5971 _class_name->as_C_string(), 5972 class_name_in_cp->as_C_string() 5973 ); 5974 return; 5975 } else { 5976 // The class name was not known by the caller so we set it from 5977 // the value in the CP. 5978 update_class_name(class_name_in_cp); 5979 } 5980 // else nothing to do: the expected class name matches what is in the CP 5981 } 5982 } 5983 5984 // Verification prevents us from creating names with dots in them, this 5985 // asserts that that's the case. 5986 assert(is_internal_format(_class_name), "external class name format used internally"); 5987 5988 if (!is_internal()) { 5989 LogTarget(Debug, class, preorder) lt; 5990 if (lt.is_enabled()){ 5991 ResourceMark rm(THREAD); 5992 LogStream ls(lt); 5993 ls.print("%s", _class_name->as_klass_external_name()); 5994 if (stream->source() != nullptr) { 5995 ls.print(" source: %s", stream->source()); 5996 } 5997 ls.cr(); 5998 } 5999 } 6000 6001 // SUPERKLASS 6002 _super_class_index = stream->get_u2_fast(); 6003 check_super_class(cp, 6004 _super_class_index, 6005 _need_verify, 6006 CHECK); 6007 6008 // Interfaces 6009 _itfs_len = stream->get_u2_fast(); 6010 parse_interfaces(stream, 6011 _itfs_len, 6012 cp, 6013 &_has_nonstatic_concrete_methods, 6014 CHECK); 6015 6016 assert(_local_interfaces != nullptr, "invariant"); 6017 6018 // Fields (offsets are filled in later) 6019 parse_fields(stream, 6020 _access_flags, 6021 cp, 6022 cp_size, 6023 &_java_fields_count, 6024 CHECK); 6025 6026 assert(_temp_field_info != nullptr, "invariant"); 6027 6028 // Methods 6029 parse_methods(stream, 6030 _access_flags.is_interface(), 6031 &_has_localvariable_table, 6032 &_has_final_method, 6033 &_declares_nonstatic_concrete_methods, 6034 CHECK); 6035 6036 assert(_methods != nullptr, "invariant"); 6037 6038 if (_declares_nonstatic_concrete_methods) { 6039 _has_nonstatic_concrete_methods = true; 6040 } 6041 6042 // Additional attributes/annotations 6043 _parsed_annotations = new ClassAnnotationCollector(); 6044 parse_classfile_attributes(stream, cp, _parsed_annotations, CHECK); 6045 6046 assert(_inner_classes != nullptr, "invariant"); 6047 6048 // Finalize the Annotations metadata object, 6049 // now that all annotation arrays have been created. 6050 create_combined_annotations(CHECK); 6051 6052 // Make sure this is the end of class file stream 6053 guarantee_property(stream->at_eos(), 6054 "Extra bytes at the end of class file %s", 6055 CHECK); 6056 6057 // all bytes in stream read and parsed 6058 } 6059 6060 void ClassFileParser::mangle_hidden_class_name(InstanceKlass* const ik) { 6061 ResourceMark rm; 6062 // Construct hidden name from _class_name, "+", and &ik. Note that we can't 6063 // use a '/' because that confuses finding the class's package. Also, can't 6064 // use an illegal char such as ';' because that causes serialization issues 6065 // and issues with hidden classes that create their own hidden classes. 6066 char addr_buf[20]; 6067 if (CDSConfig::is_dumping_static_archive()) { 6068 // We want stable names for the archived hidden classes (only for static 6069 // archive for now). Spaces under default_SharedBaseAddress() will be 6070 // occupied by the archive at run time, so we know that no dynamically 6071 // loaded InstanceKlass will be placed under there. 6072 static volatile size_t counter = 0; 6073 AtomicAccess::cmpxchg(&counter, (size_t)0, Arguments::default_SharedBaseAddress()); // initialize it 6074 size_t new_id = AtomicAccess::add(&counter, (size_t)1); 6075 jio_snprintf(addr_buf, 20, "0x%zx", new_id); 6076 } else { 6077 jio_snprintf(addr_buf, 20, INTPTR_FORMAT, p2i(ik)); 6078 } 6079 size_t new_name_len = _class_name->utf8_length() + 2 + strlen(addr_buf); 6080 char* new_name = NEW_RESOURCE_ARRAY(char, new_name_len); 6081 jio_snprintf(new_name, new_name_len, "%s+%s", 6082 _class_name->as_C_string(), addr_buf); 6083 update_class_name(SymbolTable::new_symbol(new_name)); 6084 6085 // Add a Utf8 entry containing the hidden name. 6086 assert(_class_name != nullptr, "Unexpected null _class_name"); 6087 int hidden_index = _orig_cp_size; // this is an extra slot we added 6088 _cp->symbol_at_put(hidden_index, _class_name); 6089 6090 // Update this_class_index's slot in the constant pool with the new Utf8 entry. 6091 // We have to update the resolved_klass_index and the name_index together 6092 // so extract the existing resolved_klass_index first. 6093 CPKlassSlot cp_klass_slot = _cp->klass_slot_at(_this_class_index); 6094 int resolved_klass_index = cp_klass_slot.resolved_klass_index(); 6095 _cp->unresolved_klass_at_put(_this_class_index, hidden_index, resolved_klass_index); 6096 assert(_cp->klass_slot_at(_this_class_index).name_index() == _orig_cp_size, 6097 "Bad name_index"); 6098 } 6099 6100 void ClassFileParser::post_process_parsed_stream(const ClassFileStream* const stream, 6101 ConstantPool* cp, 6102 TRAPS) { 6103 assert(stream != nullptr, "invariant"); 6104 assert(stream->at_eos(), "invariant"); 6105 assert(cp != nullptr, "invariant"); 6106 assert(_loader_data != nullptr, "invariant"); 6107 6108 if (_class_name == vmSymbols::java_lang_Object()) { 6109 precond(_super_class_index == 0); 6110 precond(_super_klass == nullptr); 6111 guarantee_property(_local_interfaces == Universe::the_empty_instance_klass_array(), 6112 "java.lang.Object cannot implement an interface in class file %s", 6113 CHECK); 6114 } else { 6115 // Set _super_klass after class file is parsed and format is checked 6116 assert(_super_class_index > 0, "any class other than Object must have a super class"); 6117 Symbol* const super_class_name = cp->klass_name_at(_super_class_index); 6118 if (_access_flags.is_interface()) { 6119 // Before attempting to resolve the superclass, check for class format 6120 // errors not checked yet. 6121 guarantee_property(super_class_name == vmSymbols::java_lang_Object(), 6122 "Interfaces must have java.lang.Object as superclass in class file %s", 6123 CHECK); 6124 } 6125 Handle loader(THREAD, _loader_data->class_loader()); 6126 if (loader.is_null() && super_class_name == vmSymbols::java_lang_Object()) { 6127 // fast path to avoid lookup 6128 _super_klass = vmClasses::Object_klass(); 6129 } else { 6130 _super_klass = (const InstanceKlass*) 6131 SystemDictionary::resolve_super_or_fail(_class_name, 6132 super_class_name, 6133 loader, 6134 true, 6135 CHECK); 6136 } 6137 } 6138 6139 if (_super_klass != nullptr) { 6140 if (_super_klass->is_interface()) { 6141 classfile_icce_error("class %s has interface %s as super class", _super_klass, THREAD); 6142 return; 6143 } 6144 6145 if (_super_klass->is_final()) { 6146 classfile_icce_error("class %s cannot inherit from final class %s", _super_klass, THREAD); 6147 return; 6148 } 6149 6150 if (Arguments::is_valhalla_enabled()) { 6151 // If this class is an value class, its super class cannot be an identity class unless it is java.lang.Object. 6152 if (_super_klass->access_flags().is_identity_class() && !access_flags().is_identity_class() && 6153 _super_klass != vmClasses::Object_klass()) { 6154 ResourceMark rm(THREAD); 6155 THROW_MSG(vmSymbols::java_lang_IncompatibleClassChangeError(), 6156 err_msg("Value type %s has an identity type as supertype", _class_name->as_C_string())); 6157 } 6158 } 6159 6160 if (_super_klass->has_nonstatic_concrete_methods()) { 6161 _has_nonstatic_concrete_methods = true; 6162 } 6163 } 6164 6165 if (_parsed_annotations->has_annotation(AnnotationCollector::_jdk_internal_LooselyConsistentValue) && _access_flags.is_identity_class()) { 6166 THROW_MSG(vmSymbols::java_lang_ClassFormatError(), 6167 err_msg("class %s cannot have annotation jdk.internal.vm.annotation.LooselyConsistentValue, because it is not a value class", 6168 _class_name->as_klass_external_name())); 6169 } 6170 6171 // Determining if the class allows tearing or not (default is not) 6172 if (Arguments::is_valhalla_enabled() && !_access_flags.is_identity_class()) { 6173 if (_parsed_annotations->has_annotation(ClassAnnotationCollector::_jdk_internal_LooselyConsistentValue) 6174 && (_super_klass == vmClasses::Object_klass() || !_super_klass->must_be_atomic())) { 6175 // Conditions above are not sufficient to determine atomicity requirements, 6176 // the presence of fields with atomic requirements could force the current class to have atomicy requirements too 6177 // Marking as not needing atomicity for now, can be updated when computing the fields layout 6178 // The InstanceKlass must be filled with the value from the FieldLayoutInfo returned by 6179 // the FieldLayoutBuilder, not with this _must_be_atomic field. 6180 _must_be_atomic = false; 6181 } 6182 // Apply VM options override 6183 if (*ForceNonTearable != '\0') { 6184 // Allow a command line switch to force the same atomicity property: 6185 const char* class_name_str = _class_name->as_C_string(); 6186 if (StringUtils::class_list_match(ForceNonTearable, class_name_str)) { 6187 _must_be_atomic = true; 6188 } 6189 } 6190 } 6191 6192 // Compute the transitive list of all unique interfaces implemented by this class 6193 _transitive_interfaces = 6194 compute_transitive_interfaces(_super_klass, 6195 _local_interfaces, 6196 _loader_data, 6197 CHECK); 6198 6199 assert(_transitive_interfaces != nullptr, "invariant"); 6200 6201 // sort methods 6202 _method_ordering = sort_methods(_methods); 6203 6204 _all_mirandas = new GrowableArray<Method*>(20); 6205 6206 Handle loader(THREAD, _loader_data->class_loader()); 6207 klassVtable::compute_vtable_size_and_num_mirandas(&_vtable_size, 6208 &_num_miranda_methods, 6209 _all_mirandas, 6210 _super_klass, 6211 _methods, 6212 _access_flags, 6213 _major_version, 6214 loader, 6215 _class_name, 6216 _local_interfaces); 6217 6218 // Size of Java itable (in words) 6219 _itable_size = is_interface() ? 0 : 6220 klassItable::compute_itable_size(_transitive_interfaces); 6221 6222 assert(_parsed_annotations != nullptr, "invariant"); 6223 6224 if (Arguments::is_valhalla_enabled()) { 6225 fetch_field_classes(cp, CHECK); 6226 } 6227 6228 _layout_info = new FieldLayoutInfo(); 6229 FieldLayoutBuilder lb(class_name(), loader_data(), super_klass(), _cp, /*_fields*/ _temp_field_info, 6230 _parsed_annotations->is_contended(), is_inline_type(), 6231 access_flags().is_abstract() && !access_flags().is_identity_class() && !access_flags().is_interface(), 6232 _must_be_atomic, _layout_info, _inline_layout_info_array); 6233 lb.build_layout(); 6234 6235 // If it turned out that we didn't inline any of the fields, we deallocate 6236 // the array of InlineLayoutInfo since it isn't needed, and so it isn't 6237 // transferred to the allocated InstanceKlass. 6238 if (_inline_layout_info_array != nullptr && !_layout_info->_has_inlined_fields) { 6239 MetadataFactory::free_array<InlineLayoutInfo>(_loader_data, _inline_layout_info_array); 6240 _inline_layout_info_array = nullptr; 6241 } 6242 6243 int injected_fields_count = _temp_field_info->length() - _java_fields_count; 6244 _fieldinfo_stream = 6245 FieldInfoStream::create_FieldInfoStream(_temp_field_info, _java_fields_count, 6246 injected_fields_count, loader_data(), CHECK); 6247 _fieldinfo_search_table = FieldInfoStream::create_search_table(_cp, _fieldinfo_stream, _loader_data, CHECK); 6248 _fields_status = 6249 MetadataFactory::new_array<FieldStatus>(_loader_data, _temp_field_info->length(), 6250 FieldStatus(0), CHECK); 6251 6252 // Strict static fields track initialization status from the beginning of time. 6253 // After this class runs <clinit>, they will be verified as being "not unset". 6254 // See Step 8 of InstanceKlass::initialize_impl. 6255 if (_has_strict_static_fields) { 6256 bool found_one = false; 6257 for (int i = 0; i < _temp_field_info->length(); i++) { 6258 FieldInfo& fi = *_temp_field_info->adr_at(i); 6259 if (fi.access_flags().is_strict() && fi.access_flags().is_static()) { 6260 found_one = true; 6261 if (fi.initializer_index() != 0) { 6262 // skip strict static fields with ConstantValue attributes 6263 } else { 6264 _fields_status->adr_at(fi.index())->update_strict_static_unset(true); 6265 _fields_status->adr_at(fi.index())->update_strict_static_unread(true); 6266 } 6267 } 6268 } 6269 assert(found_one == _has_strict_static_fields, 6270 "correct prediction = %d", (int)_has_strict_static_fields); 6271 } 6272 } 6273 6274 // In order to be able to optimize fields layouts by applying heap flattening, 6275 // the JVM needs to know the layout of the class of the fields, which implies 6276 // having these classes loaded. The strategy has two folds: 6277 // 1 - if the current class has a LoadableDescriptors attribute containing the 6278 // name of the class of the field and PreloadClasses is true, the JVM will 6279 // try to speculatively load this class. Failures to load the class are 6280 // silently discarded, and loadings resulting in a non-optimizable class 6281 // are ignored 6282 // 2 - if step 1 cannot be applied, the JVM will simply check if the class 6283 // loader of the current class already knows these classes (no class 6284 // loading triggered in this case). Note that the migrated value classes 6285 // of the JDK are automatically registered to all class loaders, and 6286 // are guaranteed to be found in this step even if the current class 6287 // has not been recompiled with JEP 401 features enabled 6288 void ClassFileParser::fetch_field_classes(ConstantPool* cp, TRAPS) { 6289 for (FieldInfo fieldinfo : *_temp_field_info) { 6290 if (fieldinfo.access_flags().is_static()) continue; // Only non-static fields are processed at load time 6291 Symbol* sig = fieldinfo.signature(cp); 6292 if (Signature::has_envelope(sig)) { 6293 TempNewSymbol name = Signature::strip_envelope(sig); 6294 if (name == _class_name) continue; 6295 if (PreloadClasses && is_class_in_loadable_descriptors_attribute(sig)) { 6296 log_info(class, preload)("Preloading of class %s during loading of class %s. " 6297 "Cause: field type in LoadableDescriptors attribute", 6298 name->as_C_string(), _class_name->as_C_string()); 6299 oop loader = loader_data()->class_loader(); 6300 InstanceKlass* klass = SystemDictionary::resolve_super_or_fail(_class_name, name, 6301 Handle(THREAD, loader), 6302 false, THREAD); 6303 6304 assert((klass == nullptr) == HAS_PENDING_EXCEPTION, "Must be the same"); 6305 6306 if (klass != nullptr) { 6307 if (klass->is_inline_klass()) { 6308 set_inline_layout_info_klass(fieldinfo.index(), InlineKlass::cast(klass), CHECK); 6309 log_info(class, preload)("Preloading of class %s during loading of class %s " 6310 "(cause: field type in LoadableDescriptors attribute) succeeded", 6311 name->as_C_string(), _class_name->as_C_string()); 6312 } else { 6313 // Non value class are allowed by the current spec, but it could be an indication of an issue so let's log this 6314 log_info(class, preload)("Preloading of class %s during loading of class %s " 6315 "(cause: field type in LoadableDescriptors attribute) but loaded class is not a value class", 6316 name->as_C_string(), _class_name->as_C_string()); 6317 if (fieldinfo.field_flags().is_null_free_inline_type()) { 6318 log_warning(class, preload)("After preloading of class %s during loading of class %s " 6319 "field was annotated with @NullRestricted but loaded class is not a value class, " 6320 "the annotation is ignored", 6321 name->as_C_string(), _class_name->as_C_string()); 6322 fieldinfo.field_flags().update_null_free_inline_type(false); 6323 } 6324 } 6325 } else { 6326 log_info(class, preload)("Preloading of class %s during loading of class %s " 6327 "(cause: field type in LoadableDescriptors attribute) failed : %s", 6328 name->as_C_string(), _class_name->as_C_string(), 6329 PENDING_EXCEPTION->klass()->name()->as_C_string()); 6330 if (fieldinfo.field_flags().is_null_free_inline_type()) { 6331 log_warning(class, preload)("After preloading of class %s during loading of class %s failed," 6332 "field was annotated with @NullRestricted but class is unknown, " 6333 "the annotation is ignored", 6334 name->as_C_string(), _class_name->as_C_string()); 6335 fieldinfo.field_flags().update_null_free_inline_type(false); 6336 } 6337 6338 // Loads triggered by the LoadableDescriptors attribute are speculative, failures must not 6339 // impact loading of current class. 6340 CLEAR_PENDING_EXCEPTION; 6341 } 6342 } else { 6343 oop loader = loader_data()->class_loader(); 6344 InstanceKlass* klass = SystemDictionary::find_instance_klass(THREAD, name, Handle(THREAD, loader)); 6345 if (klass != nullptr && klass->is_inline_klass()) { 6346 set_inline_layout_info_klass(fieldinfo.index(), InlineKlass::cast(klass), CHECK); 6347 log_info(class, preload)("During loading of class %s , class %s found in local system dictionary" 6348 "(field type not in LoadableDescriptors attribute)", 6349 _class_name->as_C_string(), name->as_C_string()); 6350 } else if (fieldinfo.field_flags().is_null_free_inline_type()) { 6351 if (klass == nullptr) { 6352 log_warning(class, preload)("During loading of class %s, class %s is unknown, " 6353 "but a field of this type was annotated with @NullRestricted, " 6354 "the annotation is ignored", 6355 _class_name->as_C_string(), name->as_C_string()); 6356 } else { 6357 log_warning(class, preload)("During loading of class %s, class %s was found in the local system dictionary " 6358 "and is not a concrete value class, but a field of this type was annotated with " 6359 "@NullRestricted, the annotation is ignored", 6360 _class_name->as_C_string(), name->as_C_string()); 6361 } 6362 fieldinfo.field_flags().update_null_free_inline_type(false); 6363 } 6364 } 6365 } 6366 } 6367 } 6368 6369 void ClassFileParser::set_klass(InstanceKlass* klass) { 6370 6371 #ifdef ASSERT 6372 if (klass != nullptr) { 6373 assert(nullptr == _klass, "leaking?"); 6374 } 6375 #endif 6376 6377 _klass = klass; 6378 } 6379 6380 void ClassFileParser::set_inline_layout_info_klass(int field_index, InlineKlass* ik, TRAPS) { 6381 assert(field_index >= 0 && field_index < java_fields_count(), "IOOB: 0 <= %d < %d", field_index, (int)java_fields_count()); 6382 6383 // The array of InlineLayoutInfo is allocated on demand. This way the array is 6384 // never allocated for an InstanceKlass which has no need for this information. 6385 if (_inline_layout_info_array == nullptr) { 6386 _inline_layout_info_array = MetadataFactory::new_array<InlineLayoutInfo>(_loader_data, 6387 java_fields_count(), 6388 CHECK); 6389 } 6390 6391 // Set the Klass for the field's index 6392 _inline_layout_info_array->adr_at(field_index)->set_klass(ik); 6393 } 6394 6395 void ClassFileParser::set_klass_to_deallocate(InstanceKlass* klass) { 6396 6397 #ifdef ASSERT 6398 if (klass != nullptr) { 6399 assert(nullptr == _klass_to_deallocate, "leaking?"); 6400 } 6401 #endif 6402 6403 _klass_to_deallocate = klass; 6404 } 6405 6406 // Caller responsible for ResourceMark 6407 // clone stream with rewound position 6408 const ClassFileStream* ClassFileParser::clone_stream() const { 6409 assert(_stream != nullptr, "invariant"); 6410 6411 return _stream->clone(); 6412 } 6413 6414 ReferenceType ClassFileParser::super_reference_type() const { 6415 return _super_klass == nullptr ? REF_NONE : _super_klass->reference_type(); 6416 } 6417 6418 bool ClassFileParser::is_instance_ref_klass() const { 6419 // Only the subclasses of j.l.r.Reference are InstanceRefKlass. 6420 // j.l.r.Reference itself is InstanceKlass because InstanceRefKlass denotes a 6421 // klass requiring special treatment in ref-processing. The abstract 6422 // j.l.r.Reference cannot be instantiated so doesn't partake in 6423 // ref-processing. 6424 return is_java_lang_ref_Reference_subclass(); 6425 } 6426 6427 bool ClassFileParser::is_java_lang_ref_Reference_subclass() const { 6428 if (_super_klass == nullptr) { 6429 return false; 6430 } 6431 6432 if (_super_klass->name() == vmSymbols::java_lang_ref_Reference()) { 6433 // Direct subclass of j.l.r.Reference: Soft|Weak|Final|Phantom 6434 return true; 6435 } 6436 6437 return _super_klass->reference_type() != REF_NONE; 6438 } 6439 6440 // ---------------------------------------------------------------------------- 6441 // debugging 6442 6443 #ifdef ASSERT 6444 6445 // return true if class_name contains no '.' (internal format is '/') 6446 bool ClassFileParser::is_internal_format(Symbol* class_name) { 6447 if (class_name != nullptr) { 6448 ResourceMark rm; 6449 char* name = class_name->as_C_string(); 6450 return strchr(name, JVM_SIGNATURE_DOT) == nullptr; 6451 } else { 6452 return true; 6453 } 6454 } 6455 6456 #endif --- EOF ---