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 }