1 /* 2 * Copyright (c) 2022, 2025, 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/aotClassLinker.hpp" 26 #include "cds/aotClassLocation.hpp" 27 #include "cds/aotConstantPoolResolver.hpp" 28 #include "cds/archiveBuilder.hpp" 29 #include "cds/archiveUtils.inline.hpp" 30 #include "cds/cdsConfig.hpp" 31 #include "cds/classListWriter.hpp" 32 #include "cds/finalImageRecipes.hpp" 33 #include "cds/heapShared.hpp" 34 #include "cds/lambdaFormInvokers.inline.hpp" 35 #include "classfile/classLoader.hpp" 36 #include "classfile/classLoaderExt.hpp" 37 #include "classfile/dictionary.hpp" 38 #include "classfile/symbolTable.hpp" 39 #include "classfile/systemDictionary.hpp" 40 #include "classfile/systemDictionaryShared.hpp" 41 #include "classfile/vmClasses.hpp" 42 #include "interpreter/bytecodeStream.hpp" 43 #include "interpreter/interpreterRuntime.hpp" 44 #include "memory/resourceArea.hpp" 45 #include "oops/constantPool.inline.hpp" 46 #include "oops/instanceKlass.hpp" 47 #include "oops/klass.inline.hpp" 48 #include "runtime/handles.inline.hpp" 49 #include "runtime/javaCalls.hpp" 50 51 AOTConstantPoolResolver::ClassesTable* AOTConstantPoolResolver::_processed_classes = nullptr; 52 53 void AOTConstantPoolResolver::initialize() { 54 assert(_processed_classes == nullptr, "must be"); 55 _processed_classes = new (mtClass)ClassesTable(); 56 } 57 58 void AOTConstantPoolResolver::dispose() { 59 assert(_processed_classes != nullptr, "must be"); 60 delete _processed_classes; 61 _processed_classes = nullptr; 62 } 63 64 // Returns true if we CAN PROVE that cp_index will always resolve to 65 // the same information at both dump time and run time. This is a 66 // necessary (but not sufficient) condition for pre-resolving cp_index 67 // during CDS archive assembly. 68 bool AOTConstantPoolResolver::is_resolution_deterministic(ConstantPool* cp, int cp_index) { 69 assert(!is_in_archivebuilder_buffer(cp), "sanity"); 70 71 if (cp->tag_at(cp_index).is_klass()) { 72 // We require cp_index to be already resolved. This is fine for now, are we 73 // currently archive only CP entries that are already resolved. 74 Klass* resolved_klass = cp->resolved_klass_at(cp_index); 75 return resolved_klass != nullptr && is_class_resolution_deterministic(cp->pool_holder(), resolved_klass); 76 } else if (cp->tag_at(cp_index).is_invoke_dynamic()) { 77 return is_indy_resolution_deterministic(cp, cp_index); 78 } else if (cp->tag_at(cp_index).is_field() || 79 cp->tag_at(cp_index).is_method() || 80 cp->tag_at(cp_index).is_interface_method()) { 81 int klass_cp_index = cp->uncached_klass_ref_index_at(cp_index); 82 if (!cp->tag_at(klass_cp_index).is_klass()) { 83 // Not yet resolved 84 return false; 85 } 86 Klass* k = cp->resolved_klass_at(klass_cp_index); 87 if (!is_class_resolution_deterministic(cp->pool_holder(), k)) { 88 return false; 89 } 90 91 if (!k->is_instance_klass()) { 92 // TODO: support non instance klasses as well. 93 return false; 94 } 95 96 // Here, We don't check if this entry can actually be resolved to a valid Field/Method. 97 // This method should be called by the ConstantPool to check Fields/Methods that 98 // have already been successfully resolved. 99 return true; 100 } else { 101 return false; 102 } 103 } 104 105 bool AOTConstantPoolResolver::is_class_resolution_deterministic(InstanceKlass* cp_holder, Klass* resolved_class) { 106 assert(!is_in_archivebuilder_buffer(cp_holder), "sanity"); 107 assert(!is_in_archivebuilder_buffer(resolved_class), "sanity"); 108 109 if (resolved_class->is_instance_klass()) { 110 InstanceKlass* ik = InstanceKlass::cast(resolved_class); 111 112 if (!ik->is_shared() && SystemDictionaryShared::is_excluded_class(ik)) { 113 return false; 114 } 115 116 if (cp_holder->is_subtype_of(ik)) { 117 // All super types of ik will be resolved in ik->class_loader() before 118 // ik is defined in this loader, so it's safe to archive the resolved klass reference. 119 return true; 120 } 121 122 if (CDSConfig::is_dumping_aot_linked_classes()) { 123 // Need to call try_add_candidate instead of is_candidate, as this may be called 124 // before AOTClassLinker::add_candidates(). 125 if (AOTClassLinker::try_add_candidate(ik)) { 126 return true; 127 } else { 128 return false; 129 } 130 } else if (AOTClassLinker::is_vm_class(ik)) { 131 if (ik->class_loader() != cp_holder->class_loader()) { 132 // At runtime, cp_holder() may not be able to resolve to the same 133 // ik. For example, a different version of ik may be defined in 134 // cp->pool_holder()'s loader using MethodHandles.Lookup.defineClass(). 135 return false; 136 } else { 137 return true; 138 } 139 } else { 140 return false; 141 } 142 } else if (resolved_class->is_objArray_klass()) { 143 Klass* elem = ObjArrayKlass::cast(resolved_class)->bottom_klass(); 144 if (elem->is_instance_klass()) { 145 return is_class_resolution_deterministic(cp_holder, InstanceKlass::cast(elem)); 146 } else if (elem->is_typeArray_klass()) { 147 return true; 148 } else { 149 return false; 150 } 151 } else if (resolved_class->is_typeArray_klass()) { 152 return true; 153 } else { 154 return false; 155 } 156 } 157 158 void AOTConstantPoolResolver::dumptime_resolve_constants(InstanceKlass* ik, TRAPS) { 159 if (!ik->is_linked()) { 160 return; 161 } 162 bool first_time; 163 _processed_classes->put_if_absent(ik, &first_time); 164 if (!first_time) { 165 // We have already resolved the constants in class, so no need to do it again. 166 return; 167 } 168 169 constantPoolHandle cp(THREAD, ik->constants()); 170 for (int cp_index = 1; cp_index < cp->length(); cp_index++) { // Index 0 is unused 171 switch (cp->tag_at(cp_index).value()) { 172 case JVM_CONSTANT_String: 173 resolve_string(cp, cp_index, CHECK); // may throw OOM when interning strings. 174 break; 175 } 176 } 177 178 // Normally, we don't want to archive any CP entries that were not resolved 179 // in the training run. Otherwise the AOT/JIT may inline too much code that has not 180 // been executed. 181 // 182 // However, we want to aggressively resolve all klass/field/method constants for 183 // LambdaForm Invoker Holder classes, Lambda Proxy classes, and LambdaForm classes, 184 // so that the compiler can inline through them. 185 if (SystemDictionaryShared::is_builtin_loader(ik->class_loader_data())) { 186 bool eager_resolve = false; 187 188 if (LambdaFormInvokers::may_be_regenerated_class(ik->name())) { 189 eager_resolve = true; 190 } 191 if (ik->is_hidden() && HeapShared::is_archivable_hidden_klass(ik)) { 192 eager_resolve = true; 193 } 194 195 if (eager_resolve) { 196 preresolve_class_cp_entries(THREAD, ik, nullptr); 197 preresolve_field_and_method_cp_entries(THREAD, ik, nullptr); 198 } 199 } 200 } 201 202 // This works only for the boot/platform/app loaders 203 Klass* AOTConstantPoolResolver::find_loaded_class(Thread* current, oop class_loader, Symbol* name) { 204 HandleMark hm(current); 205 Handle h_loader(current, class_loader); 206 Klass* k = SystemDictionary::find_instance_or_array_klass(current, name, h_loader); 207 if (k != nullptr) { 208 return k; 209 } 210 if (h_loader() == SystemDictionary::java_system_loader()) { 211 return find_loaded_class(current, SystemDictionary::java_platform_loader(), name); 212 } else if (h_loader() == SystemDictionary::java_platform_loader()) { 213 return find_loaded_class(current, nullptr, name); 214 } else { 215 assert(h_loader() == nullptr, "This function only works for boot/platform/app loaders %p %p %p", 216 cast_from_oop<address>(h_loader()), 217 cast_from_oop<address>(SystemDictionary::java_system_loader()), 218 cast_from_oop<address>(SystemDictionary::java_platform_loader())); 219 } 220 221 return nullptr; 222 } 223 224 Klass* AOTConstantPoolResolver::find_loaded_class(Thread* current, ConstantPool* cp, int class_cp_index) { 225 Symbol* name = cp->klass_name_at(class_cp_index); 226 return find_loaded_class(current, cp->pool_holder()->class_loader(), name); 227 } 228 229 #if INCLUDE_CDS_JAVA_HEAP 230 void AOTConstantPoolResolver::resolve_string(constantPoolHandle cp, int cp_index, TRAPS) { 231 if (CDSConfig::is_dumping_heap()) { 232 int cache_index = cp->cp_to_object_index(cp_index); 233 ConstantPool::string_at_impl(cp, cp_index, cache_index, CHECK); 234 } 235 } 236 #endif 237 238 void AOTConstantPoolResolver::preresolve_class_cp_entries(JavaThread* current, InstanceKlass* ik, GrowableArray<bool>* preresolve_list) { 239 if (!SystemDictionaryShared::is_builtin_loader(ik->class_loader_data())) { 240 return; 241 } 242 243 JavaThread* THREAD = current; 244 constantPoolHandle cp(THREAD, ik->constants()); 245 for (int cp_index = 1; cp_index < cp->length(); cp_index++) { 246 if (cp->tag_at(cp_index).value() == JVM_CONSTANT_UnresolvedClass) { 247 if (preresolve_list != nullptr && preresolve_list->at(cp_index) == false) { 248 // This class was not resolved during trial run. Don't attempt to resolve it. Otherwise 249 // the compiler may generate less efficient code. 250 continue; 251 } 252 if (find_loaded_class(current, cp(), cp_index) == nullptr) { 253 // Do not resolve any class that has not been loaded yet 254 continue; 255 } 256 Klass* resolved_klass = cp->klass_at(cp_index, THREAD); 257 if (HAS_PENDING_EXCEPTION) { 258 CLEAR_PENDING_EXCEPTION; // just ignore 259 } else { 260 log_trace(cds, resolve)("Resolved class [%3d] %s -> %s", cp_index, ik->external_name(), 261 resolved_klass->external_name()); 262 } 263 } 264 } 265 } 266 267 void AOTConstantPoolResolver::preresolve_field_and_method_cp_entries(JavaThread* current, InstanceKlass* ik, GrowableArray<bool>* preresolve_list) { 268 JavaThread* THREAD = current; 269 constantPoolHandle cp(THREAD, ik->constants()); 270 if (cp->cache() == nullptr) { 271 return; 272 } 273 for (int i = 0; i < ik->methods()->length(); i++) { 274 Method* m = ik->methods()->at(i); 275 BytecodeStream bcs(methodHandle(THREAD, m)); 276 while (!bcs.is_last_bytecode()) { 277 bcs.next(); 278 Bytecodes::Code raw_bc = bcs.raw_code(); 279 switch (raw_bc) { 280 case Bytecodes::_getstatic: 281 case Bytecodes::_putstatic: 282 case Bytecodes::_getfield: 283 case Bytecodes::_putfield: 284 maybe_resolve_fmi_ref(ik, m, raw_bc, bcs.get_index_u2(), preresolve_list, THREAD); 285 if (HAS_PENDING_EXCEPTION) { 286 CLEAR_PENDING_EXCEPTION; // just ignore 287 } 288 break; 289 case Bytecodes::_invokehandle: 290 case Bytecodes::_invokespecial: 291 case Bytecodes::_invokevirtual: 292 case Bytecodes::_invokeinterface: 293 case Bytecodes::_invokestatic: 294 maybe_resolve_fmi_ref(ik, m, raw_bc, bcs.get_index_u2(), preresolve_list, THREAD); 295 if (HAS_PENDING_EXCEPTION) { 296 CLEAR_PENDING_EXCEPTION; // just ignore 297 } 298 break; 299 default: 300 break; 301 } 302 } 303 } 304 } 305 306 void AOTConstantPoolResolver::maybe_resolve_fmi_ref(InstanceKlass* ik, Method* m, Bytecodes::Code bc, int raw_index, 307 GrowableArray<bool>* preresolve_list, TRAPS) { 308 methodHandle mh(THREAD, m); 309 constantPoolHandle cp(THREAD, ik->constants()); 310 HandleMark hm(THREAD); 311 int cp_index = cp->to_cp_index(raw_index, bc); 312 313 if (cp->is_resolved(raw_index, bc)) { 314 return; 315 } 316 317 if (preresolve_list != nullptr && preresolve_list->at(cp_index) == false) { 318 // This field wasn't resolved during the trial run. Don't attempt to resolve it. Otherwise 319 // the compiler may generate less efficient code. 320 return; 321 } 322 323 int klass_cp_index = cp->uncached_klass_ref_index_at(cp_index); 324 if (find_loaded_class(THREAD, cp(), klass_cp_index) == nullptr) { 325 // Do not resolve any field/methods from a class that has not been loaded yet. 326 return; 327 } 328 329 Klass* resolved_klass = cp->klass_ref_at(raw_index, bc, CHECK); 330 const char* is_static = ""; 331 332 switch (bc) { 333 case Bytecodes::_getstatic: 334 case Bytecodes::_putstatic: 335 if (!VM_Version::supports_fast_class_init_checks()) { 336 return; // Do not resolve since interpreter lacks fast clinit barriers support 337 } 338 InterpreterRuntime::resolve_get_put(bc, raw_index, mh, cp, false /*initialize_holder*/, CHECK); 339 is_static = " *** static"; 340 break; 341 case Bytecodes::_getfield: 342 case Bytecodes::_putfield: 343 InterpreterRuntime::resolve_get_put(bc, raw_index, mh, cp, false /*initialize_holder*/, CHECK); 344 break; 345 346 case Bytecodes::_invokestatic: 347 if (!VM_Version::supports_fast_class_init_checks()) { 348 return; // Do not resolve since interpreter lacks fast clinit barriers support 349 } 350 InterpreterRuntime::cds_resolve_invoke(bc, raw_index, cp, CHECK); 351 is_static = " *** static"; 352 break; 353 354 case Bytecodes::_invokevirtual: 355 case Bytecodes::_invokespecial: 356 case Bytecodes::_invokeinterface: 357 InterpreterRuntime::cds_resolve_invoke(bc, raw_index, cp, CHECK); 358 break; 359 360 case Bytecodes::_invokehandle: 361 InterpreterRuntime::cds_resolve_invokehandle(raw_index, cp, CHECK); 362 break; 363 364 default: 365 ShouldNotReachHere(); 366 } 367 368 if (log_is_enabled(Trace, cds, resolve)) { 369 ResourceMark rm(THREAD); 370 bool resolved = cp->is_resolved(raw_index, bc); 371 Symbol* name = cp->name_ref_at(raw_index, bc); 372 Symbol* signature = cp->signature_ref_at(raw_index, bc); 373 log_trace(cds, resolve)("%s %s [%3d] %s -> %s.%s:%s%s", 374 (resolved ? "Resolved" : "Failed to resolve"), 375 Bytecodes::name(bc), cp_index, ik->external_name(), 376 resolved_klass->external_name(), 377 name->as_C_string(), signature->as_C_string(), is_static); 378 } 379 } 380 381 void AOTConstantPoolResolver::preresolve_indy_cp_entries(JavaThread* current, InstanceKlass* ik, GrowableArray<bool>* preresolve_list) { 382 JavaThread* THREAD = current; 383 constantPoolHandle cp(THREAD, ik->constants()); 384 if (!CDSConfig::is_dumping_invokedynamic() || cp->cache() == nullptr) { 385 return; 386 } 387 388 assert(preresolve_list != nullptr, "preresolve_indy_cp_entries() should not be called for " 389 "regenerated LambdaForm Invoker classes, which should not have indys anyway."); 390 391 Array<ResolvedIndyEntry>* indy_entries = cp->cache()->resolved_indy_entries(); 392 for (int i = 0; i < indy_entries->length(); i++) { 393 ResolvedIndyEntry* rie = indy_entries->adr_at(i); 394 int cp_index = rie->constant_pool_index(); 395 if (preresolve_list->at(cp_index) == true) { 396 if (!rie->is_resolved() && is_indy_resolution_deterministic(cp(), cp_index)) { 397 InterpreterRuntime::cds_resolve_invokedynamic(i, cp, THREAD); 398 if (HAS_PENDING_EXCEPTION) { 399 CLEAR_PENDING_EXCEPTION; // just ignore 400 } 401 } 402 if (log_is_enabled(Trace, cds, resolve)) { 403 ResourceMark rm(THREAD); 404 log_trace(cds, resolve)("%s indy [%3d] %s", 405 rie->is_resolved() ? "Resolved" : "Failed to resolve", 406 cp_index, ik->external_name()); 407 } 408 } 409 } 410 } 411 412 // Check the MethodType signatures used by parameters to the indy BSMs. Make sure we don't 413 // use types that have been excluded, or else we might end up creating MethodTypes that cannot be stored 414 // in the AOT cache. 415 bool AOTConstantPoolResolver::check_methodtype_signature(ConstantPool* cp, Symbol* sig, Klass** return_type_ret) { 416 ResourceMark rm; 417 for (SignatureStream ss(sig); !ss.is_done(); ss.next()) { 418 if (ss.is_reference()) { 419 Symbol* type = ss.as_symbol(); 420 Klass* k = find_loaded_class(Thread::current(), cp->pool_holder()->class_loader(), type); 421 if (k == nullptr) { 422 return false; 423 } 424 425 if (SystemDictionaryShared::should_be_excluded(k)) { 426 if (log_is_enabled(Warning, cds, resolve)) { 427 ResourceMark rm; 428 log_warning(cds, resolve)("Cannot aot-resolve Lambda proxy because %s is excluded", k->external_name()); 429 } 430 return false; 431 } 432 433 if (ss.at_return_type() && return_type_ret != nullptr) { 434 *return_type_ret = k; 435 } 436 } 437 } 438 return true; 439 } 440 441 bool AOTConstantPoolResolver::check_lambda_metafactory_signature(ConstantPool* cp, Symbol* sig) { 442 Klass* k; 443 if (!check_methodtype_signature(cp, sig, &k)) { 444 return false; 445 } 446 447 // <k> is the interface type implemented by the lambda proxy 448 if (!k->is_interface()) { 449 // cp->pool_holder() doesn't look like a valid class generated by javac 450 return false; 451 } 452 453 454 // The linked lambda callsite has an instance of the interface implemented by this lambda. If this 455 // interface requires its <clinit> to be executed, then we must delay the execution to the production run 456 // as <clinit> can have side effects ==> exclude such cases. 457 InstanceKlass* intf = InstanceKlass::cast(k); 458 bool exclude = intf->interface_needs_clinit_execution_as_super(); 459 if (log_is_enabled(Debug, cds, resolve)) { 460 ResourceMark rm; 461 log_debug(cds, resolve)("%s aot-resolve Lambda proxy of interface type %s", 462 exclude ? "Cannot" : "Can", k->external_name()); 463 } 464 return !exclude; 465 } 466 467 bool AOTConstantPoolResolver::check_lambda_metafactory_methodtype_arg(ConstantPool* cp, int bsms_attribute_index, int arg_i) { 468 int mt_index = cp->operand_argument_index_at(bsms_attribute_index, arg_i); 469 if (!cp->tag_at(mt_index).is_method_type()) { 470 // malformed class? 471 return false; 472 } 473 474 Symbol* sig = cp->method_type_signature_at(mt_index); 475 if (log_is_enabled(Debug, cds, resolve)) { 476 ResourceMark rm; 477 log_debug(cds, resolve)("Checking MethodType for LambdaMetafactory BSM arg %d: %s", arg_i, sig->as_C_string()); 478 } 479 480 return check_methodtype_signature(cp, sig); 481 } 482 483 bool AOTConstantPoolResolver::check_lambda_metafactory_methodhandle_arg(ConstantPool* cp, int bsms_attribute_index, int arg_i) { 484 int mh_index = cp->operand_argument_index_at(bsms_attribute_index, arg_i); 485 if (!cp->tag_at(mh_index).is_method_handle()) { 486 // malformed class? 487 return false; 488 } 489 490 Symbol* sig = cp->method_handle_signature_ref_at(mh_index); 491 if (log_is_enabled(Debug, cds, resolve)) { 492 ResourceMark rm; 493 log_debug(cds, resolve)("Checking MethodType of MethodHandle for LambdaMetafactory BSM arg %d: %s", arg_i, sig->as_C_string()); 494 } 495 return check_methodtype_signature(cp, sig); 496 } 497 498 bool AOTConstantPoolResolver::is_indy_resolution_deterministic(ConstantPool* cp, int cp_index) { 499 assert(cp->tag_at(cp_index).is_invoke_dynamic(), "sanity"); 500 if (!CDSConfig::is_dumping_invokedynamic()) { 501 return false; 502 } 503 504 InstanceKlass* pool_holder = cp->pool_holder(); 505 if (!SystemDictionaryShared::is_builtin(pool_holder)) { 506 return false; 507 } 508 509 int bsm = cp->bootstrap_method_ref_index_at(cp_index); 510 int bsm_ref = cp->method_handle_index_at(bsm); 511 Symbol* bsm_name = cp->uncached_name_ref_at(bsm_ref); 512 Symbol* bsm_signature = cp->uncached_signature_ref_at(bsm_ref); 513 Symbol* bsm_klass = cp->klass_name_at(cp->uncached_klass_ref_index_at(bsm_ref)); 514 515 // We currently support only StringConcatFactory::makeConcatWithConstants() and LambdaMetafactory::metafactory() 516 // We should mark the allowed BSMs in the JDK code using a private annotation. 517 // See notes on RFE JDK-8342481. 518 519 if (bsm_klass->equals("java/lang/invoke/StringConcatFactory") && 520 bsm_name->equals("makeConcatWithConstants") && 521 bsm_signature->equals("(Ljava/lang/invoke/MethodHandles$Lookup;" 522 "Ljava/lang/String;" 523 "Ljava/lang/invoke/MethodType;" 524 "Ljava/lang/String;" 525 "[Ljava/lang/Object;" 526 ")Ljava/lang/invoke/CallSite;")) { 527 Symbol* factory_type_sig = cp->uncached_signature_ref_at(cp_index); 528 if (log_is_enabled(Debug, cds, resolve)) { 529 ResourceMark rm; 530 log_debug(cds, resolve)("Checking StringConcatFactory callsite signature [%d]: %s", cp_index, factory_type_sig->as_C_string()); 531 } 532 533 Klass* k; 534 if (!check_methodtype_signature(cp, factory_type_sig, &k)) { 535 return false; 536 } 537 if (k != vmClasses::String_klass()) { 538 // bad class file? 539 return false; 540 } 541 542 return true; 543 } 544 545 if (bsm_klass->equals("java/lang/invoke/LambdaMetafactory") && 546 bsm_name->equals("metafactory") && 547 bsm_signature->equals("(Ljava/lang/invoke/MethodHandles$Lookup;" 548 "Ljava/lang/String;" 549 "Ljava/lang/invoke/MethodType;" 550 "Ljava/lang/invoke/MethodType;" 551 "Ljava/lang/invoke/MethodHandle;" 552 "Ljava/lang/invoke/MethodType;" 553 ")Ljava/lang/invoke/CallSite;")) { 554 /* 555 * An indy callsite is associated with the following MethodType and MethodHandles: 556 * 557 * https://github.com/openjdk/jdk/blob/580eb62dc097efeb51c76b095c1404106859b673/src/java.base/share/classes/java/lang/invoke/LambdaMetafactory.java#L293-L309 558 * 559 * MethodType factoryType The expected signature of the {@code CallSite}. The 560 * parameter types represent the types of capture variables; 561 * the return type is the interface to implement. When 562 * used with {@code invokedynamic}, this is provided by 563 * the {@code NameAndType} of the {@code InvokeDynamic} 564 * 565 * MethodType interfaceMethodType Signature and return type of method to be 566 * implemented by the function object. 567 * 568 * MethodHandle implementation A direct method handle describing the implementation 569 * method which should be called (with suitable adaptation 570 * of argument types and return types, and with captured 571 * arguments prepended to the invocation arguments) at 572 * invocation time. 573 * 574 * MethodType dynamicMethodType The signature and return type that should 575 * be enforced dynamically at invocation time. 576 * In simple use cases this is the same as 577 * {@code interfaceMethodType}. 578 */ 579 Symbol* factory_type_sig = cp->uncached_signature_ref_at(cp_index); 580 if (log_is_enabled(Debug, cds, resolve)) { 581 ResourceMark rm; 582 log_debug(cds, resolve)("Checking indy callsite signature [%d]: %s", cp_index, factory_type_sig->as_C_string()); 583 } 584 585 if (!check_lambda_metafactory_signature(cp, factory_type_sig)) { 586 return false; 587 } 588 589 int bsms_attribute_index = cp->bootstrap_methods_attribute_index(cp_index); 590 int arg_count = cp->operand_argument_count_at(bsms_attribute_index); 591 if (arg_count != 3) { 592 // Malformed class? 593 return false; 594 } 595 596 // interfaceMethodType 597 if (!check_lambda_metafactory_methodtype_arg(cp, bsms_attribute_index, 0)) { 598 return false; 599 } 600 601 // implementation 602 if (!check_lambda_metafactory_methodhandle_arg(cp, bsms_attribute_index, 1)) { 603 return false; 604 } 605 606 // dynamicMethodType 607 if (!check_lambda_metafactory_methodtype_arg(cp, bsms_attribute_index, 2)) { 608 return false; 609 } 610 611 return true; 612 } 613 614 return false; 615 } 616 #ifdef ASSERT 617 bool AOTConstantPoolResolver::is_in_archivebuilder_buffer(address p) { 618 if (!Thread::current()->is_VM_thread() || ArchiveBuilder::current() == nullptr) { 619 return false; 620 } else { 621 return ArchiveBuilder::current()->is_in_buffer_space(p); 622 } 623 } 624 #endif 625 626 int AOTConstantPoolResolver::class_reflection_data_flags(InstanceKlass* ik, TRAPS) { 627 assert(java_lang_Class::has_reflection_data(ik->java_mirror()), "must be"); 628 629 HandleMark hm(THREAD); 630 JavaCallArguments args(Handle(THREAD, ik->java_mirror())); 631 JavaValue result(T_INT); 632 JavaCalls::call_special(&result, 633 vmClasses::Class_klass(), 634 vmSymbols::encodeReflectionData_name(), 635 vmSymbols::void_int_signature(), 636 &args, CHECK_0); 637 int flags = result.get_jint(); 638 log_info(cds)("Encode ReflectionData: %s (flags=0x%x)", ik->external_name(), flags); 639 return flags; 640 } 641 642 void AOTConstantPoolResolver::generate_reflection_data(JavaThread* current, InstanceKlass* ik, int rd_flags) { 643 log_info(cds)("Generate ReflectionData: %s (flags=" INT32_FORMAT_X ")", ik->external_name(), rd_flags); 644 JavaThread* THREAD = current; // for exception macros 645 JavaCallArguments args(Handle(THREAD, ik->java_mirror())); 646 args.push_int(rd_flags); 647 JavaValue result(T_OBJECT); 648 JavaCalls::call_special(&result, 649 vmClasses::Class_klass(), 650 vmSymbols::generateReflectionData_name(), 651 vmSymbols::int_void_signature(), 652 &args, THREAD); 653 if (HAS_PENDING_EXCEPTION) { 654 Handle exc_handle(THREAD, PENDING_EXCEPTION); 655 CLEAR_PENDING_EXCEPTION; 656 657 log_warning(cds)("Exception during Class::generateReflectionData() call for %s", ik->external_name()); 658 LogStreamHandle(Debug, cds) log; 659 if (log.is_enabled()) { 660 java_lang_Throwable::print_stack_trace(exc_handle, &log); 661 } 662 } 663 } 664 665 Klass* AOTConstantPoolResolver::resolve_boot_class_or_fail(const char* class_name, TRAPS) { 666 Handle class_loader; 667 TempNewSymbol class_name_sym = SymbolTable::new_symbol(class_name); 668 return SystemDictionary::resolve_or_fail(class_name_sym, class_loader, true, THREAD); 669 } 670 671 void AOTConstantPoolResolver::trace_dynamic_proxy_class(oop loader, const char* proxy_name, objArrayOop interfaces, int access_flags) { 672 if (interfaces->length() < 1) { 673 return; 674 } 675 if (ClassListWriter::is_enabled()) { 676 const char* loader_name = ArchiveUtils::builtin_loader_name_or_null(loader); 677 if (loader_name != nullptr) { 678 stringStream ss; 679 ss.print("%s %s %d %d", loader_name, proxy_name, access_flags, interfaces->length()); 680 for (int i = 0; i < interfaces->length(); i++) { 681 oop mirror = interfaces->obj_at(i); 682 Klass* k = java_lang_Class::as_Klass(mirror); 683 ss.print(" %s", k->name()->as_C_string()); 684 } 685 ClassListWriter w; 686 w.stream()->print_cr("@dynamic-proxy %s", ss.freeze()); 687 } 688 } 689 if (CDSConfig::is_dumping_preimage_static_archive()) { 690 FinalImageRecipes::add_dynamic_proxy_class(loader, proxy_name, interfaces, access_flags); 691 } 692 } 693 694 void AOTConstantPoolResolver::init_dynamic_proxy_cache(TRAPS) { 695 static bool inited = false; 696 if (inited) { 697 return; 698 } 699 inited = true; 700 701 Klass* klass = resolve_boot_class_or_fail("java/lang/reflect/Proxy", CHECK); 702 TempNewSymbol method = SymbolTable::new_symbol("initCacheForCDS"); 703 TempNewSymbol signature = SymbolTable::new_symbol("(Ljava/lang/ClassLoader;Ljava/lang/ClassLoader;)V"); 704 705 JavaCallArguments args; 706 args.push_oop(Handle(THREAD, SystemDictionary::java_platform_loader())); 707 args.push_oop(Handle(THREAD, SystemDictionary::java_system_loader())); 708 JavaValue result(T_VOID); 709 JavaCalls::call_static(&result, 710 klass, 711 method, 712 signature, 713 &args, CHECK); 714 } 715 716 717 void AOTConstantPoolResolver::define_dynamic_proxy_class(Handle loader, Handle proxy_name, Handle interfaces, int access_flags, TRAPS) { 718 if (!CDSConfig::is_dumping_dynamic_proxies()) { 719 return; 720 } 721 init_dynamic_proxy_cache(CHECK); 722 723 Klass* klass = resolve_boot_class_or_fail("java/lang/reflect/Proxy$ProxyBuilder", CHECK); 724 TempNewSymbol method = SymbolTable::new_symbol("defineProxyClassForCDS"); 725 TempNewSymbol signature = SymbolTable::new_symbol("(Ljava/lang/ClassLoader;Ljava/lang/String;[Ljava/lang/Class;I)Ljava/lang/Class;"); 726 727 JavaCallArguments args; 728 args.push_oop(Handle(THREAD, loader())); 729 args.push_oop(Handle(THREAD, proxy_name())); 730 args.push_oop(Handle(THREAD, interfaces())); 731 args.push_int(access_flags); 732 JavaValue result(T_OBJECT); 733 JavaCalls::call_static(&result, 734 klass, 735 method, 736 signature, 737 &args, CHECK); 738 739 // Assumptions: 740 // FMG is archived, which means -modulepath and -Xbootclasspath are both not specified. 741 // All named modules are loaded from the system modules files. 742 // TODO: test support for -Xbootclasspath after JDK-8322322. Some of the code below need to be changed. 743 // TODO: we just give dummy shared_classpath_index for the generated class so that it will be archived. 744 // The index is not used at runtime (see SystemDictionaryShared::load_shared_class_for_builtin_loader, which 745 // uses a null ProtectionDomain for this class) 746 oop mirror = result.get_oop(); 747 assert(mirror != nullptr, "class must have been generated if not OOM"); 748 InstanceKlass* ik = InstanceKlass::cast(java_lang_Class::as_Klass(mirror)); 749 if (ik->is_shared_boot_class() || ik->is_shared_platform_class()) { 750 assert(ik->module()->is_named(), "dynamic proxies defined in unnamed modules for boot/platform loaders not supported"); 751 ik->set_shared_classpath_index(0); 752 } else { 753 assert(ik->is_shared_app_class(), "must be"); 754 ik->set_shared_classpath_index(AOTClassLocationConfig::dumptime()->app_cp_start_index()); 755 } 756 757 ArchiveBuilder::alloc_stats()->record_dynamic_proxy_class(); 758 if (log_is_enabled(Info, cds, dynamic, proxy)) { 759 ResourceMark rm(THREAD); 760 stringStream ss; 761 const char* prefix = ""; 762 ss.print("%s (%-7s, cp index = %d) implements ", ik->external_name(), 763 ArchiveUtils::builtin_loader_name(loader()), ik->shared_classpath_index()); 764 objArrayOop intfs = (objArrayOop)interfaces(); 765 for (int i = 0; i < intfs->length(); i++) { 766 oop intf_mirror = intfs->obj_at(i); 767 ss.print("%s%s", prefix, java_lang_Class::as_Klass(intf_mirror)->external_name()); 768 prefix = ", "; 769 } 770 771 log_info(cds, dynamic, proxy)("%s", ss.freeze()); 772 } 773 }