1 /*
  2  * Copyright (c) 2016, 2024, 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 "precompiled.hpp"
 26 #include "cds/archiveBuilder.hpp"
 27 #include "cds/archiveUtils.hpp"
 28 #include "cds/cdsConfig.hpp"
 29 #include "cds/filemap.hpp"
 30 #include "cds/heapShared.hpp"
 31 #include "classfile/classLoader.hpp"
 32 #include "classfile/classLoaderData.inline.hpp"
 33 #include "classfile/javaClasses.inline.hpp"
 34 #include "classfile/moduleEntry.hpp"
 35 #include "classfile/modules.hpp"
 36 #include "classfile/systemDictionary.hpp"
 37 #include "jni.h"
 38 #include "logging/log.hpp"
 39 #include "logging/logStream.hpp"
 40 #include "memory/resourceArea.hpp"
 41 #include "memory/universe.hpp"
 42 #include "oops/oopHandle.inline.hpp"
 43 #include "oops/symbol.hpp"
 44 #include "runtime/handles.inline.hpp"
 45 #include "runtime/safepoint.hpp"
 46 #include "utilities/events.hpp"
 47 #include "utilities/growableArray.hpp"
 48 #include "utilities/ostream.hpp"
 49 #include "utilities/quickSort.hpp"
 50 #include "utilities/resourceHash.hpp"
 51 
 52 ModuleEntry* ModuleEntryTable::_javabase_module = nullptr;
 53 
 54 oop ModuleEntry::module() const { return _module.resolve(); }
 55 
 56 void ModuleEntry::set_location(Symbol* location) {
 57   // _location symbol's refcounts are managed by ModuleEntry,
 58   // must decrement the old one before updating.
 59   Symbol::maybe_decrement_refcount(_location);
 60 
 61   _location = location;
 62 
 63   if (location != nullptr) {
 64     location->increment_refcount();
 65     CDS_ONLY(if (UseSharedSpaces) {
 66         _shared_path_index = FileMapInfo::get_module_shared_path_index(location);
 67       });
 68   }
 69 }
 70 
 71 // Return true if the module's version should be displayed in error messages,
 72 // logging, etc.
 73 // Return false if the module's version is null, if it is unnamed, or if the
 74 // module is not an upgradeable module.
 75 // Detect if the module is not upgradeable by checking:
 76 //     1. Module location is "jrt:/java." and its loader is boot or platform
 77 //     2. Module location is "jrt:/jdk.", its loader is one of the builtin loaders
 78 //        and its version is the same as module java.base's version
 79 // The above check is imprecise but should work in almost all cases.
 80 bool ModuleEntry::should_show_version() {
 81   if (version() == nullptr || !is_named()) return false;
 82 
 83   if (location() != nullptr) {
 84     ResourceMark rm;
 85     const char* loc = location()->as_C_string();
 86     ClassLoaderData* cld = loader_data();
 87 
 88     assert(!cld->has_class_mirror_holder(), "module's cld should have a ClassLoader holder not a Class holder");
 89     if ((cld->is_the_null_class_loader_data() || cld->is_platform_class_loader_data()) &&
 90         (strncmp(loc, "jrt:/java.", 10) == 0)) {
 91       return false;
 92     }
 93     if ((ModuleEntryTable::javabase_moduleEntry()->version()->fast_compare(version()) == 0) &&
 94         cld->is_permanent_class_loader_data() && (strncmp(loc, "jrt:/jdk.", 9) == 0)) {
 95       return false;
 96     }
 97   }
 98   return true;
 99 }
100 
101 void ModuleEntry::set_version(Symbol* version) {
102   // _version symbol's refcounts are managed by ModuleEntry,
103   // must decrement the old one before updating.
104   Symbol::maybe_decrement_refcount(_version);
105 
106   _version = version;
107 
108   Symbol::maybe_increment_refcount(version);
109 }
110 
111 // Returns the shared ProtectionDomain
112 oop ModuleEntry::shared_protection_domain() {
113   return _shared_pd.resolve();
114 }
115 
116 // Set the shared ProtectionDomain atomically
117 void ModuleEntry::set_shared_protection_domain(ClassLoaderData *loader_data,
118                                                Handle pd_h) {
119   // Create a handle for the shared ProtectionDomain and save it atomically.
120   // init_handle_locked checks if someone beats us setting the _shared_pd cache.
121   loader_data->init_handle_locked(_shared_pd, pd_h);
122 }
123 
124 // Returns true if this module can read module m
125 bool ModuleEntry::can_read(ModuleEntry* m) const {
126   assert(m != nullptr, "No module to lookup in this module's reads list");
127 
128   // Unnamed modules read everyone and all modules
129   // read java.base.  If either of these conditions
130   // hold, readability has been established.
131   if (!this->is_named() ||
132       (m == ModuleEntryTable::javabase_moduleEntry())) {
133     return true;
134   }
135 
136   MutexLocker m1(Module_lock);
137   // This is a guard against possible race between agent threads that redefine
138   // or retransform classes in this module. Only one of them is adding the
139   // default read edges to the unnamed modules of the boot and app class loaders
140   // with an upcall to jdk.internal.module.Modules.transformedByAgent.
141   // At the same time, another thread can instrument the module classes by
142   // injecting dependencies that require the default read edges for resolution.
143   if (this->has_default_read_edges() && !m->is_named()) {
144     ClassLoaderData* cld = m->loader_data();
145     assert(!cld->has_class_mirror_holder(), "module's cld should have a ClassLoader holder not a Class holder");
146     if (cld->is_the_null_class_loader_data() || cld->is_system_class_loader_data()) {
147       return true; // default read edge
148     }
149   }
150   if (!has_reads_list()) {
151     return false;
152   } else {
153     return _reads->contains(m);
154   }
155 }
156 
157 // Add a new module to this module's reads list
158 void ModuleEntry::add_read(ModuleEntry* m) {
159   // Unnamed module is special cased and can read all modules
160   if (!is_named()) {
161     return;
162   }
163 
164   MutexLocker m1(Module_lock);
165   if (m == nullptr) {
166     set_can_read_all_unnamed();
167   } else {
168     if (_reads == nullptr) {
169       // Lazily create a module's reads list
170       _reads = new (mtModule) GrowableArray<ModuleEntry*>(MODULE_READS_SIZE, mtModule);
171     }
172 
173     // Determine, based on this newly established read edge to module m,
174     // if this module's read list should be walked at a GC safepoint.
175     set_read_walk_required(m->loader_data());
176 
177     // Establish readability to module m
178     _reads->append_if_missing(m);
179   }
180 }
181 
182 // If the module's loader, that a read edge is being established to, is
183 // not the same loader as this module's and is not one of the 3 builtin
184 // class loaders, then this module's reads list must be walked at GC
185 // safepoint. Modules have the same life cycle as their defining class
186 // loaders and should be removed if dead.
187 void ModuleEntry::set_read_walk_required(ClassLoaderData* m_loader_data) {
188   assert(is_named(), "Cannot call set_read_walk_required on unnamed module");
189   assert_locked_or_safepoint(Module_lock);
190   if (!_must_walk_reads &&
191       loader_data() != m_loader_data &&
192       !m_loader_data->is_builtin_class_loader_data()) {
193     _must_walk_reads = true;
194     if (log_is_enabled(Trace, module)) {
195       ResourceMark rm;
196       log_trace(module)("ModuleEntry::set_read_walk_required(): module %s reads list must be walked",
197                         (name() != nullptr) ? name()->as_C_string() : UNNAMED_MODULE);
198     }
199   }
200 }
201 
202 // Set whether the module is open, i.e. all its packages are unqualifiedly exported
203 void ModuleEntry::set_is_open(bool is_open) {
204   assert_lock_strong(Module_lock);
205   _is_open = is_open;
206 }
207 
208 // Returns true if the module has a non-empty reads list. As such, the unnamed
209 // module will return false.
210 bool ModuleEntry::has_reads_list() const {
211   assert_locked_or_safepoint(Module_lock);
212   return ((_reads != nullptr) && !_reads->is_empty());
213 }
214 
215 // Purge dead module entries out of reads list.
216 void ModuleEntry::purge_reads() {
217   assert_locked_or_safepoint(Module_lock);
218 
219   if (_must_walk_reads && has_reads_list()) {
220     // This module's _must_walk_reads flag will be reset based
221     // on the remaining live modules on the reads list.
222     _must_walk_reads = false;
223 
224     if (log_is_enabled(Trace, module)) {
225       ResourceMark rm;
226       log_trace(module)("ModuleEntry::purge_reads(): module %s reads list being walked",
227                         (name() != nullptr) ? name()->as_C_string() : UNNAMED_MODULE);
228     }
229 
230     // Go backwards because this removes entries that are dead.
231     int len = _reads->length();
232     for (int idx = len - 1; idx >= 0; idx--) {
233       ModuleEntry* module_idx = _reads->at(idx);
234       ClassLoaderData* cld_idx = module_idx->loader_data();
235       if (cld_idx->is_unloading()) {
236         _reads->delete_at(idx);
237       } else {
238         // Update the need to walk this module's reads based on live modules
239         set_read_walk_required(cld_idx);
240       }
241     }
242   }
243 }
244 
245 void ModuleEntry::module_reads_do(ModuleClosure* f) {
246   assert_locked_or_safepoint(Module_lock);
247   assert(f != nullptr, "invariant");
248 
249   if (has_reads_list()) {
250     int reads_len = _reads->length();
251     for (int i = 0; i < reads_len; ++i) {
252       f->do_module(_reads->at(i));
253     }
254   }
255 }
256 
257 void ModuleEntry::delete_reads() {
258   delete _reads;
259   _reads = nullptr;
260 }
261 
262 ModuleEntry::ModuleEntry(Handle module_handle,
263                          bool is_open, Symbol* name,
264                          Symbol* version, Symbol* location,
265                          ClassLoaderData* loader_data) :
266     _name(name),
267     _loader_data(loader_data),
268     _reads(nullptr),
269     _version(nullptr),
270     _location(nullptr),
271     CDS_ONLY(_shared_path_index(-1) COMMA)
272     _can_read_all_unnamed(false),
273     _has_default_read_edges(false),
274     _must_walk_reads(false),
275     _is_open(is_open),
276     _is_patched(false) {
277 
278   // Initialize fields specific to a ModuleEntry
279   if (_name == nullptr) {
280     // Unnamed modules can read all other unnamed modules.
281     set_can_read_all_unnamed();
282   } else {
283     _name->increment_refcount();
284   }
285 
286   if (!module_handle.is_null()) {
287     _module = loader_data->add_handle(module_handle);
288   }
289 
290   set_version(version);
291 
292   // may need to add CDS info
293   set_location(location);
294 
295   if (name != nullptr && ClassLoader::is_in_patch_mod_entries(name)) {
296     set_is_patched();
297     if (log_is_enabled(Trace, module, patch)) {
298       ResourceMark rm;
299       log_trace(module, patch)("Marked module %s as patched from --patch-module",
300                                name != nullptr ? name->as_C_string() : UNNAMED_MODULE);
301     }
302   }
303 
304   JFR_ONLY(INIT_ID(this);)
305 }
306 
307 ModuleEntry::~ModuleEntry() {
308   // Clean out the C heap allocated reads list first before freeing the entry
309   delete_reads();
310   Symbol::maybe_decrement_refcount(_name);
311   Symbol::maybe_decrement_refcount(_version);
312   Symbol::maybe_decrement_refcount(_location);
313 }
314 
315 ModuleEntry* ModuleEntry::create_unnamed_module(ClassLoaderData* cld) {
316   // The java.lang.Module for this loader's
317   // corresponding unnamed module can be found in the java.lang.ClassLoader object.
318   oop module = java_lang_ClassLoader::unnamedModule(cld->class_loader());
319 
320   // Ensure that the unnamed module was correctly set when the class loader was constructed.
321   // Guarantee will cause a recognizable crash if the user code has circumvented calling the ClassLoader constructor.
322   ResourceMark rm;
323   guarantee(java_lang_Module::is_instance(module),
324             "The unnamed module for ClassLoader %s, is null or not an instance of java.lang.Module. The class loader has not been initialized correctly.",
325             cld->loader_name_and_id());
326 
327   ModuleEntry* unnamed_module = new_unnamed_module_entry(Handle(Thread::current(), module), cld);
328 
329   // Store pointer to the ModuleEntry in the unnamed module's java.lang.Module object.
330   java_lang_Module::set_module_entry(module, unnamed_module);
331 
332   return unnamed_module;
333 }
334 
335 ModuleEntry* ModuleEntry::create_boot_unnamed_module(ClassLoaderData* cld) {
336   // For the boot loader, the java.lang.Module for the unnamed module
337   // is not known until a call to JVM_SetBootLoaderUnnamedModule is made. At
338   // this point initially create the ModuleEntry for the unnamed module.
339   ModuleEntry* unnamed_module = new_unnamed_module_entry(Handle(), cld);
340   assert(unnamed_module != nullptr, "boot loader unnamed module should not be null");
341   return unnamed_module;
342 }
343 
344 // When creating an unnamed module, this is called without holding the Module_lock.
345 // This is okay because the unnamed module gets created before the ClassLoaderData
346 // is available to other threads.
347 ModuleEntry* ModuleEntry::new_unnamed_module_entry(Handle module_handle, ClassLoaderData* cld) {
348 
349   ModuleEntry* entry = new ModuleEntry(module_handle, /*is_open*/true, /*name*/nullptr,
350                                        /*version*/ nullptr, /*location*/ nullptr,
351                                        cld);
352   // Unnamed modules can read all other unnamed modules.
353   assert(entry->can_read_all_unnamed(), "constructor set that");
354   return entry;
355 }
356 
357 ModuleEntryTable::ModuleEntryTable() { }
358 
359 ModuleEntryTable::~ModuleEntryTable() {
360   class ModuleEntryTableDeleter : public StackObj {
361    public:
362     bool do_entry(const SymbolHandle& name, ModuleEntry*& entry) {
363       if (log_is_enabled(Info, module, unload) || log_is_enabled(Debug, module)) {
364         ResourceMark rm;
365         const char* str = name->as_C_string();
366         log_info(module, unload)("unloading module %s", str);
367         log_debug(module)("ModuleEntryTable: deleting module: %s", str);
368       }
369       delete entry;
370       return true;
371     }
372   };
373 
374   ModuleEntryTableDeleter deleter;
375   _table.unlink(&deleter);
376   assert(_table.number_of_entries() == 0, "should have removed all entries");
377 
378 }
379 
380 void ModuleEntry::set_loader_data(ClassLoaderData* cld) {
381   assert(!cld->has_class_mirror_holder(), "Unexpected has_class_mirror_holder cld");
382   _loader_data = cld;
383 }
384 
385 #if INCLUDE_CDS_JAVA_HEAP
386 typedef ResourceHashtable<
387   const ModuleEntry*,
388   ModuleEntry*,
389   557, // prime number
390   AnyObj::C_HEAP> ArchivedModuleEntries;
391 static ArchivedModuleEntries* _archive_modules_entries = nullptr;
392 
393 #ifndef PRODUCT
394 static int _num_archived_module_entries = 0;
395 static int _num_inited_module_entries = 0;
396 #endif
397 
398 ModuleEntry* ModuleEntry::allocate_archived_entry() const {
399   assert(is_named(), "unnamed packages/modules are not archived");
400   ModuleEntry* archived_entry = (ModuleEntry*)ArchiveBuilder::rw_region_alloc(sizeof(ModuleEntry));
401   memcpy((void*)archived_entry, (void*)this, sizeof(ModuleEntry));
402   archived_entry->_archived_module_index = -1;
403 
404   if (_archive_modules_entries == nullptr) {
405     _archive_modules_entries = new (mtClass)ArchivedModuleEntries();
406   }
407   assert(_archive_modules_entries->get(this) == nullptr, "Each ModuleEntry must not be shared across ModuleEntryTables");
408   _archive_modules_entries->put(this, archived_entry);
409   DEBUG_ONLY(_num_archived_module_entries++);
410 
411   if (log_is_enabled(Info, cds, module)) {
412     ResourceMark rm;
413     LogStream ls(Log(cds, module)::info());
414     ls.print("Stored in archive: ");
415     archived_entry->print(&ls);
416   }
417   return archived_entry;
418 }
419 
420 bool ModuleEntry::has_been_archived() {
421   assert(!ArchiveBuilder::current()->is_in_buffer_space(this), "must be called on original ModuleEntry");
422   return _archive_modules_entries->contains(this);
423 }
424 
425 ModuleEntry* ModuleEntry::get_archived_entry(ModuleEntry* orig_entry) {
426   ModuleEntry** ptr = _archive_modules_entries->get(orig_entry);
427   assert(ptr != nullptr && *ptr != nullptr, "must have been allocated");
428   return *ptr;
429 }
430 
431 // This function is used to archive ModuleEntry::_reads and PackageEntry::_qualified_exports.
432 // GrowableArray cannot be directly archived, as it needs to be expandable at runtime.
433 // Write it out as an Array, and convert it back to GrowableArray at runtime.
434 Array<ModuleEntry*>* ModuleEntry::write_growable_array(ModuleEntry* module, GrowableArray<ModuleEntry*>* array) {
435   Array<ModuleEntry*>* archived_array = nullptr;
436   int length = (array == nullptr) ? 0 : array->length();
437   if (module->is_named()) {
438     if (Modules::is_dynamic_proxy_module(module)) {
439       // This is a dynamically generated module. Its opens and exports will be
440       // restored at runtime in the Java code. See comments in ArchivedData::restore().
441       return nullptr;
442     }
443   }
444   if (length > 0) {
445     archived_array = ArchiveBuilder::new_ro_array<ModuleEntry*>(length);
446     for (int i = 0; i < length; i++) {
447       ModuleEntry* archived_entry = get_archived_entry(array->at(i));
448       archived_array->at_put(i, archived_entry);
449       ArchivePtrMarker::mark_pointer((address*)archived_array->adr_at(i));
450     }
451   }
452 
453   return archived_array;
454 }
455 
456 GrowableArray<ModuleEntry*>* ModuleEntry::restore_growable_array(Array<ModuleEntry*>* archived_array) {
457   GrowableArray<ModuleEntry*>* array = nullptr;
458   int length = (archived_array == nullptr) ? 0 : archived_array->length();
459   if (length > 0) {
460     array = new (mtModule) GrowableArray<ModuleEntry*>(length, mtModule);
461     for (int i = 0; i < length; i++) {
462       ModuleEntry* archived_entry = archived_array->at(i);
463       array->append(archived_entry);
464     }
465   }
466 
467   return array;
468 }
469 
470 void ModuleEntry::iterate_symbols(MetaspaceClosure* closure) {
471   closure->push(&_name);
472   closure->push(&_version);
473   closure->push(&_location);
474 }
475 
476 void ModuleEntry::init_as_archived_entry() {
477   Array<ModuleEntry*>* archived_reads = write_growable_array(this, _reads);
478 
479   _loader_data = nullptr;  // re-init at runtime
480   _shared_path_index = FileMapInfo::get_module_shared_path_index(_location);
481   if (name() != nullptr) {
482     _name = ArchiveBuilder::get_buffered_symbol(_name);
483     ArchivePtrMarker::mark_pointer((address*)&_name);
484   }
485   _reads = (GrowableArray<ModuleEntry*>*)archived_reads;
486   if (_version != nullptr) {
487     _version = ArchiveBuilder::get_buffered_symbol(_version);
488   }
489   if (_location != nullptr) {
490     _location = ArchiveBuilder::get_buffered_symbol(_location);
491   }
492   JFR_ONLY(set_trace_id(0);) // re-init at runtime
493 
494   ArchivePtrMarker::mark_pointer((address*)&_reads);
495   ArchivePtrMarker::mark_pointer((address*)&_version);
496   ArchivePtrMarker::mark_pointer((address*)&_location);
497 }
498 
499 void ModuleEntry::update_oops_in_archived_module(int root_oop_index) {
500   assert(CDSConfig::is_dumping_full_module_graph(), "sanity");
501   assert(_archived_module_index == -1, "must be set exactly once");
502   assert(root_oop_index >= 0, "sanity");
503 
504   _archived_module_index = root_oop_index;
505 
506   assert(shared_protection_domain() == nullptr, "never set during -Xshare:dump");
507   // Clear handles and restore at run time. Handles cannot be archived.
508   OopHandle null_handle;
509   _module = null_handle;
510 
511   // For verify_archived_module_entries()
512   DEBUG_ONLY(_num_inited_module_entries++);
513 }
514 
515 #ifndef PRODUCT
516 void ModuleEntry::verify_archived_module_entries() {
517   assert(_num_archived_module_entries == _num_inited_module_entries,
518          "%d ModuleEntries have been archived but %d of them have been properly initialized with archived java.lang.Module objects",
519          _num_archived_module_entries, _num_inited_module_entries);
520 }
521 #endif // PRODUCT
522 
523 void ModuleEntry::load_from_archive(ClassLoaderData* loader_data) {
524   assert(CDSConfig::is_loading_full_module_graph(), "runtime only");
525   set_loader_data(loader_data);
526   _reads = restore_growable_array((Array<ModuleEntry*>*)_reads);
527   JFR_ONLY(INIT_ID(this);)
528 }
529 
530 void ModuleEntry::restore_archived_oops(ClassLoaderData* loader_data) {
531   assert(CDSConfig::is_loading_full_module_graph(), "runtime only");
532   Handle module_handle(Thread::current(), HeapShared::get_root(_archived_module_index, /*clear=*/true));
533   assert(module_handle.not_null(), "huh");
534   set_module(loader_data->add_handle(module_handle));
535 
536   // This was cleared to zero during dump time -- we didn't save the value
537   // because it may be affected by archive relocation.
538   java_lang_Module::set_module_entry(module_handle(), this);
539 
540   assert(java_lang_Module::loader(module_handle()) == loader_data->class_loader(),
541          "must be set in dump time");
542 
543   if (log_is_enabled(Info, cds, module)) {
544     ResourceMark rm;
545     LogStream ls(Log(cds, module)::info());
546     ls.print("Restored from archive: ");
547     print(&ls);
548   }
549 }
550 
551 void ModuleEntry::clear_archived_oops() {
552   assert(UseSharedSpaces && !CDSConfig::is_loading_full_module_graph(), "runtime only");
553   HeapShared::clear_root(_archived_module_index);
554 }
555 
556 static int compare_module_by_name(ModuleEntry* a, ModuleEntry* b) {
557   assert(a == b || a->name() != b->name(), "no duplicated names");
558   return a->name()->fast_compare(b->name());
559 }
560 
561 void ModuleEntryTable::iterate_symbols(MetaspaceClosure* closure) {
562   auto syms = [&] (const SymbolHandle& key, ModuleEntry*& m) {
563       m->iterate_symbols(closure);
564   };
565   _table.iterate_all(syms);
566 }
567 
568 Array<ModuleEntry*>* ModuleEntryTable::allocate_archived_entries() {
569   Array<ModuleEntry*>* archived_modules = ArchiveBuilder::new_rw_array<ModuleEntry*>(_table.number_of_entries());
570   int n = 0;
571   auto grab = [&] (const SymbolHandle& key, ModuleEntry*& m) {
572     archived_modules->at_put(n++, m);
573   };
574   _table.iterate_all(grab);
575 
576   if (n > 1) {
577     // Always allocate in the same order to produce deterministic archive.
578     QuickSort::sort(archived_modules->data(), n, (_sort_Fn)compare_module_by_name, true);
579   }
580   for (int i = 0; i < n; i++) {
581     archived_modules->at_put(i, archived_modules->at(i)->allocate_archived_entry());
582     ArchivePtrMarker::mark_pointer((address*)archived_modules->adr_at(i));
583   }
584   return archived_modules;
585 }
586 
587 void ModuleEntryTable::init_archived_entries(Array<ModuleEntry*>* archived_modules) {
588   assert(CDSConfig::is_dumping_full_module_graph(), "sanity");
589   for (int i = 0; i < archived_modules->length(); i++) {
590     ModuleEntry* archived_entry = archived_modules->at(i);
591     archived_entry->init_as_archived_entry();
592   }
593 }
594 
595 void ModuleEntryTable::load_archived_entries(ClassLoaderData* loader_data,
596                                              Array<ModuleEntry*>* archived_modules) {
597   assert(CDSConfig::is_loading_full_module_graph(), "runtime only");
598 
599   for (int i = 0; i < archived_modules->length(); i++) {
600     ModuleEntry* archived_entry = archived_modules->at(i);
601     archived_entry->load_from_archive(loader_data);
602     _table.put(archived_entry->name(), archived_entry);
603   }
604 }
605 
606 void ModuleEntryTable::restore_archived_oops(ClassLoaderData* loader_data, Array<ModuleEntry*>* archived_modules) {
607   assert(CDSConfig::is_loading_full_module_graph(), "runtime only");
608   for (int i = 0; i < archived_modules->length(); i++) {
609     ModuleEntry* archived_entry = archived_modules->at(i);
610     archived_entry->restore_archived_oops(loader_data);
611   }
612 }
613 #endif // INCLUDE_CDS_JAVA_HEAP
614 
615 // Create an entry in the class loader's module_entry_table.  It is the
616 // caller's responsibility to ensure that the entry has not already been
617 // created.
618 ModuleEntry* ModuleEntryTable::locked_create_entry(Handle module_handle,
619                                                    bool is_open,
620                                                    Symbol* module_name,
621                                                    Symbol* module_version,
622                                                    Symbol* module_location,
623                                                    ClassLoaderData* loader_data) {
624   assert(module_name != nullptr, "ModuleEntryTable locked_create_entry should never be called for unnamed module.");
625   assert(Module_lock->owned_by_self(), "should have the Module_lock");
626   assert(lookup_only(module_name) == nullptr, "Module already exists");
627   ModuleEntry* entry = new ModuleEntry(module_handle, is_open, module_name,
628                                        module_version, module_location, loader_data);
629   bool created = _table.put(module_name, entry);
630   assert(created, "should be");
631   return entry;
632 }
633 
634 // lookup_only by Symbol* to find a ModuleEntry.
635 ModuleEntry* ModuleEntryTable::lookup_only(Symbol* name) {
636   assert_locked_or_safepoint(Module_lock);
637   assert(name != nullptr, "name cannot be nullptr");
638   ModuleEntry** entry = _table.get(name);
639   return (entry == nullptr) ? nullptr : *entry;
640 }
641 
642 // Remove dead modules from all other alive modules' reads list.
643 // This should only occur at class unloading.
644 void ModuleEntryTable::purge_all_module_reads() {
645   assert_locked_or_safepoint(Module_lock);
646   auto purge = [&] (const SymbolHandle& key, ModuleEntry*& entry) {
647     entry->purge_reads();
648   };
649   _table.iterate_all(purge);
650 }
651 
652 void ModuleEntryTable::finalize_javabase(Handle module_handle, Symbol* version, Symbol* location) {
653   assert(Module_lock->owned_by_self(), "should have the Module_lock");
654   ClassLoaderData* boot_loader_data = ClassLoaderData::the_null_class_loader_data();
655   ModuleEntryTable* module_table = boot_loader_data->modules();
656 
657   assert(module_table != nullptr, "boot loader's ModuleEntryTable not defined");
658 
659   if (module_handle.is_null()) {
660     fatal("Unable to finalize module definition for " JAVA_BASE_NAME);
661   }
662 
663   // Set java.lang.Module, version and location for java.base
664   ModuleEntry* jb_module = javabase_moduleEntry();
665   assert(jb_module != nullptr, JAVA_BASE_NAME " ModuleEntry not defined");
666   jb_module->set_version(version);
667   jb_module->set_location(location);
668   // Once java.base's ModuleEntry _module field is set with the known
669   // java.lang.Module, java.base is considered "defined" to the VM.
670   jb_module->set_module(boot_loader_data->add_handle(module_handle));
671 
672   // Store pointer to the ModuleEntry for java.base in the java.lang.Module object.
673   java_lang_Module::set_module_entry(module_handle(), jb_module);
674 }
675 
676 // Within java.lang.Class instances there is a java.lang.Module field that must
677 // be set with the defining module.  During startup, prior to java.base's definition,
678 // classes needing their module field set are added to the fixup_module_list.
679 // Their module field is set once java.base's java.lang.Module is known to the VM.
680 void ModuleEntryTable::patch_javabase_entries(JavaThread* current, Handle module_handle) {
681   if (module_handle.is_null()) {
682     fatal("Unable to patch the module field of classes loaded prior to "
683           JAVA_BASE_NAME "'s definition, invalid java.lang.Module");
684   }
685 
686   // Do the fixups for the basic primitive types
687   java_lang_Class::set_module(Universe::int_mirror(), module_handle());
688   java_lang_Class::set_module(Universe::float_mirror(), module_handle());
689   java_lang_Class::set_module(Universe::double_mirror(), module_handle());
690   java_lang_Class::set_module(Universe::byte_mirror(), module_handle());
691   java_lang_Class::set_module(Universe::bool_mirror(), module_handle());
692   java_lang_Class::set_module(Universe::char_mirror(), module_handle());
693   java_lang_Class::set_module(Universe::long_mirror(), module_handle());
694   java_lang_Class::set_module(Universe::short_mirror(), module_handle());
695   java_lang_Class::set_module(Universe::void_mirror(), module_handle());
696 
697   // Do the fixups for classes that have already been created.
698   GrowableArray <Klass*>* list = java_lang_Class::fixup_module_field_list();
699   int list_length = list->length();
700   for (int i = 0; i < list_length; i++) {
701     Klass* k = list->at(i);
702     assert(k->is_klass(), "List should only hold classes");
703 #ifndef PRODUCT
704     if (HeapShared::is_a_test_class_in_unnamed_module(k)) {
705       // We allow -XX:ArchiveHeapTestClass to archive additional classes
706       // into the CDS heap, but these must be in the unnamed module.
707       ModuleEntry* unnamed_module = ClassLoaderData::the_null_class_loader_data()->unnamed_module();
708       Handle unnamed_module_handle(current, unnamed_module->module());
709       java_lang_Class::fixup_module_field(k, unnamed_module_handle);
710     } else
711 #endif
712     {
713       java_lang_Class::fixup_module_field(k, module_handle);
714     }
715     k->class_loader_data()->dec_keep_alive();
716   }
717 
718   delete java_lang_Class::fixup_module_field_list();
719   java_lang_Class::set_fixup_module_field_list(nullptr);
720 }
721 
722 void ModuleEntryTable::print(outputStream* st) {
723   ResourceMark rm;
724   auto printer = [&] (const SymbolHandle& name, ModuleEntry*& entry) {
725     entry->print(st);
726   };
727   st->print_cr("Module Entry Table (table_size=%d, entries=%d)",
728                _table.table_size(), _table.number_of_entries());
729   assert_locked_or_safepoint(Module_lock);
730   _table.iterate_all(printer);
731 }
732 
733 void ModuleEntryTable::modules_do(void f(ModuleEntry*)) {
734   auto do_f = [&] (const SymbolHandle& key, ModuleEntry*& entry) {
735     f(entry);
736   };
737   assert_lock_strong(Module_lock);
738   _table.iterate_all(do_f);
739 }
740 
741 void ModuleEntryTable::modules_do(ModuleClosure* closure) {
742   auto do_f = [&] (const SymbolHandle& key, ModuleEntry*& entry) {
743     closure->do_module(entry);
744   };
745   assert_lock_strong(Module_lock);
746   _table.iterate_all(do_f);
747 }
748 
749 void ModuleEntry::print(outputStream* st) {
750   st->print_cr("entry " PTR_FORMAT " name %s module " PTR_FORMAT " loader %s version %s location %s strict %s",
751                p2i(this),
752                name() == nullptr ? UNNAMED_MODULE : name()->as_C_string(),
753                p2i(module()),
754                loader_data()->loader_name_and_id(),
755                version() != nullptr ? version()->as_C_string() : "nullptr",
756                location() != nullptr ? location()->as_C_string() : "nullptr",
757                BOOL_TO_STR(!can_read_all_unnamed()));
758 }
759 
760 void ModuleEntryTable::verify() {
761   auto do_f = [&] (const SymbolHandle& key, ModuleEntry*& entry) {
762     entry->verify();
763   };
764   assert_locked_or_safepoint(Module_lock);
765   _table.iterate_all(do_f);
766 }
767 
768 void ModuleEntry::verify() {
769   guarantee(loader_data() != nullptr, "A module entry must be associated with a loader.");
770 }