8306582: Remove MetaspaceShared::exit_after_static_dump()

src/hotspot/share/cds/archiveBuilder.cpp

@@ -261,7 +261,8 @@ void ArchiveBuilder::gather_klasses_and_symbols() {
     // TODO: in the future, if we want to produce deterministic contents in the
     // dynamic archive, we might need to sort the symbols alphabetically (also see
     // DynamicArchiveBuilder::sort_methods()).
-    sort_symbols_and_fix_hash();
+    log_info(cds)("Sorting symbols ... ");
+    _symbols->sort(compare_symbols_by_address);
     sort_klasses();
 
     // TODO -- we need a proper estimate for the archived modules, etc,
@@ -279,16 +280,6 @@ int ArchiveBuilder::compare_symbols_by_address(Symbol** a, Symbol** b) {
   }
 }
 
-void ArchiveBuilder::sort_symbols_and_fix_hash() {
-  log_info(cds)("Sorting symbols and fixing identity hash ... ");
-  os::init_random(0x12345678);
-  _symbols->sort(compare_symbols_by_address);
-  for (int i = 0; i < _symbols->length(); i++) {
-    assert(_symbols->at(i)->is_permanent(), "archived symbols must be permanent");
-    _symbols->at(i)->update_identity_hash();
-  }
-}
-
 int ArchiveBuilder::compare_klass_by_name(Klass** a, Klass** b) {
   return a[0]->name()->fast_compare(b[0]->name());
 }
@@ -645,6 +636,14 @@ void ArchiveBuilder::make_shallow_copy(DumpRegion *dump_region, SourceObjInfo* s
   newtop = dump_region->top();
 
   memcpy(dest, src, bytes);
+
+  // Update the hash of buffered sorted symbols for static dump so that the symbols have deterministic contents
+  if (DumpSharedSpaces && (src_info->msotype() == MetaspaceObj::SymbolType)) {
+    Symbol* buffered_symbol = (Symbol*)dest;
+    assert(((Symbol*)src)->is_permanent(), "archived symbols must be permanent");
+    buffered_symbol->update_identity_hash();
+  }
+
   {
     bool created;
     _buffered_to_src_table.put_if_absent((address)dest, src, &created);

src/hotspot/share/cds/archiveBuilder.hpp

@@ -241,7 +241,6 @@ class ArchiveBuilder : public StackObj {
   FollowMode get_follow_mode(MetaspaceClosure::Ref *ref);
 
   void iterate_sorted_roots(MetaspaceClosure* it);
-  void sort_symbols_and_fix_hash();
   void sort_klasses();
   static int compare_symbols_by_address(Symbol** a, Symbol** b);
   static int compare_klass_by_name(Klass** a, Klass** b);

src/hotspot/share/cds/heapShared.cpp

@@ -133,7 +133,10 @@ KlassSubGraphInfo* HeapShared::_default_subgraph_info;
 GrowableArrayCHeap<oop, mtClassShared>* HeapShared::_pending_roots = nullptr;
 OopHandle HeapShared::_roots;
 OopHandle HeapShared::_scratch_basic_type_mirrors[T_VOID+1];
-KlassToOopHandleTable* HeapShared::_scratch_java_mirror_table = nullptr;
+MetaspaceObjToOopHandleTable* HeapShared::_scratch_java_mirror_table = nullptr;
+MetaspaceObjToOopHandleTable* HeapShared::_scratch_references_table = nullptr;
+ClassLoaderData* HeapShared::_saved_java_platform_loader_data = nullptr;
+ClassLoaderData* HeapShared::_saved_java_system_loader_data = nullptr;
 
 static bool is_subgraph_root_class_of(ArchivableStaticFieldInfo fields[], InstanceKlass* ik) {
   for (int i = 0; fields[i].valid(); i++) {
@@ -298,47 +301,66 @@ bool HeapShared::archive_object(oop obj) {
       }
       java_lang_Module::set_module_entry(obj, nullptr);
     } else if (java_lang_ClassLoader::is_instance(obj)) {
-      // class_data will be restored explicitly at run time.
+      // class_data will be restored explicitly at run time and after dumptime
       guarantee(obj == SystemDictionary::java_platform_loader() ||
                 obj == SystemDictionary::java_system_loader() ||
                 java_lang_ClassLoader::loader_data(obj) == nullptr, "must be");
+      if (obj == SystemDictionary::java_platform_loader()) {
+        _saved_java_platform_loader_data = java_lang_ClassLoader::loader_data_acquire(SystemDictionary::java_platform_loader());
+      } else if (obj == SystemDictionary::java_system_loader()) {
+        _saved_java_system_loader_data = java_lang_ClassLoader::loader_data_acquire(SystemDictionary::java_system_loader());
+      }
       java_lang_ClassLoader::release_set_loader_data(obj, nullptr);
     }
 
     return true;
   }
 }
 
-class KlassToOopHandleTable: public ResourceHashtable<Klass*, OopHandle,
+void HeapShared::restore_loader_data() {
+  log_info(cds)("Restoring java platform and system loaders");
+  java_lang_ClassLoader::release_set_loader_data(SystemDictionary::java_platform_loader(), _saved_java_platform_loader_data);
+  java_lang_ClassLoader::release_set_loader_data(SystemDictionary::java_system_loader(), _saved_java_system_loader_data);
+}
+
+class MetaspaceObjToOopHandleTable: public ResourceHashtable<MetaspaceObj*, OopHandle,
     36137, // prime number
     AnyObj::C_HEAP,
     mtClassShared> {
 public:
-  oop get_oop(Klass* k) {
+  oop get_oop(MetaspaceObj* ptr) {
     MutexLocker ml(ScratchObjects_lock, Mutex::_no_safepoint_check_flag);
-    OopHandle* handle = get(k);
+    OopHandle* handle = get(ptr);
     if (handle != nullptr) {
       return handle->resolve();
     } else {
       return nullptr;
     }
   }
-  void set_oop(Klass* k, oop o) {
+  void set_oop(MetaspaceObj* ptr, oop o) {
     MutexLocker ml(ScratchObjects_lock, Mutex::_no_safepoint_check_flag);
     OopHandle handle(Universe::vm_global(), o);
-    bool is_new = put(k, handle);
+    bool is_new = put(ptr, handle);
     assert(is_new, "cannot set twice");
   }
-  void remove_oop(Klass* k) {
+  void remove_oop(MetaspaceObj* ptr) {
     MutexLocker ml(ScratchObjects_lock, Mutex::_no_safepoint_check_flag);
-    OopHandle* handle = get(k);
+    OopHandle* handle = get(ptr);
     if (handle != nullptr) {
       handle->release(Universe::vm_global());
-      remove(k);
+      remove(ptr);
     }
   }
 };
 
+void HeapShared::add_scratch_resolved_references(ConstantPool* src, objArrayOop dest) {
+  _scratch_references_table->set_oop(src, dest);
+}
+
+objArrayOop HeapShared::scratch_resolved_references(ConstantPool* src) {
+  return (objArrayOop)_scratch_references_table->get_oop(src);
+}
+
 void HeapShared::init_scratch_objects(TRAPS) {
   for (int i = T_BOOLEAN; i < T_VOID+1; i++) {
     BasicType bt = (BasicType)i;
@@ -347,7 +369,8 @@ void HeapShared::init_scratch_objects(TRAPS) {
       _scratch_basic_type_mirrors[i] = OopHandle(Universe::vm_global(), m);
     }
   }
-  _scratch_java_mirror_table = new (mtClass)KlassToOopHandleTable();
+  _scratch_java_mirror_table = new (mtClass)MetaspaceObjToOopHandleTable();
+  _scratch_references_table = new (mtClass)MetaspaceObjToOopHandleTable();
 }
 
 oop HeapShared::scratch_java_mirror(BasicType t) {
@@ -366,6 +389,9 @@ void HeapShared::set_scratch_java_mirror(Klass* k, oop mirror) {
 
 void HeapShared::remove_scratch_objects(Klass* k) {
   _scratch_java_mirror_table->remove_oop(k);
+  if (k->is_instance_klass()) {
+    _scratch_references_table->remove(InstanceKlass::cast(k)->constants());
+  }
 }
 
 void HeapShared::archive_java_mirrors() {

src/hotspot/share/cds/heapShared.hpp

@@ -43,7 +43,7 @@
 class DumpedInternedStrings;
 class FileMapInfo;
 class KlassSubGraphInfo;
-class KlassToOopHandleTable;
+class MetaspaceObjToOopHandleTable;
 class ResourceBitMap;
 
 struct ArchivableStaticFieldInfo;
@@ -280,7 +280,11 @@ class HeapShared: AllStatic {
   static GrowableArrayCHeap<oop, mtClassShared>* _pending_roots;
   static OopHandle _roots;
   static OopHandle _scratch_basic_type_mirrors[T_VOID+1];
-  static KlassToOopHandleTable* _scratch_java_mirror_table;
+  static MetaspaceObjToOopHandleTable* _scratch_java_mirror_table;
+  static MetaspaceObjToOopHandleTable* _scratch_references_table;
+
+  static ClassLoaderData* _saved_java_platform_loader_data;
+  static ClassLoaderData* _saved_java_system_loader_data;
 
   static void init_seen_objects_table() {
     assert(_seen_objects_table == nullptr, "must be");
@@ -394,7 +398,10 @@ class HeapShared: AllStatic {
 #endif // INCLUDE_CDS_JAVA_HEAP
 
  public:
+  static objArrayOop scratch_resolved_references(ConstantPool* src);
+  static void add_scratch_resolved_references(ConstantPool* src, objArrayOop dest) NOT_CDS_JAVA_HEAP_RETURN;
   static void init_scratch_objects(TRAPS) NOT_CDS_JAVA_HEAP_RETURN;
+  static void restore_loader_data() NOT_CDS_JAVA_HEAP_RETURN;
   static bool is_heap_region(int idx) {
     CDS_JAVA_HEAP_ONLY(return (idx == MetaspaceShared::hp);)
     NOT_CDS_JAVA_HEAP_RETURN_(false);

src/hotspot/share/cds/metaspaceShared.cpp

@@ -502,6 +502,9 @@ void VM_PopulateDumpSharedSpace::doit() {
 
   char* cloned_vtables = CppVtables::dumptime_init(&builder);
 
+  // Initialize random for updating the hash of symbols
+  os::init_random(0x12345678);
+
   builder.dump_rw_metadata();
   builder.dump_ro_metadata();
   builder.relocate_metaspaceobj_embedded_pointers();
@@ -542,8 +545,6 @@ void VM_PopulateDumpSharedSpace::doit() {
     log_warning(cds)("This archive was created with AllowArchivingWithJavaAgent. It should be used "
             "for testing purposes only and should not be used in a production environment");
   }
-
-  MetaspaceShared::exit_after_static_dump();
 }
 
 class CollectCLDClosure : public CLDClosure {
@@ -660,11 +661,14 @@ void MetaspaceShared::preload_and_dump() {
                      java_lang_String::as_utf8_string(java_lang_Throwable::message(PENDING_EXCEPTION)));
       MetaspaceShared::unrecoverable_writing_error("VM exits due to exception, use -Xlog:cds,exceptions=trace for detail");
     }
-  } else {
-    // On success, the VM_PopulateDumpSharedSpace op should have
-    // exited the VM.
-    ShouldNotReachHere();
   }
+
+#if INCLUDE_CDS_JAVA_HEAP
+  // Restore the java loaders that were cleared at dump time
+  if (use_full_module_graph()) {
+    HeapShared::restore_loader_data();
+  }
+#endif
 }
 
 #if INCLUDE_CDS_JAVA_HEAP && defined(_LP64)
@@ -893,14 +897,6 @@ void MetaspaceShared::unrecoverable_writing_error(const char* message) {
   vm_direct_exit(1);
 }
 
-// We have finished dumping the static archive. At this point, there may be pending VM
-// operations. We have changed some global states (such as vmClasses::_klasses) that
-// may cause these VM operations to fail. For safety, forget these operations and
-// exit the VM directly.
-void MetaspaceShared::exit_after_static_dump() {
-  os::_exit(0);
-}
-
 void MetaspaceShared::initialize_runtime_shared_and_meta_spaces() {
   assert(UseSharedSpaces, "Must be called when UseSharedSpaces is enabled");
   MapArchiveResult result = MAP_ARCHIVE_OTHER_FAILURE;

src/hotspot/share/cds/metaspaceShared.hpp

@@ -104,7 +104,6 @@ class MetaspaceShared : AllStatic {
 
   static void unrecoverable_loading_error(const char* message = nullptr);
   static void unrecoverable_writing_error(const char* message = nullptr);
-  static void exit_after_static_dump();
 
   static void serialize(SerializeClosure* sc) NOT_CDS_RETURN;
 

src/hotspot/share/oops/constantPool.cpp

@@ -216,6 +216,12 @@ void ConstantPool::initialize_resolved_references(ClassLoaderData* loader_data,
     HandleMark hm(THREAD);
     Handle refs_handle (THREAD, stom);  // must handleize.
     set_resolved_references(loader_data->add_handle(refs_handle));
+
+    // Create a "scratch" copy of the resolved references array to archive
+    if (DumpSharedSpaces) {
+      objArrayOop scratch_references = oopFactory::new_objArray(vmClasses::Object_klass(), map_length, CHECK);
+      HeapShared::add_scratch_resolved_references(this, scratch_references);
+    }
   }
 }
 
@@ -286,22 +292,25 @@ objArrayOop ConstantPool::prepare_resolved_references_for_archiving() {
 
   objArrayOop rr = resolved_references();
   if (rr != nullptr) {
+    ConstantPool* orig_pool = ArchiveBuilder::current()->get_source_addr(this);
+    objArrayOop scratch_rr = HeapShared::scratch_resolved_references(orig_pool);
     Array<u2>* ref_map = reference_map();
     int ref_map_len = ref_map == nullptr ? 0 : ref_map->length();
     int rr_len = rr->length();
     for (int i = 0; i < rr_len; i++) {
       oop obj = rr->obj_at(i);
-      rr->obj_at_put(i, nullptr);
+      scratch_rr->obj_at_put(i, nullptr);
       if (obj != nullptr && i < ref_map_len) {
         int index = object_to_cp_index(i);
         if (tag_at(index).is_string()) {
           assert(java_lang_String::is_instance(obj), "must be");
           if (!ArchiveHeapWriter::is_string_too_large_to_archive(obj)) {
-            rr->obj_at_put(i, obj);
+            scratch_rr->obj_at_put(i, obj);
           }
         }
       }
     }
+    return scratch_rr;
   }
   return rr;
 }

src/hotspot/share/runtime/threads.cpp

@@ -814,7 +814,6 @@ jint Threads::create_vm(JavaVMInitArgs* args, bool* canTryAgain) {
 
   if (DumpSharedSpaces) {
     MetaspaceShared::preload_and_dump();
-    ShouldNotReachHere();
   }
 
   return JNI_OK;

src/java.base/share/native/libjli/java.c

@@ -85,6 +85,7 @@ static jboolean _is_java_args = JNI_FALSE;
 static jboolean _have_classpath = JNI_FALSE;
 static const char *_fVersion;
 static jboolean _wc_enabled = JNI_FALSE;
+static jboolean dumpSharedSpaces = JNI_FALSE; /* -Xshare:dump */
 
 /*
  * Entries for splash screen environment variables.
@@ -455,6 +456,14 @@ JavaMain(void* _args)
         LEAVE();
     }
 
+    /*
+     * -Xshare:dump does not have a main class so the VM can safely exit now
+     */
+    if (dumpSharedSpaces) {
+        CHECK_EXCEPTION_LEAVE(1);
+        LEAVE();
+    }
+
     /* If the user specified neither a class name nor a JAR file */
     if (printXUsage || printUsage || what == 0 || mode == LM_UNKNOWN) {
         PrintUsage(env, printXUsage);
@@ -1432,6 +1441,13 @@ ParseArguments(int *pargc, char ***pargv,
             }
             AddOption(arg, NULL);
         }
+
+        /*
+        * Check for CDS option
+        */
+        if (JLI_StrCmp(arg, "-Xshare:dump") == 0) {
+            dumpSharedSpaces = JNI_TRUE;
+        }
     }
 
     if (*pwhat == NULL && --argc >= 0) {
@@ -1440,7 +1456,7 @@ ParseArguments(int *pargc, char ***pargv,
 
     if (*pwhat == NULL) {
         /* LM_UNKNOWN okay for options that exit */
-        if (!listModules && !describeModule && !validateModules) {
+        if (!listModules && !describeModule && !validateModules && !dumpSharedSpaces) {
             *pret = 1;
         }
     } else if (mode == LM_UNKNOWN) {