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