Force some java.lang.invoke classes to be pre-initialized at dump time

Author: iklam

src/hotspot/share/cds/classPrelinker.cpp

@@ -834,6 +834,67 @@ void ClassPrelinker::record_resolved_indys() {
   log_info(cds)("%d indies in %d classes will be resolved in final CDS image", total_indys_to_resolve, tmp_klasses.length());
 }
 
+// Warning -- this is fragile!!!
+// This is a hard-coded list of classes that are safely to preinitialize at dump time. It needs
+// to be updated if the Java source code changes.
+class ForcePreinitClosure : public CLDClosure {
+public:
+  void do_cld(ClassLoaderData* cld) {
+    static const char* forced_preinit_classes[] = {
+      "java/util/HexFormat",
+      "jdk/internal/util/ClassFileDumper",
+      "java/lang/reflect/ClassFileFormatVersion",
+      "java/lang/Character$CharacterCache",
+      "java/lang/invoke/Invokers",
+      "java/lang/invoke/Invokers$Holder",
+      "java/lang/invoke/MethodHandle",
+      "java/lang/invoke/MethodHandleStatics",
+      "java/lang/invoke/DelegatingMethodHandle",
+      "java/lang/invoke/DelegatingMethodHandle$Holder",
+      "java/lang/invoke/LambdaForm",
+      "java/lang/invoke/LambdaForm$NamedFunction",
+      "java/lang/invoke/ClassSpecializer",
+      "java/lang/invoke/DirectMethodHandle",
+      "java/lang/invoke/DirectMethodHandle$Holder",
+      "java/lang/invoke/BoundMethodHandle$Specializer",
+      "java/lang/invoke/MethodHandles$Lookup",
+
+    // TODO -- need to clear internTable, etc
+    //"java/lang/invoke/MethodType",
+
+    // TODO -- these need to link to native code
+    //"java/lang/invoke/BoundMethodHandle",
+    //"java/lang/invoke/BoundMethodHandle$Holder",
+    //"java/lang/invoke/MemberName",
+    //"java/lang/invoke/MethodHandleNatives",
+      nullptr
+    };
+    for (Klass* k = cld->klasses(); k != nullptr; k = k->next_link()) {
+      if (k->is_instance_klass()) {
+        for (const char** classes = forced_preinit_classes; *classes != nullptr; classes++) {
+          const char* class_name = *classes;
+          if (k->name()->equals(class_name)) {
+            ResourceMark rm;
+            log_info(cds, init)("Force initialization %s", k->external_name());
+            SystemDictionaryShared::force_preinit(InstanceKlass::cast(k));
+          }
+        }
+      }
+    }
+  }
+};
+
+void ClassPrelinker::setup_forced_preinit_classes() {
+  if (!ArchiveInvokeDynamic) {
+    return;
+  }
+
+  // Collect all loaded ClassLoaderData.
+  ForcePreinitClosure closure;
+  MutexLocker lock(ClassLoaderDataGraph_lock);
+  ClassLoaderDataGraph::loaded_cld_do(&closure);
+}
+
 // Initialize a class at dump time, if possible.
 void ClassPrelinker::maybe_preinit_class(InstanceKlass* ik, TRAPS) {
   if (ik->is_initialized()) {

src/hotspot/share/cds/classPrelinker.hpp

@@ -113,6 +113,7 @@ class ClassPrelinker :  AllStatic {
   static void initialize();
   static void dispose();
 
+  static void setup_forced_preinit_classes();
   static void maybe_preinit_class(InstanceKlass* ik, TRAPS);
 
   static void preresolve_class_cp_entries(JavaThread* current, InstanceKlass* ik, GrowableArray<bool>* preresolve_list);

src/hotspot/share/cds/dumpTimeClassInfo.hpp

@@ -42,6 +42,7 @@ class DumpTimeClassInfo: public CHeapObj<mtClass> {
   bool                         _has_checked_exclusion;
   bool                         _can_be_preinited;
   bool                         _has_done_preinit_check;
+  bool                         _forced_preinit;
 
   class DTLoaderConstraint {
     Symbol* _name;
@@ -139,6 +140,7 @@ class DumpTimeClassInfo: public CHeapObj<mtClass> {
     _has_checked_exclusion = false;
     _can_be_preinited = false;
     _has_done_preinit_check = false;
+    _forced_preinit = false;
     _id = -1;
     _clsfile_size = -1;
     _clsfile_crc32 = -1;
@@ -216,6 +218,8 @@ class DumpTimeClassInfo: public CHeapObj<mtClass> {
   InstanceKlass* nest_host() const                  { return _nest_host; }
   void set_nest_host(InstanceKlass* nest_host)      { _nest_host = nest_host; }
 
+  void force_preinit()                              { _forced_preinit = true; }
+  bool is_forced_preinit() const                    { return _forced_preinit; }
   bool can_be_preinited() const                     { return _can_be_preinited; }
   bool has_done_preinit_check() const               { return _has_done_preinit_check; }
 

src/hotspot/share/cds/metaspaceShared.cpp

@@ -652,6 +652,8 @@ void MetaspaceShared::link_shared_classes(bool jcmd_request, TRAPS) {
     LambdaFormInvokers::regenerate_holder_classes(CHECK);
   }
 
+  ClassPrelinker::setup_forced_preinit_classes();
+
   // Collect all loaded ClassLoaderData.
   CollectCLDClosure collect_cld(THREAD);
   {

src/hotspot/share/classfile/systemDictionaryShared.cpp

@@ -1697,6 +1697,13 @@ void SystemDictionaryShared::reset_preinit_check() {
   _dumptime_table->iterate_all_live_classes(iterator);
 }
 
+// Called by ClassPrelinker before we get into VM_PopulateDumpSharedSpace
+void SystemDictionaryShared::force_preinit(InstanceKlass* ik) {
+  MutexLocker ml(DumpTimeTable_lock, Mutex::_no_safepoint_check_flag);
+  DumpTimeClassInfo* info = get_info_locked(ik);
+  info->force_preinit();
+}
+
 bool SystemDictionaryShared::can_be_preinited(InstanceKlass* ik) {
   if (!CDSConfig::is_initing_classes_at_dump_time()) {
     return false;
@@ -1705,7 +1712,7 @@ bool SystemDictionaryShared::can_be_preinited(InstanceKlass* ik) {
   assert_lock_strong(DumpTimeTable_lock);
   DumpTimeClassInfo* info = get_info_locked(ik);
   if (!info->has_done_preinit_check()) {
-    info->set_can_be_preinited(check_can_be_preinited(ik));
+    info->set_can_be_preinited(check_can_be_preinited(ik, info));
   }
   return info->can_be_preinited();
 }
@@ -1763,7 +1770,7 @@ bool SystemDictionaryShared::has_non_default_static_fields(InstanceKlass* ik) {
   return true;
 }
 
-bool SystemDictionaryShared::check_can_be_preinited(InstanceKlass* ik) {
+bool SystemDictionaryShared::check_can_be_preinited(InstanceKlass* ik, DumpTimeClassInfo* info) {
   ResourceMark rm;
 
   if (!is_builtin(ik)) {
@@ -1786,8 +1793,9 @@ bool SystemDictionaryShared::check_can_be_preinited(InstanceKlass* ik) {
     }
   }
 
-  if (!HeapShared::is_lambda_form_klass(ik)) {
-    // We allow only LambdaForm classes to have <clinit> and non-default static fields
+  if (HeapShared::is_lambda_form_klass(ik) || info->is_forced_preinit()) {
+    // We allow only these to have <clinit> and non-default static fields
+  } else {
     if (ik->class_initializer() != nullptr) {
       log_info(cds, init)("cannot initialize %s (has <clinit>)", ik->external_name());
       return false;

src/hotspot/share/classfile/systemDictionaryShared.hpp

@@ -210,7 +210,7 @@ class SystemDictionaryShared: public SystemDictionary {
   static void reset_registered_lambda_proxy_class(InstanceKlass* ik);
   static bool is_registered_lambda_proxy_class(InstanceKlass* ik);
   static bool check_for_exclusion_impl(InstanceKlass* k);
-  static bool check_can_be_preinited(InstanceKlass* ik);
+  static bool check_can_be_preinited(InstanceKlass* ik, DumpTimeClassInfo* info);
   static bool has_non_default_static_fields(InstanceKlass* ik);
   static void remove_dumptime_info(InstanceKlass* k) NOT_CDS_RETURN;
   static void init_archived_hidden_classes(Handle class_loader, Array<InstanceKlass*>* classes,
@@ -256,6 +256,7 @@ class SystemDictionaryShared: public SystemDictionary {
   static void init_dumptime_info(InstanceKlass* k) NOT_CDS_RETURN;
   static void handle_class_unloading(InstanceKlass* k) NOT_CDS_RETURN;
 
+  static void force_preinit(InstanceKlass* ik);
   static bool can_be_preinited(InstanceKlass* ik);
   static void reset_preinit_check();