1 /*
2 * Copyright (c) 2015, 2024, 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 "precompiled.hpp"
26 #include "cds/aotConstantPoolResolver.hpp"
27 #include "cds/archiveUtils.hpp"
28 #include "cds/cdsConfig.hpp"
29 #include "cds/classListParser.hpp"
30 #include "cds/lambdaFormInvokers.hpp"
31 #include "cds/metaspaceShared.hpp"
32 #include "cds/unregisteredClasses.hpp"
33 #include "classfile/classLoader.hpp"
34 #include "classfile/javaClasses.inline.hpp"
35 #include "classfile/symbolTable.hpp"
36 #include "classfile/systemDictionary.hpp"
37 #include "classfile/systemDictionaryShared.hpp"
38 #include "classfile/vmClasses.hpp"
39 #include "classfile/vmSymbols.hpp"
40 #include "interpreter/bytecode.hpp"
41 #include "interpreter/interpreterRuntime.hpp"
42 #include "interpreter/linkResolver.hpp"
43 #include "jimage.hpp"
44 #include "jvm.h"
45 #include "logging/log.hpp"
46 #include "logging/logTag.hpp"
47 #include "memory/oopFactory.hpp"
48 #include "memory/resourceArea.hpp"
49 #include "oops/constantPool.inline.hpp"
50 #include "oops/cpCache.inline.hpp"
51 #include "runtime/atomic.hpp"
52 #include "runtime/globals_extension.hpp"
53 #include "runtime/handles.inline.hpp"
54 #include "runtime/java.hpp"
55 #include "runtime/javaCalls.hpp"
56 #include "utilities/defaultStream.hpp"
57 #include "utilities/macros.hpp"
58 #include "utilities/utf8.hpp"
59
60 const char* ClassListParser::CLASS_REFLECTION_DATA_TAG = "@class-reflection-data";
61 const char* ClassListParser::CONSTANT_POOL_TAG = "@cp";
62 const char* ClassListParser::DYNAMIC_PROXY_TAG = "@dynamic-proxy";
63 const char* ClassListParser::LAMBDA_FORM_TAG = "@lambda-form-invoker";
64 const char* ClassListParser::LAMBDA_PROXY_TAG = "@lambda-proxy";
65 const char* ClassListParser::LOADER_NEGATIVE_CACHE_TAG = "@loader-negative-cache";
66 const char* ClassListParser::ARRAY_TAG = "@array";
67
68 volatile Thread* ClassListParser::_parsing_thread = nullptr;
69 ClassListParser* ClassListParser::_instance = nullptr;
70
71 ClassListParser::ClassListParser(const char* file, ParseMode parse_mode) :
72 _classlist_file(file),
73 _id2klass_table(INITIAL_TABLE_SIZE, MAX_TABLE_SIZE),
74 _file_input(do_open(file), /* need_close=*/true),
75 _input_stream(&_file_input),
76 _parse_mode(parse_mode) {
77 log_info(cds)("Parsing %s%s", file,
78 parse_lambda_forms_invokers_only() ? " (lambda form invokers only)" : "");
79 if (!_file_input.is_open()) {
80 char reason[JVM_MAXPATHLEN];
81 os::lasterror(reason, JVM_MAXPATHLEN);
82 vm_exit_during_initialization(err_msg("Loading %s %s failed",
83 FLAG_IS_DEFAULT(AOTConfiguration) ?
84 "classlist" : "AOTConfiguration file",
85 file),
86 reason);
87 }
88 _token = _line = nullptr;
89 _interfaces = new (mtClass) GrowableArray<int>(10, mtClass);
90 _indy_items = new (mtClass) GrowableArray<const char*>(9, mtClass);
91
92 // _instance should only be accessed by the thread that created _instance.
93 assert(_instance == nullptr, "must be singleton");
94 _instance = this;
95 Atomic::store(&_parsing_thread, Thread::current());
96 }
97
98 FILE* ClassListParser::do_open(const char* file) {
99 // Use os::open() because neither fopen() nor os::fopen()
100 // can handle long path name on Windows. (See JDK-8216184)
101 int fd = os::open(file, O_RDONLY, S_IREAD);
102 FILE* fp = nullptr;
103 if (fd != -1) {
104 // Obtain a FILE* from the file descriptor so that _input_stream
105 // can be used in ClassListParser::parse()
106 fp = os::fdopen(fd, "r");
107 }
108 return fp;
109 }
110
111 bool ClassListParser::is_parsing_thread() {
112 return Atomic::load(&_parsing_thread) == Thread::current();
113 }
114
115 ClassListParser::~ClassListParser() {
116 Atomic::store(&_parsing_thread, (Thread*)nullptr);
117 delete _indy_items;
118 delete _interfaces;
119 _instance = nullptr;
120 }
121
122 void ClassListParser::parse(TRAPS) {
123 for (; !_input_stream.done(); _input_stream.next()) {
124 _line = _input_stream.current_line();
125 clean_up_input_line();
126
127 // Each line in the classlist can be one of three forms:
128 if (_line[0] == '#') {
129 // A comment; ignore it
130 } else if (_line[0] == '@') {
131 // @xxx - a tag like @lambda-proxy, to be parsed by parse_at_tags()
132 parse_at_tags(CHECK);
133 } else {
134 // A class name, followed by optional attributes. E.g.
135 // java/lang/String
136 // java/lang/Object id: 1
137 // my/pkg/TestClass id: 5 super: 1 interfaces: 3 4 source: foo.jar
138 parse_class_name_and_attributes(CHECK);
139 }
140 }
141 }
142
143 void ClassListParser::parse_class_name_and_attributes(TRAPS) {
144 read_class_name_and_attributes();
145
146 if (parse_lambda_forms_invokers_only()) {
147 return;
148 }
149
150 check_class_name(_class_name);
151 TempNewSymbol class_name_symbol = SymbolTable::new_symbol(_class_name);
152 Klass* klass = load_current_class(class_name_symbol, THREAD);
153 if (HAS_PENDING_EXCEPTION) {
154 if (PENDING_EXCEPTION->is_a(vmClasses::OutOfMemoryError_klass())) {
155 // If we have run out of memory, don't try to load the rest of the classes in
156 // the classlist. Throw an exception, which will terminate the dumping process.
157 return; // THROW
158 }
159
160 ResourceMark rm(THREAD);
161 char* ex_msg = (char*)"";
162 oop message = java_lang_Throwable::message(PENDING_EXCEPTION);
163 if (message != nullptr) {
164 ex_msg = java_lang_String::as_utf8_string(message);
165 }
166 log_warning(cds)("%s: %s", PENDING_EXCEPTION->klass()->external_name(), ex_msg);
167 // We might have an invalid class name or an bad class. Warn about it
168 // and keep going to the next line.
169 CLEAR_PENDING_EXCEPTION;
170 log_warning(cds)("Preload Warning: Cannot find %s", _class_name);
171 return;
172 }
173
174 assert(klass != nullptr, "sanity");
175 if (log_is_enabled(Trace, cds)) {
176 ResourceMark rm(THREAD);
177 log_trace(cds)("Shared spaces preloaded: %s", klass->external_name());
178 }
179
180 if (klass->is_instance_klass()) {
181 InstanceKlass* ik = InstanceKlass::cast(klass);
182
183 // Link the class to cause the bytecodes to be rewritten and the
184 // cpcache to be created. The linking is done as soon as classes
185 // are loaded in order that the related data structures (klass and
186 // cpCache) are located together.
187 MetaspaceShared::try_link_class(THREAD, ik);
188 }
189 }
190
191 void ClassListParser::clean_up_input_line() {
192 int len = (int)strlen(_line);
193 int i;
194 // Replace \t\r\n\f with ' '
195 for (i=0; i<len; i++) {
196 if (_line[i] == '\t' || _line[i] == '\r' || _line[i] == '\n' || _line[i] == '\f') {
197 _line[i] = ' ';
198 }
199 }
200
201 // Remove trailing newline/space
202 while (len > 0) {
203 if (_line[len-1] == ' ') {
204 _line[len-1] = '\0';
205 len --;
206 } else {
207 break;
208 }
209 }
210 _line_len = len;
211 }
212
213 void ClassListParser::read_class_name_and_attributes() {
214 _class_name = _line;
215 _id = _unspecified;
216 _super = _unspecified;
217 _interfaces->clear();
218 _source = nullptr;
219 _interfaces_specified = false;
220
221 if ((_token = strchr(_line, ' ')) == nullptr) {
222 // No optional attributes are specified.
223 return;
224 }
225
226 // Mark the end of the name, and go to the next input char
227 *_token++ = '\0';
228
229 while (*_token) {
230 skip_whitespaces();
231
232 if (parse_uint_option("id:", &_id)) {
233 continue;
234 } else if (parse_uint_option("super:", &_super)) {
235 check_already_loaded("Super class", _super);
236 continue;
237 } else if (skip_token("interfaces:")) {
238 int i;
239 while (try_parse_uint(&i)) {
240 check_already_loaded("Interface", i);
241 _interfaces->append(i);
242 }
243 } else if (skip_token("source:")) {
244 skip_whitespaces();
245 _source = _token;
246 char* s = strchr(_token, ' ');
247 if (s == nullptr) {
248 break; // end of input line
249 } else {
250 *s = '\0'; // mark the end of _source
251 _token = s+1;
252 }
253 } else {
254 error("Unknown input");
255 }
256 }
257
258 // if src is specified
259 // id super interfaces must all be specified
260 // loader may be specified
261 // else
262 // # the class is loaded from classpath
263 // id may be specified
264 // super, interfaces, loader must not be specified
265 }
266
267 void ClassListParser::split_tokens_by_whitespace(int offset, GrowableArray<const char*>* items) {
268 int start = offset;
269 int end;
270 bool done = false;
271 while (!done) {
272 while (_line[start] == ' ' || _line[start] == '\t') start++;
273 end = start;
274 while (_line[end] && _line[end] != ' ' && _line[end] != '\t') end++;
275 if (_line[end] == '\0') {
276 done = true;
277 } else {
278 _line[end] = '\0';
279 }
280 items->append(_line + start);
281 start = ++end;
282 }
283 }
284
285 int ClassListParser::split_at_tag_from_line() {
286 _token = _line;
287 char* ptr;
288 if ((ptr = strchr(_line, ' ')) == nullptr) {
289 error("Too few items following the @ tag \"%s\" line #%zu", _line, lineno());
290 return 0;
291 }
292 *ptr++ = '\0';
293 while (*ptr == ' ' || *ptr == '\t') ptr++;
294 return (int)(ptr - _line);
295 }
296
297 void ClassListParser::parse_at_tags(TRAPS) {
298 assert(_line[0] == '@', "must be");
299 int offset = split_at_tag_from_line();
300 assert(offset > 0, "would have exited VM");
301
302 if (strcmp(_token, LAMBDA_PROXY_TAG) == 0) {
303 _indy_items->clear();
304 split_tokens_by_whitespace(offset, _indy_items);
305 if (_indy_items->length() < 2) {
306 error("Line with @ tag has too few items \"%s\" line #%zu", _token, lineno());
307 }
308 if (!parse_lambda_forms_invokers_only()) {
309 _class_name = _indy_items->at(0);
310 check_class_name(_class_name);
311 TempNewSymbol class_name_symbol = SymbolTable::new_symbol(_class_name);
312 if (_indy_items->length() > 0) {
313 // The current line is "@lambda-proxy class_name". Load the proxy class.
314 resolve_indy(THREAD, class_name_symbol);
315 }
316 }
317 } else if (strcmp(_token, LAMBDA_FORM_TAG) == 0) {
318 LambdaFormInvokers::append(os::strdup((const char*)(_line + offset), mtInternal));
319 } else if (strcmp(_token, CONSTANT_POOL_TAG) == 0) {
320 _token = _line + offset;
321 parse_constant_pool_tag();
322 } else if (strcmp(_token, ARRAY_TAG) == 0) {
323 _token = _line + offset;
324 parse_array_dimension_tag();
325 } else if (strcmp(_token, CLASS_REFLECTION_DATA_TAG) == 0) {
326 _token = _line + offset;
327 parse_class_reflection_data_tag();
328 } else if (strcmp(_token, DYNAMIC_PROXY_TAG) == 0) {
329 _token = _line + offset;
330 parse_dynamic_proxy_tag();
331 } else if (strcmp(_token, LOADER_NEGATIVE_CACHE_TAG) == 0) {
332 _token = _line + offset;
333 parse_loader_negative_cache_tag();
334 } else {
335 error("Invalid @ tag at the beginning of line \"%s\" line #%zu", _token, lineno());
336 }
337 }
338
339 void ClassListParser::skip_whitespaces() {
340 while (*_token == ' ' || *_token == '\t') {
341 _token ++;
342 }
343 }
344
345 void ClassListParser::skip_non_whitespaces() {
346 while (*_token && *_token != ' ' && *_token != '\t') {
347 _token ++;
348 }
349 }
350
351 void ClassListParser::parse_int(int* value) {
352 skip_whitespaces();
353 if (sscanf(_token, "%i", value) == 1) {
354 skip_non_whitespaces();
355 } else {
356 error("Error: expected integer");
357 }
358 }
359
360 void ClassListParser::parse_uint(int* value) {
361 parse_int(value);
362 if (*value < 0) {
363 error("Error: negative integers not allowed (%d)", *value);
364 }
365 }
366
367 bool ClassListParser::try_parse_uint(int* value) {
368 skip_whitespaces();
369 if (sscanf(_token, "%i", value) == 1) {
370 skip_non_whitespaces();
371 return true;
372 }
373 return false;
374 }
375
376 bool ClassListParser::skip_token(const char* option_name) {
377 size_t len = strlen(option_name);
378 if (strncmp(_token, option_name, len) == 0) {
379 _token += len;
380 return true;
381 } else {
382 return false;
383 }
384 }
385
386 bool ClassListParser::parse_int_option(const char* option_name, int* value) {
387 if (skip_token(option_name)) {
388 if (*value != _unspecified) {
389 error("%s specified twice", option_name);
390 } else {
391 parse_int(value);
392 return true;
393 }
394 }
395 return false;
396 }
397
398 bool ClassListParser::parse_uint_option(const char* option_name, int* value) {
399 if (skip_token(option_name)) {
400 if (*value != _unspecified) {
401 error("%s specified twice", option_name);
402 } else {
403 parse_uint(value);
404 return true;
405 }
406 }
407 return false;
408 }
409
410 void ClassListParser::print_specified_interfaces() {
411 const int n = _interfaces->length();
412 jio_fprintf(defaultStream::error_stream(), "Currently specified interfaces[%d] = {\n", n);
413 for (int i=0; i<n; i++) {
414 InstanceKlass* k = lookup_class_by_id(_interfaces->at(i));
415 jio_fprintf(defaultStream::error_stream(), " %4d = %s\n", _interfaces->at(i), k->name()->as_klass_external_name());
416 }
417 jio_fprintf(defaultStream::error_stream(), "}\n");
418 }
419
420 void ClassListParser::print_actual_interfaces(InstanceKlass* ik) {
421 int n = ik->local_interfaces()->length();
422 jio_fprintf(defaultStream::error_stream(), "Actual interfaces[%d] = {\n", n);
423 for (int i = 0; i < n; i++) {
424 InstanceKlass* e = ik->local_interfaces()->at(i);
425 jio_fprintf(defaultStream::error_stream(), " %s\n", e->name()->as_klass_external_name());
426 }
427 jio_fprintf(defaultStream::error_stream(), "}\n");
428 }
429
430 void ClassListParser::print_diagnostic_info(outputStream* st, const char* msg, ...) {
431 va_list ap;
432 va_start(ap, msg);
433 print_diagnostic_info(st, msg, ap);
434 va_end(ap);
435 }
436
437 void ClassListParser::print_diagnostic_info(outputStream* st, const char* msg, va_list ap) {
438 int error_index = pointer_delta_as_int(_token, _line);
439 if (error_index >= _line_len) {
440 error_index = _line_len - 1;
441 }
442 if (error_index < 0) {
443 error_index = 0;
444 }
445
446 jio_fprintf(defaultStream::error_stream(),
447 "An error has occurred while processing class list file %s %zu:%d.\n",
448 _classlist_file, lineno(), (error_index + 1));
449 jio_vfprintf(defaultStream::error_stream(), msg, ap);
450
451 if (_line_len <= 0) {
452 st->print("\n");
453 } else {
454 st->print(":\n");
455 for (int i=0; i<_line_len; i++) {
456 char c = _line[i];
457 if (c == '\0') {
458 st->print("%s", " ");
459 } else {
460 st->print("%c", c);
461 }
462 }
463 st->print("\n");
464 for (int i=0; i<error_index; i++) {
465 st->print("%s", " ");
466 }
467 st->print("^\n");
468 }
469 }
470
471 void ClassListParser::error(const char* msg, ...) {
472 va_list ap;
473 va_start(ap, msg);
474 fileStream fs(defaultStream::error_stream());
475 //TODO: we should write to UL/error instead, but that requires fixing some tests cases.
476 //LogTarget(Error, cds) lt;
477 //LogStream ls(lt);
478 print_diagnostic_info(&fs, msg, ap);
479 va_end(ap);
480 vm_exit_during_initialization("class list format error.", nullptr);
481 }
482
483 void ClassListParser::check_class_name(const char* class_name) {
484 const char* err = nullptr;
485 size_t len = strlen(class_name);
486 if (len > (size_t)Symbol::max_length()) {
487 err = "class name too long";
488 } else {
489 assert(Symbol::max_length() < INT_MAX && len < INT_MAX, "must be");
490 if (!UTF8::is_legal_utf8((const unsigned char*)class_name, len, /*version_leq_47*/false)) {
491 err = "class name is not valid UTF8";
492 }
493 }
494 if (err != nullptr) {
495 jio_fprintf(defaultStream::error_stream(),
496 "An error has occurred while processing class list file %s:%zu %s\n",
497 _classlist_file, lineno(), err);
498 vm_exit_during_initialization("class list format error.", nullptr);
499 }
500 }
501
502 void ClassListParser::constant_pool_resolution_warning(const char* msg, ...) {
503 va_list ap;
504 va_start(ap, msg);
505 LogTarget(Warning, cds, resolve) lt;
506 LogStream ls(lt);
507 print_diagnostic_info(&ls, msg, ap);
508 ls.print("Your classlist may be out of sync with the JDK or the application.");
509 va_end(ap);
510 }
511
512 // This function is used for loading classes for customized class loaders
513 // during archive dumping.
514 InstanceKlass* ClassListParser::load_class_from_source(Symbol* class_name, TRAPS) {
515 #if !(defined(_LP64) && (defined(LINUX) || defined(__APPLE__) || defined(_WINDOWS)))
516 // The only supported platforms are: (1) Linux/64-bit and (2) Solaris/64-bit and
517 // (3) MacOSX/64-bit and (4) Windowss/64-bit
518 // This #if condition should be in sync with the areCustomLoadersSupportedForCDS
519 // method in test/lib/jdk/test/lib/Platform.java.
520 error("AppCDS custom class loaders not supported on this platform");
521 #endif
522
523 if (!is_super_specified()) {
524 error("If source location is specified, super class must be also specified");
525 }
526 if (!is_id_specified()) {
527 error("If source location is specified, id must be also specified");
528 }
529 if (strncmp(_class_name, "java/", 5) == 0) {
530 log_info(cds)("Prohibited package for non-bootstrap classes: %s.class from %s",
531 _class_name, _source);
532 THROW_NULL(vmSymbols::java_lang_ClassNotFoundException());
533 }
534
535 ResourceMark rm;
536 char * source_path = os::strdup_check_oom(ClassLoader::uri_to_path(_source));
537 InstanceKlass* k = UnregisteredClasses::load_class(class_name, source_path, CHECK_NULL);
538 if (k->local_interfaces()->length() != _interfaces->length()) {
539 print_specified_interfaces();
540 print_actual_interfaces(k);
541 error("The number of interfaces (%d) specified in class list does not match the class file (%d)",
542 _interfaces->length(), k->local_interfaces()->length());
543 }
544
545 assert(k->is_shared_unregistered_class(), "must be");
546
547 bool added = SystemDictionaryShared::add_unregistered_class(THREAD, k);
548 if (!added) {
549 // We allow only a single unregistered class for each unique name.
550 error("Duplicated class %s", _class_name);
551 }
552
553 return k;
554 }
555
556 void ClassListParser::populate_cds_indy_info(const constantPoolHandle &pool, int cp_index, CDSIndyInfo* cii, TRAPS) {
557 // Caller needs to allocate ResourceMark.
558 int type_index = pool->bootstrap_name_and_type_ref_index_at(cp_index);
559 int name_index = pool->name_ref_index_at(type_index);
560 cii->add_item(pool->symbol_at(name_index)->as_C_string());
561 int sig_index = pool->signature_ref_index_at(type_index);
562 cii->add_item(pool->symbol_at(sig_index)->as_C_string());
563 int argc = pool->bootstrap_argument_count_at(cp_index);
564 if (argc > 0) {
565 for (int arg_i = 0; arg_i < argc; arg_i++) {
566 int arg = pool->bootstrap_argument_index_at(cp_index, arg_i);
567 jbyte tag = pool->tag_at(arg).value();
568 if (tag == JVM_CONSTANT_MethodType) {
569 cii->add_item(pool->method_type_signature_at(arg)->as_C_string());
570 } else if (tag == JVM_CONSTANT_MethodHandle) {
571 cii->add_ref_kind(pool->method_handle_ref_kind_at(arg));
572 int callee_index = pool->method_handle_klass_index_at(arg);
573 Klass* callee = pool->klass_at(callee_index, CHECK);
574 cii->add_item(callee->name()->as_C_string());
575 cii->add_item(pool->method_handle_name_ref_at(arg)->as_C_string());
576 cii->add_item(pool->method_handle_signature_ref_at(arg)->as_C_string());
577 } else {
578 ShouldNotReachHere();
579 }
580 }
581 }
582 }
583
584 bool ClassListParser::is_matching_cp_entry(const constantPoolHandle &pool, int cp_index, TRAPS) {
585 ResourceMark rm(THREAD);
586 CDSIndyInfo cii;
587 populate_cds_indy_info(pool, cp_index, &cii, CHECK_0);
588 GrowableArray<const char*>* items = cii.items();
589 int indy_info_offset = 1;
590 if (_indy_items->length() - indy_info_offset != items->length()) {
591 return false;
592 }
593 for (int i = 0; i < items->length(); i++) {
594 if (strcmp(_indy_items->at(i + indy_info_offset), items->at(i)) != 0) {
595 return false;
596 }
597 }
598 return true;
599 }
600
601 void ClassListParser::resolve_indy(JavaThread* current, Symbol* class_name_symbol) {
602 ExceptionMark em(current);
603 JavaThread* THREAD = current; // For exception macros.
604 ClassListParser::resolve_indy_impl(class_name_symbol, THREAD);
605 if (HAS_PENDING_EXCEPTION) {
606 ResourceMark rm(current);
607 char* ex_msg = (char*)"";
608 oop message = java_lang_Throwable::message(PENDING_EXCEPTION);
609 if (message != nullptr) {
610 ex_msg = java_lang_String::as_utf8_string(message);
611 }
612 log_warning(cds)("resolve_indy for class %s has encountered exception: %s %s",
613 class_name_symbol->as_C_string(),
614 PENDING_EXCEPTION->klass()->external_name(),
615 ex_msg);
616 CLEAR_PENDING_EXCEPTION;
617 }
618 }
619
620 void ClassListParser::resolve_indy_impl(Symbol* class_name_symbol, TRAPS) {
621 if (CDSConfig::is_dumping_invokedynamic()) {
622 // The CP entry for the invokedynamic instruction will be resolved.
623 // No need to do the following.
624 return;
625 }
626
627 // This is an older CDS optimization:
628 // We store a pre-generated version of the lambda proxy class in the AOT cache,
629 // which will be loaded via JVM_LookupLambdaProxyClassFromArchive().
630 // This eliminate dynamic class generation of the proxy class, but we still need to
631 // resolve the CP entry for the invokedynamic instruction, which may result in
632 // generation of LambdaForm classes.
633 Handle class_loader(THREAD, SystemDictionary::java_system_loader());
634 Handle protection_domain;
635 Klass* klass = SystemDictionary::resolve_or_fail(class_name_symbol, class_loader, protection_domain, true, CHECK);
636 if (klass->is_instance_klass()) {
637 InstanceKlass* ik = InstanceKlass::cast(klass);
638 MetaspaceShared::try_link_class(THREAD, ik);
639 if (!ik->is_linked()) {
640 // Verification of ik has failed
641 return;
642 }
643
644 ConstantPool* cp = ik->constants();
645 ConstantPoolCache* cpcache = cp->cache();
646 bool found = false;
647 for (int indy_index = 0; indy_index < cpcache->resolved_indy_entries_length(); indy_index++) {
648 int pool_index = cpcache->resolved_indy_entry_at(indy_index)->constant_pool_index();
649 constantPoolHandle pool(THREAD, cp);
650 BootstrapInfo bootstrap_specifier(pool, pool_index, indy_index);
651 Handle bsm = bootstrap_specifier.resolve_bsm(CHECK);
652 if (!SystemDictionaryShared::is_supported_invokedynamic(&bootstrap_specifier)) {
653 log_debug(cds, lambda)("is_supported_invokedynamic check failed for cp_index %d", pool_index);
654 continue;
655 }
656 bool matched = is_matching_cp_entry(pool, pool_index, CHECK);
657 if (matched) {
658 found = true;
659 CallInfo info;
660 bool is_done = bootstrap_specifier.resolve_previously_linked_invokedynamic(info, CHECK);
661 if (!is_done) {
662 // resolve it
663 Handle recv;
664 LinkResolver::resolve_invoke(info,
665 recv,
666 pool,
667 indy_index,
668 Bytecodes::_invokedynamic, CHECK);
669 break;
670 }
671 cpcache->set_dynamic_call(info, indy_index);
672 }
673 }
674 if (!found) {
675 ResourceMark rm(THREAD);
676 log_warning(cds)("No invoke dynamic constant pool entry can be found for class %s. The classlist is probably out-of-date.",
677 class_name_symbol->as_C_string());
678 }
679 }
680 }
681
682 Klass* ClassListParser::load_current_class(Symbol* class_name_symbol, TRAPS) {
683 Klass* klass;
684 if (!is_loading_from_source()) {
685 // Load classes for the boot/platform/app loaders only.
686 if (is_super_specified()) {
687 error("If source location is not specified, super class must not be specified");
688 }
689 if (are_interfaces_specified()) {
690 error("If source location is not specified, interface(s) must not be specified");
691 }
692
693 if (Signature::is_array(class_name_symbol)) {
694 // array classes are not supported in class list.
695 THROW_NULL(vmSymbols::java_lang_ClassNotFoundException());
696 }
697
698 JavaValue result(T_OBJECT);
699 // Call java_system_loader().loadClass() directly, which will
700 // delegate to the correct loader (boot, platform or app) depending on
701 // the package name.
702
703 // ClassLoader.loadClass() wants external class name format, i.e., convert '/' chars to '.'
704 Handle ext_class_name = java_lang_String::externalize_classname(class_name_symbol, CHECK_NULL);
705 Handle loader = Handle(THREAD, SystemDictionary::java_system_loader());
706
707 JavaCalls::call_virtual(&result,
708 loader, //SystemDictionary::java_system_loader(),
709 vmClasses::ClassLoader_klass(),
710 vmSymbols::loadClass_name(),
711 vmSymbols::string_class_signature(),
712 ext_class_name,
713 CHECK_NULL);
714
715 assert(result.get_type() == T_OBJECT, "just checking");
716 oop obj = result.get_oop();
717 assert(obj != nullptr, "jdk.internal.loader.BuiltinClassLoader::loadClass never returns null");
718 klass = java_lang_Class::as_Klass(obj);
719 } else {
720 // If "source:" tag is specified, all super class and super interfaces must be specified in the
721 // class list file.
722 klass = load_class_from_source(class_name_symbol, CHECK_NULL);
723 }
724
725 assert(klass != nullptr, "exception should have been thrown");
726 assert(klass->is_instance_klass(), "array classes should have been filtered out");
727
728 if (is_id_specified()) {
729 InstanceKlass* ik = InstanceKlass::cast(klass);
730 int id = this->id();
731 SystemDictionaryShared::update_shared_entry(ik, id);
732 bool created;
733 id2klass_table()->put_if_absent(id, ik, &created);
734 if (!created) {
735 error("Duplicated ID %d for class %s", id, _class_name);
736 }
737 if (id2klass_table()->maybe_grow()) {
738 log_info(cds, hashtables)("Expanded id2klass_table() to %d", id2klass_table()->table_size());
739 }
740 }
741
742 return klass;
743 }
744
745 bool ClassListParser::is_loading_from_source() {
746 return (_source != nullptr);
747 }
748
749 InstanceKlass* ClassListParser::lookup_class_by_id(int id) {
750 InstanceKlass** klass_ptr = id2klass_table()->get(id);
751 if (klass_ptr == nullptr) {
752 error("Class ID %d has not been defined", id);
753 }
754 assert(*klass_ptr != nullptr, "must be");
755 return *klass_ptr;
756 }
757
758
759 InstanceKlass* ClassListParser::lookup_super_for_current_class(Symbol* super_name) {
760 if (!is_loading_from_source()) {
761 return nullptr;
762 }
763
764 InstanceKlass* k = lookup_class_by_id(super());
765 if (super_name != k->name()) {
766 error("The specified super class %s (id %d) does not match actual super class %s",
767 k->name()->as_klass_external_name(), super(),
768 super_name->as_klass_external_name());
769 }
770 return k;
771 }
772
773 InstanceKlass* ClassListParser::lookup_interface_for_current_class(Symbol* interface_name) {
774 if (!is_loading_from_source()) {
775 return nullptr;
776 }
777
778 const int n = _interfaces->length();
779 if (n == 0) {
780 error("Class %s implements the interface %s, but no interface has been specified in the input line",
781 _class_name, interface_name->as_klass_external_name());
782 ShouldNotReachHere();
783 }
784
785 int i;
786 for (i=0; i<n; i++) {
787 InstanceKlass* k = lookup_class_by_id(_interfaces->at(i));
788 if (interface_name == k->name()) {
789 return k;
790 }
791 }
792
793 // interface_name is not specified by the "interfaces:" keyword.
794 print_specified_interfaces();
795 error("The interface %s implemented by class %s does not match any of the specified interface IDs",
796 interface_name->as_klass_external_name(), _class_name);
797 ShouldNotReachHere();
798 return nullptr;
799 }
800
801 InstanceKlass* ClassListParser::find_builtin_class_helper(JavaThread* current, Symbol* class_name_symbol, oop class_loader_oop) {
802 Handle class_loader(current, class_loader_oop);
803 Handle protection_domain;
804 return SystemDictionary::find_instance_klass(current, class_name_symbol, class_loader, protection_domain);
805 }
806
807 InstanceKlass* ClassListParser::find_builtin_class(JavaThread* current, const char* class_name) {
808 TempNewSymbol class_name_symbol = SymbolTable::new_symbol(class_name);
809 InstanceKlass* ik;
810
811 if ( (ik = find_builtin_class_helper(current, class_name_symbol, nullptr)) != nullptr
812 || (ik = find_builtin_class_helper(current, class_name_symbol, SystemDictionary::java_platform_loader())) != nullptr
813 || (ik = find_builtin_class_helper(current, class_name_symbol, SystemDictionary::java_system_loader())) != nullptr) {
814 return ik;
815 } else {
816 return nullptr;
817 }
818 }
819
820 void ClassListParser::parse_array_dimension_tag() {
821 if (parse_lambda_forms_invokers_only()) {
822 return;
823 }
824
825 skip_whitespaces();
826 char* class_name = _token;
827 skip_non_whitespaces();
828 *_token = '\0';
829 _token ++;
830
831 skip_whitespaces();
832 int dim;
833 parse_uint(&dim);
834
835 JavaThread* THREAD = JavaThread::current();
836 InstanceKlass* ik = find_builtin_class(THREAD, class_name);
837 if (ik == nullptr) {
838 _token = class_name;
839 if (strstr(class_name, "/$Proxy") != nullptr ||
840 strstr(class_name, "MethodHandle$Species_") != nullptr) {
841 // ignore -- TODO: we should filter these out in classListWriter.cpp
842 } else {
843 constant_pool_resolution_warning("class %s is not (yet) loaded by one of the built-in loaders", class_name);
844 }
845 return;
846 }
847
848 if (dim > 0) {
849 ik->array_klass(dim, THREAD);
850 if (HAS_PENDING_EXCEPTION) {
851 error("Array klass allocation failed: %s %d", _class_name, dim);
852 }
853 }
854 }
855
856 void ClassListParser::parse_constant_pool_tag() {
857 if (parse_lambda_forms_invokers_only()) {
858 return;
859 }
860
861 JavaThread* THREAD = JavaThread::current();
862 skip_whitespaces();
863 char* class_name = _token;
864 skip_non_whitespaces();
865 *_token = '\0';
866 _token ++;
867
868 InstanceKlass* ik = find_builtin_class(THREAD, class_name);
869 if (ik == nullptr) {
870 _token = class_name;
871 if (strstr(class_name, "/$Proxy") != nullptr ||
872 strstr(class_name, "MethodHandle$Species_") != nullptr) {
873 // ignore -- TODO: we should filter these out in classListWriter.cpp
874 } else {
875 constant_pool_resolution_warning("class %s is not (yet) loaded by one of the built-in loaders", class_name);
876 }
877 return;
878 }
879
880 ResourceMark rm(THREAD);
881 constantPoolHandle cp(THREAD, ik->constants());
882 GrowableArray<bool> preresolve_list(cp->length(), cp->length(), false);
883 bool preresolve_class = false;
884 bool preresolve_fmi = false;
885 bool preresolve_indy = false;
886
887 while (*_token) {
888 int cp_index;
889 skip_whitespaces();
890 parse_uint(&cp_index);
891 if (cp_index < 1 || cp_index >= cp->length()) {
892 constant_pool_resolution_warning("Invalid constant pool index %d", cp_index);
893 return;
894 } else {
895 preresolve_list.at_put(cp_index, true);
896 }
897 constantTag cp_tag = cp->tag_at(cp_index);
898 switch (cp_tag.value()) {
899 case JVM_CONSTANT_UnresolvedClass:
900 preresolve_class = true;
901 break;
902 case JVM_CONSTANT_UnresolvedClassInError:
903 case JVM_CONSTANT_Class:
904 // ignore
905 break;
906 case JVM_CONSTANT_Fieldref:
907 case JVM_CONSTANT_Methodref:
908 case JVM_CONSTANT_InterfaceMethodref:
909 preresolve_fmi = true;
910 break;
911 case JVM_CONSTANT_InvokeDynamic:
912 preresolve_indy = true;
913 break;
914 default:
915 constant_pool_resolution_warning("Unsupported constant pool index %d: %s (type=%d)",
916 cp_index, cp_tag.internal_name(), cp_tag.value());
917 return;
918 }
919 }
920
921 if (preresolve_class) {
922 AOTConstantPoolResolver::preresolve_class_cp_entries(THREAD, ik, &preresolve_list);
923 }
924 if (preresolve_fmi) {
925 // FIXME: too coarse; doesn't cover resolution of Class entries
926 // JavaThread::NoJavaCodeMark no_java_code(THREAD); // ensure no clinits are exectued
927 AOTConstantPoolResolver::preresolve_field_and_method_cp_entries(THREAD, ik, &preresolve_list);
928 }
929 if (preresolve_indy) {
930 AOTConstantPoolResolver::preresolve_indy_cp_entries(THREAD, ik, &preresolve_list);
931 }
932 }
933
934 void ClassListParser::parse_class_reflection_data_tag() {
935 if (parse_lambda_forms_invokers_only()) {
936 return;
937 }
938
939 JavaThread* THREAD = JavaThread::current();
940 skip_whitespaces();
941 char* class_name = _token;
942 skip_non_whitespaces();
943 *_token = '\0';
944 _token ++;
945
946 InstanceKlass* ik = find_builtin_class(THREAD, class_name);
947 if (ik == nullptr) {
948 _token = class_name;
949 if (strstr(class_name, "/$Proxy") != nullptr ||
950 strstr(class_name, "MethodHandle$Species_") != nullptr) {
951 // ignore -- TODO: we should filter these out in classListWriter.cpp
952 } else {
953 warning("%s: class not found: %s", CLASS_REFLECTION_DATA_TAG, class_name);
954 }
955 return;
956 }
957
958 ResourceMark rm(THREAD);
959
960 int rd_flags = _unspecified;
961 while (*_token) {
962 skip_whitespaces();
963 if (rd_flags != _unspecified) {
964 error("rd_flags specified twice");
965 return;
966 }
967 parse_uint(&rd_flags);
968 }
969 if (rd_flags == _unspecified) {
970 error("no rd_flags specified");
971 return;
972 }
973
974 if (CDSConfig::is_dumping_reflection_data()) {
975 AOTConstantPoolResolver::generate_reflection_data(THREAD, ik, rd_flags);
976 }
977 }
978
979 oop ClassListParser::loader_from_type(const char* loader_type) {
980 oop loader;
981 if (!ArchiveUtils::builtin_loader_from_type(loader_type, &loader)) {
982 error("Unknown loader %s", loader_type);
983 }
984 return loader;
985 }
986
987 void ClassListParser::parse_dynamic_proxy_tag() {
988 if (parse_lambda_forms_invokers_only()) {
989 return;
990 }
991
992 skip_whitespaces();
993 char* loader_type = _token;
994 skip_non_whitespaces();
995 *_token = '\0';
996 _token ++;
997
998 skip_whitespaces();
999 char* proxy_name_str = _token;
1000 skip_non_whitespaces();
1001 *_token = '\0';
1002 _token ++;
1003
1004 skip_whitespaces();
1005 int access_flags;
1006 parse_uint(&access_flags);
1007
1008 skip_whitespaces();
1009 int num_intfs;
1010 parse_uint(&num_intfs);
1011
1012 JavaThread* THREAD = JavaThread::current();
1013 Handle loader(THREAD, loader_from_type(loader_type));
1014 Handle proxy_name(THREAD, java_lang_String::create_oop_from_str(proxy_name_str, THREAD));
1015 if (HAS_PENDING_EXCEPTION) {
1016 error("Out of memory");
1017 }
1018
1019 objArrayHandle interfaces(THREAD, oopFactory::new_objArray(vmClasses::Class_klass(), num_intfs, THREAD));
1020 if (HAS_PENDING_EXCEPTION) {
1021 error("Out of memory");
1022 }
1023
1024 for (int i = 0; i < num_intfs; i++) {
1025 skip_whitespaces();
1026 char* intf_name = _token;
1027 skip_non_whitespaces();
1028 *_token = '\0';
1029 _token ++;
1030
1031 InstanceKlass* ik = find_builtin_class(THREAD, intf_name);
1032 if (ik != nullptr) {
1033 interfaces()->obj_at_put(i, ik->java_mirror());
1034 } else {
1035 error("Unknown class %s", intf_name);
1036 }
1037 }
1038
1039 if (strncmp("jdk.proxy", proxy_name_str, 9) != 0) {
1040 return;
1041 }
1042
1043 AOTConstantPoolResolver::define_dynamic_proxy_class(loader, proxy_name, interfaces, access_flags, THREAD);
1044 if (HAS_PENDING_EXCEPTION) {
1045 PENDING_EXCEPTION->print_on(tty);
1046 error("defineProxyClassForCDS failed");
1047 }
1048 }
1049
1050 void ClassListParser::parse_loader_negative_cache_tag() {
1051 skip_whitespaces();
1052 char* loader_type = _token;
1053 skip_non_whitespaces();
1054 *_token = '\0';
1055 _token ++;
1056
1057 oop loader;
1058 Klass* loader_klass;
1059 if (!strcmp(loader_type, "app")) {
1060 loader = SystemDictionary::java_system_loader();
1061 loader_klass = vmClasses::jdk_internal_loader_ClassLoaders_AppClassLoader_klass();
1062 } else if (!strcmp(loader_type, "platform")) {
1063 loader = SystemDictionary::java_platform_loader();
1064 loader_klass = vmClasses::jdk_internal_loader_ClassLoaders_PlatformClassLoader_klass();
1065 } else {
1066 warning("%s: unrecognized loader type %s is ignored", LOADER_NEGATIVE_CACHE_TAG, loader_type);
1067 return;
1068 }
1069
1070 char* contents = _token;
1071 skip_non_whitespaces();
1072 *_token = '\0';
1073 _token ++;
1074
1075 if (ArchiveLoaderLookupCache) {
1076 TempNewSymbol method = SymbolTable::new_symbol("generateNegativeLookupCache");
1077 TempNewSymbol signature = SymbolTable::new_symbol("(Ljava/lang/String;)V");
1078
1079 EXCEPTION_MARK;
1080 HandleMark hm(THREAD);
1081 JavaCallArguments args(Handle(THREAD, loader));
1082 Handle contents_h = java_lang_String::create_from_str(contents, THREAD);
1083 args.push_oop(contents_h);
1084 JavaValue result(T_VOID);
1085 JavaCalls::call_virtual(&result,
1086 loader_klass,
1087 method,
1088 signature,
1089 &args, THREAD);
1090 if (HAS_PENDING_EXCEPTION) {
1091 Handle exc_handle(THREAD, PENDING_EXCEPTION);
1092 CLEAR_PENDING_EXCEPTION;
1093
1094 log_warning(cds)("Exception during BuiltinClassLoader::generateNegativeLookupCache() call for %s loader", loader_type);
1095 LogStreamHandle(Debug, cds) log;
1096 if (log.is_enabled()) {
1097 java_lang_Throwable::print_stack_trace(exc_handle, &log);
1098 }
1099 }
1100 }
1101 }
1102