8290739: Simplify storage of dump-time class information

Reviewed-by: ccheung

src/hotspot/share/cds/dumpTimeClassInfo.cpp

@@ -169,23 +169,21 @@ bool DumpTimeClassInfo::is_builtin() {
   return SystemDictionaryShared::is_builtin(_klass);
 }
 
-DumpTimeClassInfo* DumpTimeSharedClassTable::find_or_allocate_info_for(InstanceKlass* k, bool dump_in_progress) {
-  bool created = false;
-  DumpTimeClassInfo* p;
-  if (!dump_in_progress) {
-    p = put_if_absent(k, &created);
-  } else {
-    p = get(k);
-  }
-  if (created) {
-    assert(!SystemDictionaryShared::no_class_loading_should_happen(),
-           "no new classes can be loaded while dumping archive");
-    p->_klass = k;
-  } else {
-    if (!dump_in_progress) {
-      assert(p->_klass == k, "Sanity");
-    }
-  }
+DumpTimeClassInfo* DumpTimeSharedClassTable::allocate_info(InstanceKlass* k) {
+  assert(!k->is_shared(), "Do not call with shared classes");
+  bool created;
+  DumpTimeClassInfo* p = put_if_absent(k, &created);
+  assert(created, "must not exist in table");
+  p->_klass = k;
+  return p;
+}
+
+DumpTimeClassInfo* DumpTimeSharedClassTable::get_info(InstanceKlass* k) {
+  assert(!k->is_shared(), "Do not call with shared classes");
+  DumpTimeClassInfo* p = get(k);
+  assert(p != NULL, "we must not see any non-shared InstanceKlass* that's "
+         "not stored with SystemDictionaryShared::init_dumptime_info");
+  assert(p->_klass == k, "Sanity");
   return p;
 }
 

src/hotspot/share/cds/dumpTimeClassInfo.hpp

@@ -196,7 +196,8 @@ public:
     _builtin_count = 0;
     _unregistered_count = 0;
   }
-  DumpTimeClassInfo* find_or_allocate_info_for(InstanceKlass* k, bool dump_in_progress);
+  DumpTimeClassInfo* allocate_info(InstanceKlass* k);
+  DumpTimeClassInfo* get_info(InstanceKlass* k);
   void inc_builtin_count()      { _builtin_count++; }
   void inc_unregistered_count() { _unregistered_count++; }
   void update_counts();

src/hotspot/share/cds/dynamicArchive.cpp

@@ -106,8 +106,6 @@ public:
   }
 
   void doit() {
-    SystemDictionaryShared::start_dumping();
-
     verify_universe("Before CDS dynamic dump");
     DEBUG_ONLY(SystemDictionaryShared::NoClassLoadingMark nclm);
 
@@ -117,7 +115,6 @@ public:
 
     if (SystemDictionaryShared::is_dumptime_table_empty()) {
       log_warning(cds, dynamic)("There is no class to be included in the dynamic archive.");
-      SystemDictionaryShared::stop_dumping();
       return;
     }
 
@@ -177,7 +174,6 @@ public:
 
     assert(_num_dump_regions_used == _total_dump_regions, "must be");
     verify_universe("After CDS dynamic dump");
-    SystemDictionaryShared::stop_dumping();
   }
 
   virtual void iterate_roots(MetaspaceClosure* it, bool is_relocating_pointers) {

src/hotspot/share/cds/lambdaFormInvokers.cpp

@@ -218,8 +218,9 @@ void LambdaFormInvokers::regenerate_class(char* class_name, ClassFileStream& st,
   assert(!HAS_PENDING_EXCEPTION, "Invariant");
 
   result->set_is_generated_shared_class();
-  SystemDictionaryShared::set_excluded(InstanceKlass::cast(klass)); // exclude the existing class from dump
-  SystemDictionaryShared::init_dumptime_info(result);
+  if (!klass->is_shared()) {
+    SystemDictionaryShared::set_excluded(InstanceKlass::cast(klass)); // exclude the existing class from dump
+  }
   log_info(cds, lambda)("Regenerated class %s, old: " INTPTR_FORMAT " new: " INTPTR_FORMAT,
                  class_name, p2i(klass), p2i(result));
 }

src/hotspot/share/classfile/systemDictionary.cpp

@@ -1649,6 +1649,10 @@ void SystemDictionary::initialize(TRAPS) {
   _invoke_method_table = new SymbolPropertyTable(_invoke_method_size);
   _pd_cache_table = new ProtectionDomainCacheTable(defaultProtectionDomainCacheSize);
 
+#if INCLUDE_CDS
+  SystemDictionaryShared::initialize();
+#endif
+
   // Resolve basic classes
   vmClasses::resolve_all(CHECK);
   // Resolve classes used by archived heap objects

src/hotspot/share/classfile/systemDictionaryShared.cpp

@@ -81,8 +81,8 @@ DumpTimeSharedClassTable* SystemDictionaryShared::_cloned_dumptime_table = NULL;
 DumpTimeLambdaProxyClassDictionary* SystemDictionaryShared::_dumptime_lambda_proxy_class_dictionary = NULL;
 DumpTimeLambdaProxyClassDictionary* SystemDictionaryShared::_cloned_dumptime_lambda_proxy_class_dictionary = NULL;
 
-DEBUG_ONLY(bool SystemDictionaryShared::_no_class_loading_should_happen = false;)
-bool SystemDictionaryShared::_dump_in_progress = false;
+// Used by NoClassLoadingMark
+DEBUG_ONLY(bool SystemDictionaryShared::_class_loading_may_happen = true;)
 
 InstanceKlass* SystemDictionaryShared::load_shared_class_for_builtin_loader(
                  Symbol* class_name, Handle class_loader, TRAPS) {
@@ -178,27 +178,20 @@ InstanceKlass* SystemDictionaryShared::acquire_class_for_current_thread(
   return shared_klass;
 }
 
-void SystemDictionaryShared::start_dumping() {
+// Guaranteed to return non-NULL value for non-shared classes.
+// k must not be a shared class.
+DumpTimeClassInfo* SystemDictionaryShared::get_info(InstanceKlass* k) {
   MutexLocker ml(DumpTimeTable_lock, Mutex::_no_safepoint_check_flag);
-  _dump_in_progress = true;
+  assert(!k->is_shared(), "sanity");
+  return get_info_locked(k);
 }
 
-void SystemDictionaryShared::stop_dumping() {
+DumpTimeClassInfo* SystemDictionaryShared::get_info_locked(InstanceKlass* k) {
   assert_lock_strong(DumpTimeTable_lock);
-  _dump_in_progress = false;
-}
-
-DumpTimeClassInfo* SystemDictionaryShared::find_or_allocate_info_for(InstanceKlass* k) {
-  MutexLocker ml(DumpTimeTable_lock, Mutex::_no_safepoint_check_flag);
-  return find_or_allocate_info_for_locked(k);
-}
-
-DumpTimeClassInfo* SystemDictionaryShared::find_or_allocate_info_for_locked(InstanceKlass* k) {
-  assert_lock_strong(DumpTimeTable_lock);
-  if (_dumptime_table == NULL) {
-    _dumptime_table = new (ResourceObj::C_HEAP, mtClass) DumpTimeSharedClassTable;
-  }
-  return _dumptime_table->find_or_allocate_info_for(k, _dump_in_progress);
+  assert(!k->is_shared(), "sanity");
+  DumpTimeClassInfo* info = _dumptime_table->get_info(k);
+  assert(info != NULL, "must be");
+  return info;
 }
 
 bool SystemDictionaryShared::check_for_exclusion(InstanceKlass* k, DumpTimeClassInfo* info) {
@@ -501,15 +494,23 @@ InstanceKlass* SystemDictionaryShared::lookup_super_for_unregistered_class(
 void SystemDictionaryShared::set_shared_class_misc_info(InstanceKlass* k, ClassFileStream* cfs) {
   Arguments::assert_is_dumping_archive();
   assert(!is_builtin(k), "must be unregistered class");
-  DumpTimeClassInfo* info = find_or_allocate_info_for(k);
-  if (info != NULL) {
-    info->_clsfile_size  = cfs->length();
-    info->_clsfile_crc32 = ClassLoader::crc32(0, (const char*)cfs->buffer(), cfs->length());
+  DumpTimeClassInfo* info = get_info(k);
+  info->_clsfile_size  = cfs->length();
+  info->_clsfile_crc32 = ClassLoader::crc32(0, (const char*)cfs->buffer(), cfs->length());
+}
+
+void SystemDictionaryShared::initialize() {
+  if (Arguments::is_dumping_archive()) {
+    _dumptime_table = new (ResourceObj::C_HEAP, mtClass) DumpTimeSharedClassTable;
+    _dumptime_lambda_proxy_class_dictionary =
+                      new (ResourceObj::C_HEAP, mtClass) DumpTimeLambdaProxyClassDictionary;
   }
 }
 
 void SystemDictionaryShared::init_dumptime_info(InstanceKlass* k) {
-  (void)find_or_allocate_info_for(k);
+  MutexLocker ml(DumpTimeTable_lock, Mutex::_no_safepoint_check_flag);
+  assert(SystemDictionaryShared::class_loading_may_happen(), "sanity");
+  _dumptime_table->allocate_info(k);
 }
 
 void SystemDictionaryShared::remove_dumptime_info(InstanceKlass* k) {
@@ -591,7 +592,7 @@ void SystemDictionaryShared::validate_before_archiving(InstanceKlass* k) {
   ResourceMark rm;
   const char* name = k->name()->as_C_string();
   DumpTimeClassInfo* info = _dumptime_table->get(k);
-  assert(_no_class_loading_should_happen, "class loading must be disabled");
+  assert(!class_loading_may_happen(), "class loading must be disabled");
   guarantee(info != NULL, "Class %s must be entered into _dumptime_table", name);
   guarantee(!info->is_excluded(), "Should not attempt to archive excluded class %s", name);
   if (is_builtin(k)) {
@@ -649,7 +650,7 @@ public:
 };
 
 void SystemDictionaryShared::check_excluded_classes() {
-  assert(no_class_loading_should_happen(), "sanity");
+  assert(!class_loading_may_happen(), "class loading must be disabled");
   assert_lock_strong(DumpTimeTable_lock);
 
   if (DynamicDumpSharedSpaces) {
@@ -671,45 +672,34 @@ void SystemDictionaryShared::check_excluded_classes() {
 }
 
 bool SystemDictionaryShared::is_excluded_class(InstanceKlass* k) {
-  assert(_no_class_loading_should_happen, "sanity");
+  assert(!class_loading_may_happen(), "class loading must be disabled");
   assert_lock_strong(DumpTimeTable_lock);
   Arguments::assert_is_dumping_archive();
-  DumpTimeClassInfo* p = find_or_allocate_info_for_locked(k);
-  return (p == NULL) ? true : p->is_excluded();
+  DumpTimeClassInfo* p = get_info_locked(k);
+  return p->is_excluded();
 }
 
 void SystemDictionaryShared::set_excluded_locked(InstanceKlass* k) {
   assert_lock_strong(DumpTimeTable_lock);
   Arguments::assert_is_dumping_archive();
-  DumpTimeClassInfo* info = find_or_allocate_info_for_locked(k);
-  if (info != NULL) {
-    info->set_excluded();
-  }
+  DumpTimeClassInfo* info = get_info_locked(k);
+  info->set_excluded();
 }
 
 void SystemDictionaryShared::set_excluded(InstanceKlass* k) {
   Arguments::assert_is_dumping_archive();
-  DumpTimeClassInfo* info = find_or_allocate_info_for(k);
-  if (info != NULL) {
-    info->set_excluded();
-  }
+  DumpTimeClassInfo* info = get_info(k);
+  info->set_excluded();
 }
 
 void SystemDictionaryShared::set_class_has_failed_verification(InstanceKlass* ik) {
   Arguments::assert_is_dumping_archive();
-  DumpTimeClassInfo* p = find_or_allocate_info_for(ik);
-  if (p != NULL) {
-    p->set_failed_verification();
-  }
+  DumpTimeClassInfo* p = get_info(ik);
+  p->set_failed_verification();
 }
 
 bool SystemDictionaryShared::has_class_failed_verification(InstanceKlass* ik) {
   Arguments::assert_is_dumping_archive();
-  if (_dumptime_table == NULL) {
-    assert(DynamicDumpSharedSpaces, "sanity");
-    assert(ik->is_shared(), "must be a shared class in the static archive");
-    return false;
-  }
   DumpTimeClassInfo* p = _dumptime_table->get(ik);
   return (p == NULL) ? false : p->failed_verification();
 }
@@ -724,27 +714,22 @@ void SystemDictionaryShared::dumptime_classes_do(class MetaspaceClosure* it) {
   };
   _dumptime_table->iterate_all_live_classes(do_klass);
 
-  if (_dumptime_lambda_proxy_class_dictionary != NULL) {
-    auto do_lambda = [&] (LambdaProxyClassKey& key, DumpTimeLambdaProxyClassInfo& info) {
-      if (key.caller_ik()->is_loader_alive()) {
-        info.metaspace_pointers_do(it);
-        key.metaspace_pointers_do(it);
-      }
-    };
-    _dumptime_lambda_proxy_class_dictionary->iterate_all(do_lambda);
-  }
+  auto do_lambda = [&] (LambdaProxyClassKey& key, DumpTimeLambdaProxyClassInfo& info) {
+    if (key.caller_ik()->is_loader_alive()) {
+      info.metaspace_pointers_do(it);
+      key.metaspace_pointers_do(it);
+    }
+  };
+  _dumptime_lambda_proxy_class_dictionary->iterate_all(do_lambda);
 }
 
 bool SystemDictionaryShared::add_verification_constraint(InstanceKlass* k, Symbol* name,
          Symbol* from_name, bool from_field_is_protected, bool from_is_array, bool from_is_object) {
   Arguments::assert_is_dumping_archive();
-  DumpTimeClassInfo* info = find_or_allocate_info_for(k);
-  if (info != NULL) {
-    info->add_verification_constraint(k, name, from_name, from_field_is_protected,
-                                      from_is_array, from_is_object);
-  } else {
-    return true;
-  }
+  DumpTimeClassInfo* info = get_info(k);
+  info->add_verification_constraint(k, name, from_name, from_field_is_protected,
+                                    from_is_array, from_is_object);
+
   if (DynamicDumpSharedSpaces) {
     // For dynamic dumping, we can resolve all the constraint classes for all class loaders during
     // the initial run prior to creating the archive before vm exit. We will also perform verification
@@ -766,18 +751,14 @@ bool SystemDictionaryShared::add_verification_constraint(InstanceKlass* k, Symbo
 
 void SystemDictionaryShared::add_enum_klass_static_field(InstanceKlass* ik, int root_index) {
   assert(DumpSharedSpaces, "static dump only");
-  DumpTimeClassInfo* info = SystemDictionaryShared::find_or_allocate_info_for_locked(ik);
-  assert(info != NULL, "must be");
+  DumpTimeClassInfo* info = get_info_locked(ik);
   info->add_enum_klass_static_field(root_index);
 }
 
 void SystemDictionaryShared::add_to_dump_time_lambda_proxy_class_dictionary(LambdaProxyClassKey& key,
                                                            InstanceKlass* proxy_klass) {
   assert_lock_strong(DumpTimeTable_lock);
-  if (_dumptime_lambda_proxy_class_dictionary == NULL) {
-    _dumptime_lambda_proxy_class_dictionary =
-      new (ResourceObj::C_HEAP, mtClass) DumpTimeLambdaProxyClassDictionary;
-  }
+
   DumpTimeLambdaProxyClassInfo* lambda_info = _dumptime_lambda_proxy_class_dictionary->get(key);
   if (lambda_info == NULL) {
     DumpTimeLambdaProxyClassInfo info;
@@ -1030,10 +1011,8 @@ void SystemDictionaryShared::record_linking_constraint(Symbol* name, InstanceKla
   assert(!Thread::current()->is_VM_thread(), "must be");
 
   Arguments::assert_is_dumping_archive();
-  DumpTimeClassInfo* info = find_or_allocate_info_for(klass);
-  if (info != NULL) {
-    info->record_linking_constraint(name, loader1, loader2);
-  }
+  DumpTimeClassInfo* info = get_info(klass);
+  info->record_linking_constraint(name, loader1, loader2);
 }
 
 // returns true IFF there's no need to re-initialize the i/v-tables for klass for
@@ -1160,14 +1139,12 @@ size_t SystemDictionaryShared::estimate_size_for_archive() {
   size_t total_size = est.total() +
     CompactHashtableWriter::estimate_size(_dumptime_table->count_of(true)) +
     CompactHashtableWriter::estimate_size(_dumptime_table->count_of(false));
-  if (_dumptime_lambda_proxy_class_dictionary != NULL) {
-    size_t bytesize = align_up(sizeof(RunTimeLambdaProxyClassInfo), SharedSpaceObjectAlignment);
-    total_size +=
+
+  size_t bytesize = align_up(sizeof(RunTimeLambdaProxyClassInfo), SharedSpaceObjectAlignment);
+  total_size +=
       (bytesize * _dumptime_lambda_proxy_class_dictionary->_count) +
       CompactHashtableWriter::estimate_size(_dumptime_lambda_proxy_class_dictionary->_count);
-  } else {
-    total_size += CompactHashtableWriter::estimate_size(0);
-  }
+
   return total_size;
 }
 
@@ -1300,20 +1277,15 @@ void SystemDictionaryShared::write_dictionary(RunTimeSharedDictionary* dictionar
 void SystemDictionaryShared::write_to_archive(bool is_static_archive) {
   ArchiveInfo* archive = get_archive(is_static_archive);
 
-  if (_dumptime_table != NULL) {
-    write_dictionary(&archive->_builtin_dictionary, true);
-    write_dictionary(&archive->_unregistered_dictionary, false);
-  }
-  if (_dumptime_lambda_proxy_class_dictionary != NULL) {
-    write_lambda_proxy_class_dictionary(&archive->_lambda_proxy_class_dictionary);
-  }
+  write_dictionary(&archive->_builtin_dictionary, true);
+  write_dictionary(&archive->_unregistered_dictionary, false);
+
+  write_lambda_proxy_class_dictionary(&archive->_lambda_proxy_class_dictionary);
 }
 
 void SystemDictionaryShared::adjust_lambda_proxy_class_dictionary() {
-  if (_dumptime_lambda_proxy_class_dictionary != NULL) {
-    AdjustLambdaProxyClassInfo adjuster;
-    _dumptime_lambda_proxy_class_dictionary->iterate(&adjuster);
-  }
+  AdjustLambdaProxyClassInfo adjuster;
+  _dumptime_lambda_proxy_class_dictionary->iterate(&adjuster);
 }
 
 void SystemDictionaryShared::serialize_dictionary_headers(SerializeClosure* soc,
@@ -1387,7 +1359,7 @@ InstanceKlass* SystemDictionaryShared::find_builtin_class(Symbol* name) {
 
 void SystemDictionaryShared::update_shared_entry(InstanceKlass* k, int id) {
   assert(DumpSharedSpaces, "supported only when dumping");
-  DumpTimeClassInfo* info = find_or_allocate_info_for(k);
+  DumpTimeClassInfo* info = get_info(k);
   info->_id = id;
 }
 
@@ -1493,9 +1465,6 @@ void SystemDictionaryShared::print_table_statistics(outputStream* st) {
 
 bool SystemDictionaryShared::is_dumptime_table_empty() {
   assert_lock_strong(DumpTimeTable_lock);
-  if (_dumptime_table == NULL) {
-    return true;
-  }
   _dumptime_table->update_counts();
   if (_dumptime_table->count_of(true) == 0 && _dumptime_table->count_of(false) == 0){
     return true;
@@ -1545,22 +1514,20 @@ class CloneDumpTimeLambdaProxyClassTable: StackObj {
 void SystemDictionaryShared::clone_dumptime_tables() {
   Arguments::assert_is_dumping_archive();
   assert_lock_strong(DumpTimeTable_lock);
-  if (_dumptime_table != NULL) {
-    assert(_cloned_dumptime_table == NULL, "_cloned_dumptime_table must be cleaned");
-    _cloned_dumptime_table = new (ResourceObj::C_HEAP, mtClass) DumpTimeSharedClassTable;
-    CloneDumpTimeClassTable copy_classes(_dumptime_table, _cloned_dumptime_table);
-    _dumptime_table->iterate_all_live_classes(&copy_classes);
-    _cloned_dumptime_table->update_counts();
-  }
-  if (_dumptime_lambda_proxy_class_dictionary != NULL) {
-    assert(_cloned_dumptime_lambda_proxy_class_dictionary == NULL,
-           "_cloned_dumptime_lambda_proxy_class_dictionary must be cleaned");
-    _cloned_dumptime_lambda_proxy_class_dictionary =
-                                          new (ResourceObj::C_HEAP, mtClass) DumpTimeLambdaProxyClassDictionary;
-    CloneDumpTimeLambdaProxyClassTable copy_proxy_classes(_dumptime_lambda_proxy_class_dictionary,
-                                                          _cloned_dumptime_lambda_proxy_class_dictionary);
-    _dumptime_lambda_proxy_class_dictionary->iterate(&copy_proxy_classes);
-  }
+
+  assert(_cloned_dumptime_table == NULL, "_cloned_dumptime_table must be cleaned");
+  _cloned_dumptime_table = new (ResourceObj::C_HEAP, mtClass) DumpTimeSharedClassTable;
+  CloneDumpTimeClassTable copy_classes(_dumptime_table, _cloned_dumptime_table);
+  _dumptime_table->iterate_all_live_classes(&copy_classes);
+  _cloned_dumptime_table->update_counts();
+
+  assert(_cloned_dumptime_lambda_proxy_class_dictionary == NULL,
+         "_cloned_dumptime_lambda_proxy_class_dictionary must be cleaned");
+  _cloned_dumptime_lambda_proxy_class_dictionary =
+                                        new (ResourceObj::C_HEAP, mtClass) DumpTimeLambdaProxyClassDictionary;
+  CloneDumpTimeLambdaProxyClassTable copy_proxy_classes(_dumptime_lambda_proxy_class_dictionary,
+                                                        _cloned_dumptime_lambda_proxy_class_dictionary);
+  _dumptime_lambda_proxy_class_dictionary->iterate(&copy_proxy_classes);
 }
 
 void SystemDictionaryShared::restore_dumptime_tables() {
@@ -1568,6 +1535,7 @@ void SystemDictionaryShared::restore_dumptime_tables() {
   delete _dumptime_table;
   _dumptime_table = _cloned_dumptime_table;
   _cloned_dumptime_table = NULL;
+
   delete _dumptime_lambda_proxy_class_dictionary;
   _dumptime_lambda_proxy_class_dictionary = _cloned_dumptime_lambda_proxy_class_dictionary;
   _cloned_dumptime_lambda_proxy_class_dictionary = NULL;
@@ -1598,10 +1566,8 @@ class CleanupDumpTimeLambdaProxyClassTable: StackObj {
 
 void SystemDictionaryShared::cleanup_lambda_proxy_class_dictionary() {
   assert_lock_strong(DumpTimeTable_lock);
-  if (_dumptime_lambda_proxy_class_dictionary != NULL) {
-    CleanupDumpTimeLambdaProxyClassTable cleanup_proxy_classes;
-    _dumptime_lambda_proxy_class_dictionary->unlink(&cleanup_proxy_classes);
-  }
+  CleanupDumpTimeLambdaProxyClassTable cleanup_proxy_classes;
+  _dumptime_lambda_proxy_class_dictionary->unlink(&cleanup_proxy_classes);
 }
 
 #if INCLUDE_CDS_JAVA_HEAP

src/hotspot/share/classfile/systemDictionaryShared.hpp

@@ -182,8 +182,12 @@ private:
                                  Handle protection_domain,
                                  const ClassFileStream* cfs,
                                  TRAPS);
-  static DumpTimeClassInfo* find_or_allocate_info_for(InstanceKlass* k);
-  static DumpTimeClassInfo* find_or_allocate_info_for_locked(InstanceKlass* k);
+
+  // Guaranteed to return non-NULL value for non-shared classes.
+  // k must not be a shared class.
+  static DumpTimeClassInfo* get_info(InstanceKlass* k);
+  static DumpTimeClassInfo* get_info_locked(InstanceKlass* k);
+
   static void write_dictionary(RunTimeSharedDictionary* dictionary,
                                bool is_builtin);
   static void write_lambda_proxy_class_dictionary(LambdaProxyClassDictionary* dictionary);
@@ -195,8 +199,7 @@ private:
   static void remove_dumptime_info(InstanceKlass* k) NOT_CDS_RETURN;
   static bool has_been_redefined(InstanceKlass* k);
 
-  static bool _dump_in_progress;
-  DEBUG_ONLY(static bool _no_class_loading_should_happen;)
+  DEBUG_ONLY(static bool _class_loading_may_happen;)
 
 public:
   static bool is_hidden_lambda_proxy(InstanceKlass* ik);
@@ -225,6 +228,7 @@ public:
   static InstanceKlass* lookup_super_for_unregistered_class(Symbol* class_name,
                                                             Symbol* super_name,  bool is_superclass);
 
+  static void initialize() NOT_CDS_RETURN;
   static void init_dumptime_info(InstanceKlass* k) NOT_CDS_RETURN;
   static void handle_class_unloading(InstanceKlass* k) NOT_CDS_RETURN;
 
@@ -311,20 +315,21 @@ public:
   static void print_shared_archive(outputStream* st, bool is_static = true) NOT_CDS_RETURN;
   static void print_table_statistics(outputStream* st) NOT_CDS_RETURN;
   static bool is_dumptime_table_empty() NOT_CDS_RETURN_(true);
-  static void start_dumping() NOT_CDS_RETURN;
-  static void stop_dumping() NOT_CDS_RETURN;
   static bool is_supported_invokedynamic(BootstrapInfo* bsi) NOT_CDS_RETURN_(false);
-  DEBUG_ONLY(static bool no_class_loading_should_happen() {return _no_class_loading_should_happen;})
+  DEBUG_ONLY(static bool class_loading_may_happen() {return _class_loading_may_happen;})
 
 #ifdef ASSERT
+  // This object marks a critical period when writing the CDS archive. During this
+  // period, the JVM must not load any new classes, so as to avoid adding new
+  // items in the SystemDictionaryShared::_dumptime_table.
   class NoClassLoadingMark: public StackObj {
   public:
     NoClassLoadingMark() {
-      assert(!_no_class_loading_should_happen, "must not be nested");
-      _no_class_loading_should_happen = true;
+      assert(_class_loading_may_happen, "must not be nested");
+      _class_loading_may_happen = false;
     }
     ~NoClassLoadingMark() {
-      _no_class_loading_should_happen = false;
+      _class_loading_may_happen = true;
     }
   };
 #endif

src/hotspot/share/runtime/mutexLocker.hpp

@@ -122,7 +122,7 @@ extern Mutex*   NMTQuery_lock;                   // serialize NMT Dcmd queries
 #if INCLUDE_JVMTI
 extern Mutex*   CDSClassFileStream_lock;         // FileMapInfo::open_stream_for_jvmti
 #endif
-extern Mutex*   DumpTimeTable_lock;              // SystemDictionaryShared::find_or_allocate_info_for
+extern Mutex*   DumpTimeTable_lock;              // SystemDictionaryShared::_dumptime_table
 extern Mutex*   CDSLambda_lock;                  // SystemDictionaryShared::get_shared_lambda_proxy_class
 extern Mutex*   DumpRegion_lock;                 // Symbol::operator new(size_t sz, int len)
 extern Mutex*   ClassListFile_lock;              // ClassListWriter()