src/hotspot/share/classfile/moduleEntry.cpp

@@ -31,10 +31,11 @@
  #include "classfile/classLoader.hpp"
  #include "classfile/classLoaderData.inline.hpp"
  #include "classfile/classLoaderDataShared.hpp"
  #include "classfile/javaClasses.inline.hpp"
  #include "classfile/moduleEntry.hpp"
+ #include "classfile/modules.hpp"
  #include "classfile/systemDictionary.hpp"
  #include "classfile/systemDictionaryShared.hpp"
  #include "jni.h"
  #include "logging/log.hpp"
  #include "logging/logStream.hpp"

@@ -401,23 +402,33 @@
    _loader_data = cld;
  }
  
  void ModuleEntry::metaspace_pointers_do(MetaspaceClosure* it) {
    it->push(&_name);
-   it->push(&_reads);
+   if (!(is_named() && Modules::is_dynamic_proxy_module(this))) {
+     // This is a dynamically generated module. Its _reads will be
+     // restored at runtime in the Java code. See comments in ArchivedData::restore().    
+     it->push(&_reads);
+   }
    it->push(&_version);
    it->push(&_location);
+ 
  }
  
  #if INCLUDE_CDS_JAVA_HEAP
  bool ModuleEntry::should_be_archived() const {
    return SystemDictionaryShared::is_builtin_loader(loader_data());
  }
  
  void ModuleEntry::remove_unshareable_info() {
    _archived_module_index = HeapShared::append_root(module_oop());
  
+   if (is_named() && Modules::is_dynamic_proxy_module(ArchiveBuilder::current()->get_source_addr(this))) {
+     // See comments in ModuleEntry::metaspace_pointers_do()
+     _reads = nullptr;
+   }
+ 
    if (_reads != nullptr) {
      _reads->set_in_aot_cache();
    }
  
    // Clear handles and restore at run time. Handles cannot be archived.

@@ -442,21 +453,21 @@
    }
    JFR_ONLY(set_trace_id(0);) // re-init at runtime
  }
  
  void ModuleEntry::load_from_archive(ClassLoaderData* loader_data) {
-   assert(CDSConfig::is_using_archive(), "runtime only");
+   assert(CDSConfig::is_using_full_module_graph(), "runtime only");
    set_loader_data(loader_data);
    JFR_ONLY(INIT_ID(this);)
  }
  
  void ModuleEntry::preload_archived_oops() {
    (void)HeapShared::get_root(_archived_module_index, false /* clear */);
  }
  
  void ModuleEntry::restore_archived_oops(ClassLoaderData* loader_data) {
-   assert(CDSConfig::is_using_archive(), "runtime only");
+   assert(CDSConfig::is_using_full_module_graph(), "runtime only");
    Handle module_handle(Thread::current(), HeapShared::get_root(_archived_module_index, /*clear=*/true));
    assert(module_handle.not_null(), "huh");
    set_module_handle(loader_data->add_handle(module_handle));
  
    // This was cleared to zero during dump time -- we didn't save the value

@@ -473,11 +484,11 @@
      print(&ls);
    }
  }
  
  void ModuleEntry::clear_archived_oops() {
-   assert(CDSConfig::is_using_archive(), "runtime only");
+   assert(CDSConfig::is_using_archive() && !CDSConfig::is_using_full_module_graph(), "runtime only");
    HeapShared::clear_root(_archived_module_index);
  }
  
  static int compare_module_by_name(ModuleEntry* a, ModuleEntry* b) {
    assert(a == b || a->name() != b->name(), "no duplicated names");

@@ -508,21 +519,21 @@
    return aot_table;
  }
  
  void ModuleEntryTable::load_archived_entries(ClassLoaderData* loader_data,
                                               Array<ModuleEntry*>* archived_modules) {
-   assert(CDSConfig::is_using_archive(), "runtime only");
+   assert(CDSConfig::is_using_full_module_graph(), "runtime only");
  
    for (int i = 0; i < archived_modules->length(); i++) {
      ModuleEntry* archived_entry = archived_modules->at(i);
      archived_entry->load_from_archive(loader_data);
      _table.put(archived_entry->name(), archived_entry);
    }
  }
  
  void ModuleEntryTable::restore_archived_oops(ClassLoaderData* loader_data, Array<ModuleEntry*>* archived_modules) {
-   assert(CDSConfig::is_using_archive(), "runtime only");
+   assert(CDSConfig::is_using_full_module_graph(), "runtime only");
    for (int i = 0; i < archived_modules->length(); i++) {
      ModuleEntry* archived_entry = archived_modules->at(i);
      archived_entry->restore_archived_oops(loader_data);
    }
  }