1 /*
   2  * Copyright (c) 2018, 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/aotClassInitializer.hpp"
  27 #include "cds/archiveBuilder.hpp"
  28 #include "cds/archiveHeapLoader.hpp"
  29 #include "cds/archiveHeapWriter.hpp"
  30 #include "cds/archiveUtils.hpp"
  31 #include "cds/cdsConfig.hpp"
  32 #include "cds/cdsEnumKlass.hpp"
  33 #include "cds/cdsHeapVerifier.hpp"
  34 #include "cds/heapShared.hpp"
  35 #include "cds/metaspaceShared.hpp"
  36 #include "classfile/classLoaderData.hpp"
  37 #include "classfile/classLoaderExt.hpp"
  38 #include "classfile/javaClasses.inline.hpp"
  39 #include "classfile/modules.hpp"
  40 #include "classfile/stringTable.hpp"
  41 #include "classfile/symbolTable.hpp"
  42 #include "classfile/systemDictionary.hpp"
  43 #include "classfile/systemDictionaryShared.hpp"
  44 #include "classfile/vmClasses.hpp"
  45 #include "classfile/vmSymbols.hpp"
  46 #include "gc/shared/collectedHeap.hpp"
  47 #include "gc/shared/gcLocker.hpp"
  48 #include "gc/shared/gcVMOperations.hpp"
  49 #include "logging/log.hpp"
  50 #include "logging/logStream.hpp"
  51 #include "memory/iterator.inline.hpp"
  52 #include "memory/resourceArea.hpp"
  53 #include "memory/universe.hpp"
  54 #include "oops/compressedOops.inline.hpp"
  55 #include "oops/fieldStreams.inline.hpp"
  56 #include "oops/objArrayOop.inline.hpp"
  57 #include "oops/oop.inline.hpp"
  58 #include "oops/typeArrayOop.inline.hpp"
  59 #include "prims/jvmtiExport.hpp"
  60 #include "runtime/arguments.hpp"
  61 #include "runtime/fieldDescriptor.inline.hpp"
  62 #include "runtime/init.hpp"
  63 #include "runtime/javaCalls.hpp"
  64 #include "runtime/mutexLocker.hpp"
  65 #include "runtime/safepointVerifiers.hpp"
  66 #include "utilities/bitMap.inline.hpp"
  67 #include "utilities/copy.hpp"
  68 #if INCLUDE_G1GC
  69 #include "gc/g1/g1CollectedHeap.hpp"
  70 #endif
  71 
  72 #if INCLUDE_CDS_JAVA_HEAP
  73 
  74 struct ArchivableStaticFieldInfo {
  75   const char* klass_name;
  76   const char* field_name;
  77   InstanceKlass* klass;
  78   int offset;
  79   BasicType type;
  80 
  81   ArchivableStaticFieldInfo(const char* k, const char* f)
  82   : klass_name(k), field_name(f), klass(nullptr), offset(0), type(T_ILLEGAL) {}
  83 
  84   bool valid() {
  85     return klass_name != nullptr;
  86   }
  87 };
  88 
  89 bool HeapShared::_disable_writing = false;
  90 DumpedInternedStrings *HeapShared::_dumped_interned_strings = nullptr;
  91 
  92 size_t HeapShared::_alloc_count[HeapShared::ALLOC_STAT_SLOTS];
  93 size_t HeapShared::_alloc_size[HeapShared::ALLOC_STAT_SLOTS];
  94 size_t HeapShared::_total_obj_count;
  95 size_t HeapShared::_total_obj_size;
  96 
  97 #ifndef PRODUCT
  98 #define ARCHIVE_TEST_FIELD_NAME "archivedObjects"
  99 static Array<char>* _archived_ArchiveHeapTestClass = nullptr;
 100 static const char* _test_class_name = nullptr;
 101 static Klass* _test_class = nullptr;
 102 static const ArchivedKlassSubGraphInfoRecord* _test_class_record = nullptr;
 103 #endif
 104 
 105 
 106 //
 107 // If you add new entries to the following tables, you should know what you're doing!
 108 //
 109 
 110 static ArchivableStaticFieldInfo archive_subgraph_entry_fields[] = {
 111   {"java/lang/Integer$IntegerCache",              "archivedCache"},
 112   {"java/lang/Long$LongCache",                    "archivedCache"},
 113   {"java/lang/Byte$ByteCache",                    "archivedCache"},
 114   {"java/lang/Short$ShortCache",                  "archivedCache"},
 115   {"java/lang/Character$CharacterCache",          "archivedCache"},
 116   {"java/util/jar/Attributes$Name",               "KNOWN_NAMES"},
 117   {"sun/util/locale/BaseLocale",                  "constantBaseLocales"},
 118   {"jdk/internal/module/ArchivedModuleGraph",     "archivedModuleGraph"},
 119   {"java/util/ImmutableCollections",              "archivedObjects"},
 120   {"java/lang/ModuleLayer",                       "EMPTY_LAYER"},
 121   {"java/lang/module/Configuration",              "EMPTY_CONFIGURATION"},
 122   {"jdk/internal/math/FDBigInteger",              "archivedCaches"},
 123 
 124 #ifndef PRODUCT
 125   {nullptr, nullptr}, // Extra slot for -XX:ArchiveHeapTestClass
 126 #endif
 127   {nullptr, nullptr},
 128 };
 129 
 130 // full module graph
 131 static ArchivableStaticFieldInfo fmg_archive_subgraph_entry_fields[] = {
 132   {"jdk/internal/loader/ArchivedClassLoaders",    "archivedClassLoaders"},
 133   {ARCHIVED_BOOT_LAYER_CLASS,                     ARCHIVED_BOOT_LAYER_FIELD},
 134   {"java/lang/Module$ArchivedData",               "archivedData"},
 135   {nullptr, nullptr},
 136 };
 137 
 138 KlassSubGraphInfo* HeapShared::_dump_time_special_subgraph;
 139 ArchivedKlassSubGraphInfoRecord* HeapShared::_run_time_special_subgraph;
 140 GrowableArrayCHeap<oop, mtClassShared>* HeapShared::_pending_roots = nullptr;
 141 GrowableArrayCHeap<OopHandle, mtClassShared>* HeapShared::_root_segments;
 142 int HeapShared::_root_segment_max_size_elems;
 143 OopHandle HeapShared::_scratch_basic_type_mirrors[T_VOID+1];
 144 MetaspaceObjToOopHandleTable* HeapShared::_scratch_java_mirror_table = nullptr;
 145 MetaspaceObjToOopHandleTable* HeapShared::_scratch_references_table = nullptr;
 146 
 147 static bool is_subgraph_root_class_of(ArchivableStaticFieldInfo fields[], InstanceKlass* ik) {
 148   for (int i = 0; fields[i].valid(); i++) {
 149     if (fields[i].klass == ik) {
 150       return true;
 151     }
 152   }
 153   return false;
 154 }
 155 
 156 bool HeapShared::is_subgraph_root_class(InstanceKlass* ik) {
 157   return is_subgraph_root_class_of(archive_subgraph_entry_fields, ik) ||
 158          is_subgraph_root_class_of(fmg_archive_subgraph_entry_fields, ik);
 159 }
 160 
 161 unsigned HeapShared::oop_hash(oop const& p) {
 162   // Do not call p->identity_hash() as that will update the
 163   // object header.
 164   return primitive_hash(cast_from_oop<intptr_t>(p));
 165 }
 166 
 167 static void reset_states(oop obj, TRAPS) {
 168   Handle h_obj(THREAD, obj);
 169   InstanceKlass* klass = InstanceKlass::cast(obj->klass());
 170   TempNewSymbol method_name = SymbolTable::new_symbol("resetArchivedStates");
 171   Symbol* method_sig = vmSymbols::void_method_signature();
 172 
 173   while (klass != nullptr) {
 174     Method* method = klass->find_method(method_name, method_sig);
 175     if (method != nullptr) {
 176       assert(method->is_private(), "must be");
 177       if (log_is_enabled(Debug, cds)) {
 178         ResourceMark rm(THREAD);
 179         log_debug(cds)("  calling %s", method->name_and_sig_as_C_string());
 180       }
 181       JavaValue result(T_VOID);
 182       JavaCalls::call_special(&result, h_obj, klass,
 183                               method_name, method_sig, CHECK);
 184     }
 185     klass = klass->java_super();
 186   }
 187 }
 188 
 189 void HeapShared::reset_archived_object_states(TRAPS) {
 190   assert(CDSConfig::is_dumping_heap(), "dump-time only");
 191   log_debug(cds)("Resetting platform loader");
 192   reset_states(SystemDictionary::java_platform_loader(), CHECK);
 193   log_debug(cds)("Resetting system loader");
 194   reset_states(SystemDictionary::java_system_loader(), CHECK);
 195 
 196   // Clean up jdk.internal.loader.ClassLoaders::bootLoader(), which is not
 197   // directly used for class loading, but rather is used by the core library
 198   // to keep track of resources, etc, loaded by the null class loader.
 199   //
 200   // Note, this object is non-null, and is not the same as
 201   // ClassLoaderData::the_null_class_loader_data()->class_loader(),
 202   // which is null.
 203   log_debug(cds)("Resetting boot loader");
 204   JavaValue result(T_OBJECT);
 205   JavaCalls::call_static(&result,
 206                          vmClasses::jdk_internal_loader_ClassLoaders_klass(),
 207                          vmSymbols::bootLoader_name(),
 208                          vmSymbols::void_BuiltinClassLoader_signature(),
 209                          CHECK);
 210   Handle boot_loader(THREAD, result.get_oop());
 211   reset_states(boot_loader(), CHECK);
 212 }
 213 
 214 HeapShared::ArchivedObjectCache* HeapShared::_archived_object_cache = nullptr;
 215 
 216 bool HeapShared::has_been_archived(oop obj) {
 217   assert(CDSConfig::is_dumping_heap(), "dump-time only");
 218   return archived_object_cache()->get(obj) != nullptr;
 219 }
 220 
 221 int HeapShared::append_root(oop obj) {
 222   assert(CDSConfig::is_dumping_heap(), "dump-time only");
 223 
 224   // No GC should happen since we aren't scanning _pending_roots.
 225   assert(Thread::current() == (Thread*)VMThread::vm_thread(), "should be in vm thread");
 226 
 227   if (_pending_roots == nullptr) {
 228     _pending_roots = new GrowableArrayCHeap<oop, mtClassShared>(500);
 229   }
 230 
 231   return _pending_roots->append(obj);
 232 }
 233 
 234 objArrayOop HeapShared::root_segment(int segment_idx) {
 235   if (CDSConfig::is_dumping_heap()) {
 236     assert(Thread::current() == (Thread*)VMThread::vm_thread(), "should be in vm thread");
 237     if (!HeapShared::can_write()) {
 238       return nullptr;
 239     }
 240   } else {
 241     assert(CDSConfig::is_using_archive(), "must be");
 242   }
 243 
 244   objArrayOop segment = (objArrayOop)_root_segments->at(segment_idx).resolve();
 245   assert(segment != nullptr, "should have been initialized");
 246   return segment;
 247 }
 248 
 249 void HeapShared::get_segment_indexes(int idx, int& seg_idx, int& int_idx) {
 250   assert(_root_segment_max_size_elems > 0, "sanity");
 251 
 252   // Try to avoid divisions for the common case.
 253   if (idx < _root_segment_max_size_elems) {
 254     seg_idx = 0;
 255     int_idx = idx;
 256   } else {
 257     seg_idx = idx / _root_segment_max_size_elems;
 258     int_idx = idx % _root_segment_max_size_elems;
 259   }
 260 
 261   assert(idx == seg_idx * _root_segment_max_size_elems + int_idx,
 262          "sanity: %d index maps to %d segment and %d internal", idx, seg_idx, int_idx);
 263 }
 264 
 265 // Returns an objArray that contains all the roots of the archived objects
 266 oop HeapShared::get_root(int index, bool clear) {
 267   assert(index >= 0, "sanity");
 268   assert(!CDSConfig::is_dumping_heap() && CDSConfig::is_using_archive(), "runtime only");
 269   assert(!_root_segments->is_empty(), "must have loaded shared heap");
 270   int seg_idx, int_idx;
 271   get_segment_indexes(index, seg_idx, int_idx);
 272   oop result = root_segment(seg_idx)->obj_at(int_idx);
 273   if (clear) {
 274     clear_root(index);
 275   }
 276   return result;
 277 }
 278 
 279 void HeapShared::clear_root(int index) {
 280   assert(index >= 0, "sanity");
 281   assert(CDSConfig::is_using_archive(), "must be");
 282   if (ArchiveHeapLoader::is_in_use()) {
 283     int seg_idx, int_idx;
 284     get_segment_indexes(index, seg_idx, int_idx);
 285     if (log_is_enabled(Debug, cds, heap)) {
 286       oop old = root_segment(seg_idx)->obj_at(int_idx);
 287       log_debug(cds, heap)("Clearing root %d: was " PTR_FORMAT, index, p2i(old));
 288     }
 289     root_segment(seg_idx)->obj_at_put(int_idx, nullptr);
 290   }
 291 }
 292 
 293 bool HeapShared::archive_object(oop obj) {
 294   assert(CDSConfig::is_dumping_heap(), "dump-time only");
 295 
 296   assert(!obj->is_stackChunk(), "do not archive stack chunks");
 297   if (has_been_archived(obj)) {
 298     return true;
 299   }
 300 
 301   if (ArchiveHeapWriter::is_too_large_to_archive(obj->size())) {
 302     log_debug(cds, heap)("Cannot archive, object (" PTR_FORMAT ") is too large: " SIZE_FORMAT,
 303                          p2i(obj), obj->size());
 304     debug_trace();
 305     return false;
 306   } else {
 307     count_allocation(obj->size());
 308     ArchiveHeapWriter::add_source_obj(obj);
 309     CachedOopInfo info = make_cached_oop_info(obj);
 310     archived_object_cache()->put_when_absent(obj, info);
 311     archived_object_cache()->maybe_grow();
 312     mark_native_pointers(obj);
 313 
 314     if (log_is_enabled(Debug, cds, heap)) {
 315       ResourceMark rm;
 316       LogTarget(Debug, cds, heap) log;
 317       LogStream out(log);
 318       out.print("Archived heap object " PTR_FORMAT " : %s ",
 319                 p2i(obj), obj->klass()->external_name());
 320       if (java_lang_Class::is_instance(obj)) {
 321         Klass* k = java_lang_Class::as_Klass(obj);
 322         if (k != nullptr) {
 323           out.print("%s", k->external_name());
 324         } else {
 325           out.print("primitive");
 326         }
 327       }
 328       out.cr();
 329     }
 330 
 331     if (java_lang_Module::is_instance(obj) && Modules::check_archived_module_oop(obj)) {
 332       Modules::update_oops_in_archived_module(obj, append_root(obj));
 333     }
 334 
 335     return true;
 336   }
 337 }
 338 
 339 class MetaspaceObjToOopHandleTable: public ResourceHashtable<MetaspaceObj*, OopHandle,
 340     36137, // prime number
 341     AnyObj::C_HEAP,
 342     mtClassShared> {
 343 public:
 344   oop get_oop(MetaspaceObj* ptr) {
 345     MutexLocker ml(ScratchObjects_lock, Mutex::_no_safepoint_check_flag);
 346     OopHandle* handle = get(ptr);
 347     if (handle != nullptr) {
 348       return handle->resolve();
 349     } else {
 350       return nullptr;
 351     }
 352   }
 353   void set_oop(MetaspaceObj* ptr, oop o) {
 354     MutexLocker ml(ScratchObjects_lock, Mutex::_no_safepoint_check_flag);
 355     OopHandle handle(Universe::vm_global(), o);
 356     bool is_new = put(ptr, handle);
 357     assert(is_new, "cannot set twice");
 358   }
 359   void remove_oop(MetaspaceObj* ptr) {
 360     MutexLocker ml(ScratchObjects_lock, Mutex::_no_safepoint_check_flag);
 361     OopHandle* handle = get(ptr);
 362     if (handle != nullptr) {
 363       handle->release(Universe::vm_global());
 364       remove(ptr);
 365     }
 366   }
 367 };
 368 
 369 void HeapShared::add_scratch_resolved_references(ConstantPool* src, objArrayOop dest) {
 370   _scratch_references_table->set_oop(src, dest);
 371 }
 372 
 373 objArrayOop HeapShared::scratch_resolved_references(ConstantPool* src) {
 374   return (objArrayOop)_scratch_references_table->get_oop(src);
 375 }
 376 
 377 void HeapShared::init_scratch_objects(TRAPS) {
 378   for (int i = T_BOOLEAN; i < T_VOID+1; i++) {
 379     BasicType bt = (BasicType)i;
 380     if (!is_reference_type(bt)) {
 381       oop m = java_lang_Class::create_basic_type_mirror(type2name(bt), bt, CHECK);
 382       _scratch_basic_type_mirrors[i] = OopHandle(Universe::vm_global(), m);
 383     }
 384   }
 385   _scratch_java_mirror_table = new (mtClass)MetaspaceObjToOopHandleTable();
 386   _scratch_references_table = new (mtClass)MetaspaceObjToOopHandleTable();
 387 }
 388 
 389 // Given java_mirror that represents a (primitive or reference) type T,
 390 // return the "scratch" version that represents the same type T.
 391 // Note that if java_mirror will be returned if it's already a
 392 // scratch mirror.
 393 //
 394 // See java_lang_Class::create_scratch_mirror() for more info.
 395 oop HeapShared::scratch_java_mirror(oop java_mirror) {
 396   assert(java_lang_Class::is_instance(java_mirror), "must be");
 397 
 398   for (int i = T_BOOLEAN; i < T_VOID+1; i++) {
 399     BasicType bt = (BasicType)i;
 400     if (!is_reference_type(bt)) {
 401       if (_scratch_basic_type_mirrors[i].resolve() == java_mirror) {
 402         return java_mirror;
 403       }
 404     }
 405   }
 406 
 407   if (java_lang_Class::is_primitive(java_mirror)) {
 408     return scratch_java_mirror(java_lang_Class::as_BasicType(java_mirror));
 409   } else {
 410     return scratch_java_mirror(java_lang_Class::as_Klass(java_mirror));
 411   }
 412 }
 413 
 414 oop HeapShared::scratch_java_mirror(BasicType t) {
 415   assert((uint)t < T_VOID+1, "range check");
 416   assert(!is_reference_type(t), "sanity");
 417   return _scratch_basic_type_mirrors[t].resolve();
 418 }
 419 
 420 oop HeapShared::scratch_java_mirror(Klass* k) {
 421   return _scratch_java_mirror_table->get_oop(k);
 422 }
 423 
 424 void HeapShared::set_scratch_java_mirror(Klass* k, oop mirror) {
 425   _scratch_java_mirror_table->set_oop(k, mirror);
 426 }
 427 
 428 void HeapShared::remove_scratch_objects(Klass* k) {
 429   // Klass is being deallocated. Java mirror can still be alive, and it should not
 430   // point to dead klass. We need to break the link from mirror to the Klass.
 431   // See how InstanceKlass::deallocate_contents does it for normal mirrors.
 432   oop mirror = _scratch_java_mirror_table->get_oop(k);
 433   if (mirror != nullptr) {
 434     java_lang_Class::set_klass(mirror, nullptr);
 435   }
 436   _scratch_java_mirror_table->remove_oop(k);
 437   if (k->is_instance_klass()) {
 438     _scratch_references_table->remove(InstanceKlass::cast(k)->constants());
 439   }
 440 }
 441 
 442 //TODO: we eventually want a more direct test for these kinds of things.
 443 //For example the JVM could record some bit of context from the creation
 444 //of the klass, such as who called the hidden class factory.  Using
 445 //string compares on names is fragile and will break as soon as somebody
 446 //changes the names in the JDK code.  See discussion in JDK-8342481 for
 447 //related ideas about marking AOT-related classes.
 448 bool HeapShared::is_lambda_form_klass(InstanceKlass* ik) {
 449   return ik->is_hidden() &&
 450     (ik->name()->starts_with("java/lang/invoke/LambdaForm$MH+") ||
 451      ik->name()->starts_with("java/lang/invoke/LambdaForm$DMH+") ||
 452      ik->name()->starts_with("java/lang/invoke/LambdaForm$BMH+") ||
 453      ik->name()->starts_with("java/lang/invoke/LambdaForm$VH+"));
 454 }
 455 
 456 bool HeapShared::is_lambda_proxy_klass(InstanceKlass* ik) {
 457   return ik->is_hidden() && (ik->name()->index_of_at(0, "$$Lambda+", 9) > 0);
 458 }
 459 
 460 bool HeapShared::is_string_concat_klass(InstanceKlass* ik) {
 461   return ik->is_hidden() && ik->name()->starts_with("java/lang/String$$StringConcat");
 462 }
 463 
 464 bool HeapShared::is_archivable_hidden_klass(InstanceKlass* ik) {
 465   return CDSConfig::is_dumping_invokedynamic() &&
 466     (is_lambda_form_klass(ik) || is_lambda_proxy_klass(ik) || is_string_concat_klass(ik));
 467 }
 468 
 469 void HeapShared::copy_aot_initialized_mirror(Klass* orig_k, oop orig_mirror, oop m) {
 470   assert(orig_k->is_instance_klass(), "sanity");
 471   InstanceKlass* ik = InstanceKlass::cast(orig_k);
 472   InstanceKlass* buffered_ik = ArchiveBuilder::current()->get_buffered_addr(ik);
 473 
 474   assert(ik->is_initialized(), "must be");
 475 
 476   int nfields = 0;
 477   for (JavaFieldStream fs(ik); !fs.done(); fs.next()) {
 478     if (fs.access_flags().is_static()) {
 479       fieldDescriptor& fd = fs.field_descriptor();
 480       int offset = fd.offset();
 481       switch (fd.field_type()) {
 482       case T_OBJECT:
 483       case T_ARRAY:
 484         m->obj_field_put(offset, orig_mirror->obj_field(offset));
 485         break;
 486       case T_BOOLEAN:
 487         m->bool_field_put(offset, orig_mirror->bool_field(offset));
 488         break;
 489       case T_BYTE:
 490         m->byte_field_put(offset, orig_mirror->byte_field(offset));
 491         break;
 492       case T_SHORT:
 493         m->short_field_put(offset, orig_mirror->short_field(offset));
 494         break;
 495       case T_CHAR:
 496         m->char_field_put(offset, orig_mirror->char_field(offset));
 497         break;
 498       case T_INT:
 499         m->int_field_put(offset, orig_mirror->int_field(offset));
 500         break;
 501       case T_LONG:
 502         m->long_field_put(offset, orig_mirror->long_field(offset));
 503         break;
 504       case T_FLOAT:
 505         m->float_field_put(offset, orig_mirror->float_field(offset));
 506         break;
 507       case T_DOUBLE:
 508         m->double_field_put(offset, orig_mirror->double_field(offset));
 509         break;
 510       default:
 511         ShouldNotReachHere();
 512       }
 513       nfields ++;
 514     }
 515   }
 516 
 517   java_lang_Class::set_class_data(m, java_lang_Class::class_data(orig_mirror));
 518 
 519   // Class::reflectData use SoftReference, which cannot be archived. Set it
 520   // to null and it will be recreated at runtime.
 521   java_lang_Class::set_reflection_data(m, nullptr);
 522 
 523   if (log_is_enabled(Info, cds, init)) {
 524     ResourceMark rm;
 525     log_debug(cds, init)("copied %3d field(s) in aot-initialized mirror %s%s", nfields, ik->external_name(),
 526                          ik->is_hidden() ? " (hidden)" : "");
 527   }
 528 }
 529 
 530 static void copy_java_mirror_hashcode(oop orig_mirror, oop scratch_m) {
 531   // We need to retain the identity_hash, because it may have been used by some hashtables
 532   // in the shared heap.
 533   if (!orig_mirror->fast_no_hash_check()) {
 534     intptr_t src_hash = orig_mirror->identity_hash();
 535     if (UseCompactObjectHeaders) {
 536       narrowKlass nk = CompressedKlassPointers::encode(orig_mirror->klass());
 537       scratch_m->set_mark(markWord::prototype().set_narrow_klass(nk).copy_set_hash(src_hash));
 538     } else {
 539       scratch_m->set_mark(markWord::prototype().copy_set_hash(src_hash));
 540     }
 541     assert(scratch_m->mark().is_unlocked(), "sanity");
 542 
 543     DEBUG_ONLY(intptr_t archived_hash = scratch_m->identity_hash());
 544     assert(src_hash == archived_hash, "Different hash codes: original " INTPTR_FORMAT ", archived " INTPTR_FORMAT, src_hash, archived_hash);
 545   }
 546 }
 547 
 548 static objArrayOop get_archived_resolved_references(InstanceKlass* src_ik) {
 549   InstanceKlass* buffered_ik = ArchiveBuilder::current()->get_buffered_addr(src_ik);
 550   if (buffered_ik->is_shared_boot_class() ||
 551       buffered_ik->is_shared_platform_class() ||
 552       buffered_ik->is_shared_app_class()) {
 553     objArrayOop rr = src_ik->constants()->resolved_references_or_null();
 554     if (rr != nullptr && !ArchiveHeapWriter::is_too_large_to_archive(rr)) {
 555       return HeapShared::scratch_resolved_references(src_ik->constants());
 556     }
 557   }
 558   return nullptr;
 559 }
 560 
 561 void HeapShared::archive_java_mirrors() {
 562   for (int i = T_BOOLEAN; i < T_VOID+1; i++) {
 563     BasicType bt = (BasicType)i;
 564     if (!is_reference_type(bt)) {
 565       oop orig_mirror = Universe::java_mirror(bt);
 566       oop m = _scratch_basic_type_mirrors[i].resolve();
 567       assert(m != nullptr, "sanity");
 568       copy_java_mirror_hashcode(orig_mirror, m);
 569       bool success = archive_reachable_objects_from(1, _dump_time_special_subgraph, m);
 570       assert(success, "sanity");
 571 
 572       log_trace(cds, heap, mirror)(
 573         "Archived %s mirror object from " PTR_FORMAT,
 574         type2name(bt), p2i(m));
 575 
 576       Universe::set_archived_basic_type_mirror_index(bt, append_root(m));
 577     }
 578   }
 579 
 580   GrowableArray<Klass*>* klasses = ArchiveBuilder::current()->klasses();
 581   assert(klasses != nullptr, "sanity");
 582 
 583   for (int i = 0; i < klasses->length(); i++) {
 584     Klass* orig_k = klasses->at(i);
 585     oop orig_mirror = orig_k->java_mirror();
 586     oop m = scratch_java_mirror(orig_k);
 587     if (m != nullptr) {
 588       copy_java_mirror_hashcode(orig_mirror, m);
 589     }
 590   }
 591 
 592   for (int i = 0; i < klasses->length(); i++) {
 593     Klass* orig_k = klasses->at(i);
 594     oop orig_mirror = orig_k->java_mirror();
 595     oop m = scratch_java_mirror(orig_k);
 596     if (m != nullptr) {
 597       Klass* buffered_k = ArchiveBuilder::get_buffered_klass(orig_k);
 598       bool success = archive_reachable_objects_from(1, _dump_time_special_subgraph, m);
 599       guarantee(success, "scratch mirrors must point to only archivable objects");
 600       buffered_k->set_archived_java_mirror(append_root(m));
 601       ResourceMark rm;
 602       log_trace(cds, heap, mirror)(
 603         "Archived %s mirror object from " PTR_FORMAT,
 604         buffered_k->external_name(), p2i(m));
 605 
 606       // archive the resolved_referenes array
 607       if (buffered_k->is_instance_klass()) {
 608         InstanceKlass* ik = InstanceKlass::cast(buffered_k);
 609         objArrayOop rr = get_archived_resolved_references(InstanceKlass::cast(orig_k));
 610         if (rr != nullptr) {
 611           bool success = HeapShared::archive_reachable_objects_from(1, _dump_time_special_subgraph, rr);
 612           assert(success, "must be");
 613           int root_index = append_root(rr);
 614           ik->constants()->cache()->set_archived_references(root_index);
 615         }
 616       }
 617     }
 618   }
 619 }
 620 
 621 void HeapShared::archive_strings() {
 622   oop shared_strings_array = StringTable::init_shared_table(_dumped_interned_strings);
 623   bool success = archive_reachable_objects_from(1, _dump_time_special_subgraph, shared_strings_array);
 624   // We must succeed because:
 625   // - _dumped_interned_strings do not contain any large strings.
 626   // - StringTable::init_shared_table() doesn't create any large arrays.
 627   assert(success, "shared strings array must not point to arrays or strings that are too large to archive");
 628   StringTable::set_shared_strings_array_index(append_root(shared_strings_array));
 629 }
 630 
 631 int HeapShared::archive_exception_instance(oop exception) {
 632   bool success = archive_reachable_objects_from(1, _dump_time_special_subgraph, exception);
 633   assert(success, "sanity");
 634   return append_root(exception);
 635 }
 636 
 637 void HeapShared::mark_native_pointers(oop orig_obj) {
 638   if (java_lang_Class::is_instance(orig_obj)) {
 639     ArchiveHeapWriter::mark_native_pointer(orig_obj, java_lang_Class::klass_offset());
 640     ArchiveHeapWriter::mark_native_pointer(orig_obj, java_lang_Class::array_klass_offset());
 641   } else if (java_lang_invoke_ResolvedMethodName::is_instance(orig_obj)) {
 642     ArchiveHeapWriter::mark_native_pointer(orig_obj, java_lang_invoke_ResolvedMethodName::vmtarget_offset());
 643   }
 644 }
 645 
 646 void HeapShared::get_pointer_info(oop src_obj, bool& has_oop_pointers, bool& has_native_pointers) {
 647   CachedOopInfo* info = archived_object_cache()->get(src_obj);
 648   assert(info != nullptr, "must be");
 649   has_oop_pointers = info->has_oop_pointers();
 650   has_native_pointers = info->has_native_pointers();
 651 }
 652 
 653 void HeapShared::set_has_native_pointers(oop src_obj) {
 654   CachedOopInfo* info = archived_object_cache()->get(src_obj);
 655   assert(info != nullptr, "must be");
 656   info->set_has_native_pointers();
 657 }
 658 
 659 void HeapShared::start_finding_required_hidden_classes() {
 660   if (!CDSConfig::is_dumping_invokedynamic()) {
 661     return;
 662   }
 663   NoSafepointVerifier nsv;
 664 
 665   init_seen_objects_table();
 666 
 667   // We first scan the objects that are known to be archived (from the archive_subgraph
 668   // tables)
 669   find_required_hidden_classes_helper(archive_subgraph_entry_fields);
 670   if (CDSConfig::is_dumping_full_module_graph()) {
 671     find_required_hidden_classes_helper(fmg_archive_subgraph_entry_fields);
 672   }
 673 
 674   // Later, SystemDictionaryShared::find_all_archivable_classes_impl() will start
 675   // scanning the constant pools of all classes that it decides to archive.
 676 }
 677 
 678 void HeapShared::end_finding_required_hidden_classes() {
 679   if (!CDSConfig::is_dumping_invokedynamic()) {
 680     return;
 681   }
 682   NoSafepointVerifier nsv;
 683 
 684   delete_seen_objects_table();
 685 }
 686 
 687 void HeapShared::find_required_hidden_classes_helper(ArchivableStaticFieldInfo fields[]) {
 688   if (!CDSConfig::is_dumping_heap()) {
 689     return;
 690   }
 691   for (int i = 0; fields[i].valid(); i++) {
 692     ArchivableStaticFieldInfo* f = &fields[i];
 693     InstanceKlass* k = f->klass;
 694     oop m = k->java_mirror();
 695     oop o = m->obj_field(f->offset);
 696     if (o != nullptr) {
 697       find_required_hidden_classes_in_object(o);
 698     }
 699   }
 700 }
 701 
 702 class HeapShared::FindRequiredHiddenClassesOopClosure: public BasicOopIterateClosure {
 703   GrowableArray<oop> _stack;
 704   template <class T> void do_oop_work(T *p) {
 705     // Recurse on a GrowableArray to avoid overflowing the C stack.
 706     oop o = RawAccess<>::oop_load(p);
 707     if (o != nullptr) {
 708       _stack.append(o);
 709     }
 710   }
 711 
 712  public:
 713 
 714   void do_oop(narrowOop *p) { FindRequiredHiddenClassesOopClosure::do_oop_work(p); }
 715   void do_oop(      oop *p) { FindRequiredHiddenClassesOopClosure::do_oop_work(p); }
 716 
 717   FindRequiredHiddenClassesOopClosure(oop o) {
 718     _stack.append(o);
 719   }
 720   oop pop() {
 721     if (_stack.length() == 0) {
 722       return nullptr;
 723     } else {
 724       return _stack.pop();
 725     }
 726   }
 727 };
 728 
 729 static void mark_required_if_hidden_class(Klass* k) {
 730   if (k != nullptr && k->is_instance_klass()) {
 731     InstanceKlass* ik = InstanceKlass::cast(k);
 732     if (ik->is_hidden()) {
 733       SystemDictionaryShared::mark_required_hidden_class(ik);
 734     }
 735   }
 736 }
 737 
 738 
 739 void HeapShared::find_required_hidden_classes_in_object(oop root) {
 740   ResourceMark rm;
 741   FindRequiredHiddenClassesOopClosure c(root);
 742   oop o;
 743   while ((o = c.pop()) != nullptr) {
 744     if (!has_been_seen_during_subgraph_recording(o)) {
 745       set_has_been_seen_during_subgraph_recording(o);
 746 
 747       // Mark the klass of this object
 748       mark_required_if_hidden_class(o->klass());
 749 
 750       // For special objects, mark the klass that they contain information about.
 751       // - a Class that refers to an hidden class
 752       // - a ResolvedMethodName that refers to a method declared in a hidden class
 753       if (java_lang_Class::is_instance(o)) {
 754         mark_required_if_hidden_class(java_lang_Class::as_Klass(o));
 755       } else if (java_lang_invoke_ResolvedMethodName::is_instance(o)) {
 756         Method* m = java_lang_invoke_ResolvedMethodName::vmtarget(o);
 757         if (m != nullptr) {
 758           mark_required_if_hidden_class(m->method_holder());
 759         }
 760       }
 761 
 762       o->oop_iterate(&c);
 763     }
 764   }
 765 }
 766 
 767 void HeapShared::archive_objects(ArchiveHeapInfo *heap_info) {
 768   {
 769     NoSafepointVerifier nsv;
 770 
 771     // The special subgraph doesn't belong to any class. We use Object_klass() here just
 772     // for convenience.
 773     _dump_time_special_subgraph = init_subgraph_info(vmClasses::Object_klass(), false);
 774 
 775     // Cache for recording where the archived objects are copied to
 776     create_archived_object_cache();
 777 
 778     if (UseCompressedOops || UseG1GC) {
 779       log_info(cds)("Heap range = [" PTR_FORMAT " - "  PTR_FORMAT "]",
 780                     UseCompressedOops ? p2i(CompressedOops::begin()) :
 781                                         p2i((address)G1CollectedHeap::heap()->reserved().start()),
 782                     UseCompressedOops ? p2i(CompressedOops::end()) :
 783                                         p2i((address)G1CollectedHeap::heap()->reserved().end()));
 784     }
 785     copy_objects();
 786 
 787     CDSHeapVerifier::verify();
 788     check_special_subgraph_classes();
 789   }
 790 
 791   ArchiveHeapWriter::write(_pending_roots, heap_info);
 792 }
 793 
 794 void HeapShared::copy_interned_strings() {
 795   init_seen_objects_table();
 796 
 797   auto copier = [&] (oop s, bool value_ignored) {
 798     assert(s != nullptr, "sanity");
 799     assert(!ArchiveHeapWriter::is_string_too_large_to_archive(s), "large strings must have been filtered");
 800     bool success = archive_reachable_objects_from(1, _dump_time_special_subgraph, s);
 801     assert(success, "must be");
 802     // Prevent string deduplication from changing the value field to
 803     // something not in the archive.
 804     java_lang_String::set_deduplication_forbidden(s);
 805   };
 806   _dumped_interned_strings->iterate_all(copier);
 807 
 808   delete_seen_objects_table();
 809 }
 810 
 811 void HeapShared::copy_special_subgraph() {
 812   copy_interned_strings();
 813 
 814   init_seen_objects_table();
 815   {
 816     archive_java_mirrors();
 817     archive_strings();
 818     Universe::archive_exception_instances();
 819   }
 820   delete_seen_objects_table();
 821 }
 822 
 823 void HeapShared::prepare_resolved_references() {
 824   GrowableArray<Klass*>* klasses = ArchiveBuilder::current()->klasses();
 825   for (int i = 0; i < klasses->length(); i++) {
 826     Klass* src_k = klasses->at(i);
 827     if (src_k->is_instance_klass()) {
 828       InstanceKlass* buffered_ik = ArchiveBuilder::current()->get_buffered_addr(InstanceKlass::cast(src_k));
 829       buffered_ik->constants()->prepare_resolved_references_for_archiving();
 830     }
 831   }
 832 }
 833 
 834 void HeapShared::copy_objects() {
 835   assert(HeapShared::can_write(), "must be");
 836 
 837   prepare_resolved_references();
 838   find_all_aot_initialized_classes();
 839   copy_special_subgraph();
 840 
 841   archive_object_subgraphs(archive_subgraph_entry_fields,
 842                            false /* is_full_module_graph */);
 843 
 844   if (CDSConfig::is_dumping_full_module_graph()) {
 845     archive_object_subgraphs(fmg_archive_subgraph_entry_fields,
 846                              true /* is_full_module_graph */);
 847     Modules::verify_archived_modules();
 848   }
 849 }
 850 
 851 // Closure used by HeapShared::scan_for_aot_initialized_classes() to look for all objects
 852 // that are reachable from a given root.
 853 class HeapShared::AOTInitializedClassScanner : public BasicOopIterateClosure {
 854   bool _made_progress;
 855 
 856   template <class T> void check(T *p) {
 857     oop obj = HeapAccess<>::oop_load(p);
 858     if (!java_lang_Class::is_instance(obj)) {
 859       // Don't scan the mirrors, as we may see an orig_mirror while scanning
 860       // the object graph, .... TODO more info
 861       _made_progress |= HeapShared::scan_for_aot_initialized_classes(obj);
 862     }
 863   }
 864 
 865 public:
 866   AOTInitializedClassScanner() : _made_progress(false) {}
 867   void do_oop(narrowOop *p) { check(p); }
 868   void do_oop(      oop *p) { check(p); }
 869   bool made_progress() { return _made_progress; }
 870 };
 871 
 872 // If <buffered_ik> has been initialized during the assembly phase, mark its
 873 // has_aot_initialized_mirror bit. And then do the same for all supertypes of
 874 // <buffered_ik>.
 875 //
 876 // Note: a super interface <intf> of <buffered_ik> may not have been initialized, if
 877 // <intf> has not declared any default methods.
 878 //
 879 // Note: this function doesn not call InstanceKlass::initialize() -- we are inside
 880 // a safepoint.
 881 //
 882 // Returns true if one or more classes have been newly marked.
 883 static bool mark_for_aot_initialization(InstanceKlass* buffered_ik) {
 884   assert(SafepointSynchronize::is_at_safepoint(), "sanity");
 885   assert(ArchiveBuilder::current()->is_in_buffer_space(buffered_ik), "sanity");
 886 
 887   if (buffered_ik->has_aot_initialized_mirror()) { // already marked
 888     return false;
 889   }
 890 
 891   bool made_progress = false;
 892   if (buffered_ik->is_initialized()) {
 893     if (log_is_enabled(Info, cds, init)) {
 894       ResourceMark rm;
 895       log_info(cds, init)("Mark class for aot-init: %s", buffered_ik->external_name());
 896     }
 897 
 898     InstanceKlass* src_ik = ArchiveBuilder::current()->get_source_addr(buffered_ik);
 899 
 900     // If we get here with a "wild" user class, which may have
 901     // uncontrolled <clinit> code, exit with an error.  Obviously
 902     // filtering logic upstream needs to detect APP classes and not mark
 903     // them for aot-init in the first place, but this will be the final
 904     // firewall.
 905 
 906 #ifndef PRODUCT
 907     // ArchiveHeapTestClass is used for a very small number of internal regression
 908     // tests (non-product builds only). It may initialize some unexpected classes.
 909     if (ArchiveHeapTestClass == nullptr)
 910 #endif
 911     {
 912       if (!src_ik->in_javabase_module()) {
 913         // Class/interface types in the boot loader may have been initialized as side effects
 914         // of JVM bootstrap code, so they are fine. But we need to check all other classes.
 915         if (buffered_ik->is_interface()) {
 916           // This probably means a bug in AOTConstantPoolResolver.::is_indy_resolution_deterministic()
 917           guarantee(!buffered_ik->interface_needs_clinit_execution_as_super(),
 918                     "should not have initialized an interface whose <clinit> might have unpredictable side effects");
 919         } else {
 920           // "normal" classes
 921           guarantee(HeapShared::is_archivable_hidden_klass(buffered_ik),
 922                     "should not have initialized any non-interface, non-hidden classes outside of java.base");
 923         }
 924       }
 925     }
 926 
 927     buffered_ik->set_has_aot_initialized_mirror();
 928     if (AOTClassInitializer::is_runtime_setup_required(src_ik)) {
 929       buffered_ik->set_is_runtime_setup_required();
 930     }
 931     made_progress = true;
 932 
 933     InstanceKlass* super = buffered_ik->java_super();
 934     if (super != nullptr) {
 935       mark_for_aot_initialization(super);
 936     }
 937 
 938     Array<InstanceKlass*>* interfaces = buffered_ik->transitive_interfaces();
 939     for (int i = 0; i < interfaces->length(); i++) {
 940       InstanceKlass* intf = interfaces->at(i);
 941       mark_for_aot_initialization(intf);
 942       if (!intf->is_initialized()) {
 943         assert(!intf->interface_needs_clinit_execution_as_super(/*also_check_supers*/false), "sanity");
 944         assert(!intf->has_aot_initialized_mirror(), "must not be marked");
 945       }
 946     }
 947   }
 948 
 949   return made_progress;
 950 }
 951 
 952 void HeapShared::find_all_aot_initialized_classes() {
 953   if (!CDSConfig::is_dumping_aot_linked_classes()) {
 954     return;
 955   }
 956 
 957   init_seen_objects_table();
 958   find_all_aot_initialized_classes_helper();
 959   delete_seen_objects_table();
 960 }
 961 
 962 // Recursively find all class that should be aot-initialized:
 963 // - the class has at least one instance that can be reachable from the special subgraph; or
 964 // - the class is hard-coded in AOTClassInitializer::can_archive_initialized_mirror()
 965 void HeapShared::find_all_aot_initialized_classes_helper() {
 966   GrowableArray<Klass*>* klasses = ArchiveBuilder::current()->klasses();
 967   assert(klasses != nullptr, "sanity");
 968 
 969   // First scan all resolved constant pools references.
 970   for (int i = 0; i < klasses->length(); i++) {
 971     Klass* src_k = klasses->at(i);
 972     if (src_k->is_instance_klass()) {
 973       InstanceKlass* src_ik = InstanceKlass::cast(src_k);
 974       InstanceKlass* buffered_ik = ArchiveBuilder::current()->get_buffered_addr(src_ik);
 975       objArrayOop rr = get_archived_resolved_references(src_ik);
 976       if (rr != nullptr) {
 977         objArrayOop scratch_rr = scratch_resolved_references(src_ik->constants());
 978         for (int i = 0; i < scratch_rr->length(); i++) {
 979           scan_for_aot_initialized_classes(scratch_rr->obj_at(i));
 980         }
 981       }
 982 
 983       // If a class is hard-coded to be aot-initialize, mark it as such.
 984       if (AOTClassInitializer::can_archive_initialized_mirror(src_ik)) {
 985         mark_for_aot_initialization(buffered_ik);
 986       }
 987     }
 988   }
 989 
 990   // These objects also belong to the special subgraph
 991   scan_for_aot_initialized_classes(Universe::null_ptr_exception_instance());
 992   scan_for_aot_initialized_classes(Universe::arithmetic_exception_instance());
 993   scan_for_aot_initialized_classes(Universe::internal_error_instance());
 994   scan_for_aot_initialized_classes(Universe::array_index_out_of_bounds_exception_instance());
 995   scan_for_aot_initialized_classes(Universe::array_store_exception_instance());
 996   scan_for_aot_initialized_classes(Universe::class_cast_exception_instance());
 997 
 998   bool made_progress;
 999   do {
1000     // In each pass, we copy the scratch mirrors of the classes that were marked
1001     // as aot-init in the previous pass. We then scan these mirrors, which may
1002     // mark more classes. Keep iterating until no more progress can be made.
1003     made_progress = false;
1004     for (int i = 0; i < klasses->length(); i++) {
1005       Klass* orig_k = klasses->at(i);
1006       if (orig_k->is_instance_klass()) {
1007         InstanceKlass* orig_ik = InstanceKlass::cast(orig_k);
1008         if (ArchiveBuilder::current()->get_buffered_addr(orig_ik)->has_aot_initialized_mirror()) {
1009           oop orig_mirror = orig_ik->java_mirror();
1010           oop scratch_mirror = scratch_java_mirror(orig_k);
1011           if (!has_been_seen_during_subgraph_recording(scratch_mirror)) {
1012             // Scan scratch_mirror instead of orig_mirror (which has fields like ClassLoader that
1013             // are not archived).
1014             copy_aot_initialized_mirror(orig_k, orig_mirror, scratch_mirror);
1015             made_progress |= scan_for_aot_initialized_classes(scratch_mirror);
1016           }
1017         }
1018       }
1019     }
1020   } while (made_progress);
1021 }
1022 
1023 bool HeapShared::scan_for_aot_initialized_classes(oop obj) {
1024   if (obj == nullptr || has_been_seen_during_subgraph_recording(obj)) {
1025     return false;
1026   }
1027   set_has_been_seen_during_subgraph_recording(obj);
1028 
1029   bool made_progress = false;
1030   Klass* k = obj->klass();
1031   if (k->is_instance_klass()) {
1032     InstanceKlass* orig_ik = InstanceKlass::cast(k);
1033     InstanceKlass* buffered_ik = ArchiveBuilder::current()->get_buffered_addr(orig_ik);
1034     made_progress = mark_for_aot_initialization(buffered_ik);
1035   }
1036 
1037   AOTInitializedClassScanner scanner;
1038   obj->oop_iterate(&scanner);
1039   made_progress |= scanner.made_progress();
1040   return made_progress;
1041 }
1042 
1043 //
1044 // Subgraph archiving support
1045 //
1046 HeapShared::DumpTimeKlassSubGraphInfoTable* HeapShared::_dump_time_subgraph_info_table = nullptr;
1047 HeapShared::RunTimeKlassSubGraphInfoTable   HeapShared::_run_time_subgraph_info_table;
1048 
1049 // Get the subgraph_info for Klass k. A new subgraph_info is created if
1050 // there is no existing one for k. The subgraph_info records the "buffered"
1051 // address of the class.
1052 KlassSubGraphInfo* HeapShared::init_subgraph_info(Klass* k, bool is_full_module_graph) {
1053   assert(CDSConfig::is_dumping_heap(), "dump time only");
1054   bool created;
1055   Klass* buffered_k = ArchiveBuilder::get_buffered_klass(k);
1056   KlassSubGraphInfo* info =
1057     _dump_time_subgraph_info_table->put_if_absent(k, KlassSubGraphInfo(buffered_k, is_full_module_graph),
1058                                                   &created);
1059   assert(created, "must not initialize twice");
1060   return info;
1061 }
1062 
1063 KlassSubGraphInfo* HeapShared::get_subgraph_info(Klass* k) {
1064   assert(CDSConfig::is_dumping_heap(), "dump time only");
1065   KlassSubGraphInfo* info = _dump_time_subgraph_info_table->get(k);
1066   assert(info != nullptr, "must have been initialized");
1067   return info;
1068 }
1069 
1070 // Add an entry field to the current KlassSubGraphInfo.
1071 void KlassSubGraphInfo::add_subgraph_entry_field(int static_field_offset, oop v) {
1072   assert(CDSConfig::is_dumping_heap(), "dump time only");
1073   if (_subgraph_entry_fields == nullptr) {
1074     _subgraph_entry_fields =
1075       new (mtClass) GrowableArray<int>(10, mtClass);
1076   }
1077   _subgraph_entry_fields->append(static_field_offset);
1078   _subgraph_entry_fields->append(HeapShared::append_root(v));
1079 }
1080 
1081 // Add the Klass* for an object in the current KlassSubGraphInfo's subgraphs.
1082 // Only objects of boot classes can be included in sub-graph.
1083 void KlassSubGraphInfo::add_subgraph_object_klass(Klass* orig_k) {
1084   assert(CDSConfig::is_dumping_heap(), "dump time only");
1085   Klass* buffered_k = ArchiveBuilder::get_buffered_klass(orig_k);
1086 
1087   if (_subgraph_object_klasses == nullptr) {
1088     _subgraph_object_klasses =
1089       new (mtClass) GrowableArray<Klass*>(50, mtClass);
1090   }
1091 
1092   assert(ArchiveBuilder::current()->is_in_buffer_space(buffered_k), "must be a shared class");
1093 
1094   if (_k == buffered_k) {
1095     // Don't add the Klass containing the sub-graph to it's own klass
1096     // initialization list.
1097     return;
1098   }
1099 
1100   if (buffered_k->is_instance_klass()) {
1101     if (CDSConfig::is_dumping_invokedynamic()) {
1102       assert(InstanceKlass::cast(buffered_k)->is_shared_boot_class() ||
1103              HeapShared::is_lambda_proxy_klass(InstanceKlass::cast(buffered_k)),
1104             "we can archive only instances of boot classes or lambda proxy classes");
1105     } else {
1106       assert(InstanceKlass::cast(buffered_k)->is_shared_boot_class(),
1107              "must be boot class");
1108     }
1109     // vmClasses::xxx_klass() are not updated, need to check
1110     // the original Klass*
1111     if (orig_k == vmClasses::String_klass() ||
1112         orig_k == vmClasses::Object_klass()) {
1113       // Initialized early during VM initialization. No need to be added
1114       // to the sub-graph object class list.
1115       return;
1116     }
1117     if (buffered_k->has_aot_initialized_mirror()) {
1118       // No need to add to the runtime-init list.
1119       return;
1120     }
1121     check_allowed_klass(InstanceKlass::cast(orig_k));
1122   } else if (buffered_k->is_objArray_klass()) {
1123     Klass* abk = ObjArrayKlass::cast(buffered_k)->bottom_klass();
1124     if (abk->is_instance_klass()) {
1125       assert(InstanceKlass::cast(abk)->is_shared_boot_class(),
1126             "must be boot class");
1127       check_allowed_klass(InstanceKlass::cast(ObjArrayKlass::cast(orig_k)->bottom_klass()));
1128     }
1129     if (buffered_k == Universe::objectArrayKlass()) {
1130       // Initialized early during Universe::genesis. No need to be added
1131       // to the list.
1132       return;
1133     }
1134   } else {
1135     assert(buffered_k->is_typeArray_klass(), "must be");
1136     // Primitive type arrays are created early during Universe::genesis.
1137     return;
1138   }
1139 
1140   if (log_is_enabled(Debug, cds, heap)) {
1141     if (!_subgraph_object_klasses->contains(buffered_k)) {
1142       ResourceMark rm;
1143       log_debug(cds, heap)("Adding klass %s", orig_k->external_name());
1144     }
1145   }
1146 
1147   _subgraph_object_klasses->append_if_missing(buffered_k);
1148   _has_non_early_klasses |= is_non_early_klass(orig_k);
1149 }
1150 
1151 void KlassSubGraphInfo::check_allowed_klass(InstanceKlass* ik) {
1152   if (ik->module()->name() == vmSymbols::java_base()) {
1153     assert(ik->package() != nullptr, "classes in java.base cannot be in unnamed package");
1154     return;
1155   }
1156 
1157   const char* lambda_msg = "";
1158   if (CDSConfig::is_dumping_invokedynamic()) {
1159     lambda_msg = ", or a lambda proxy class";
1160     if (HeapShared::is_lambda_proxy_klass(ik) &&
1161         (ik->class_loader() == nullptr ||
1162          ik->class_loader() == SystemDictionary::java_platform_loader() ||
1163          ik->class_loader() == SystemDictionary::java_system_loader())) {
1164       return;
1165     }
1166   }
1167 
1168 #ifndef PRODUCT
1169   if (!ik->module()->is_named() && ik->package() == nullptr && ArchiveHeapTestClass != nullptr) {
1170     // This class is loaded by ArchiveHeapTestClass
1171     return;
1172   }
1173   const char* testcls_msg = ", or a test class in an unnamed package of an unnamed module";
1174 #else
1175   const char* testcls_msg = "";
1176 #endif
1177 
1178   ResourceMark rm;
1179   log_error(cds, heap)("Class %s not allowed in archive heap. Must be in java.base%s%s",
1180                        ik->external_name(), lambda_msg, testcls_msg);
1181   MetaspaceShared::unrecoverable_writing_error();
1182 }
1183 
1184 bool KlassSubGraphInfo::is_non_early_klass(Klass* k) {
1185   if (k->is_objArray_klass()) {
1186     k = ObjArrayKlass::cast(k)->bottom_klass();
1187   }
1188   if (k->is_instance_klass()) {
1189     if (!SystemDictionaryShared::is_early_klass(InstanceKlass::cast(k))) {
1190       ResourceMark rm;
1191       log_info(cds, heap)("non-early: %s", k->external_name());
1192       return true;
1193     } else {
1194       return false;
1195     }
1196   } else {
1197     return false;
1198   }
1199 }
1200 
1201 // Initialize an archived subgraph_info_record from the given KlassSubGraphInfo.
1202 void ArchivedKlassSubGraphInfoRecord::init(KlassSubGraphInfo* info) {
1203   _k = info->klass();
1204   _entry_field_records = nullptr;
1205   _subgraph_object_klasses = nullptr;
1206   _is_full_module_graph = info->is_full_module_graph();
1207 
1208   if (_is_full_module_graph) {
1209     // Consider all classes referenced by the full module graph as early -- we will be
1210     // allocating objects of these classes during JVMTI early phase, so they cannot
1211     // be processed by (non-early) JVMTI ClassFileLoadHook
1212     _has_non_early_klasses = false;
1213   } else {
1214     _has_non_early_klasses = info->has_non_early_klasses();
1215   }
1216 
1217   if (_has_non_early_klasses) {
1218     ResourceMark rm;
1219     log_info(cds, heap)(
1220           "Subgraph of klass %s has non-early klasses and cannot be used when JVMTI ClassFileLoadHook is enabled",
1221           _k->external_name());
1222   }
1223 
1224   // populate the entry fields
1225   GrowableArray<int>* entry_fields = info->subgraph_entry_fields();
1226   if (entry_fields != nullptr) {
1227     int num_entry_fields = entry_fields->length();
1228     assert(num_entry_fields % 2 == 0, "sanity");
1229     _entry_field_records =
1230       ArchiveBuilder::new_ro_array<int>(num_entry_fields);
1231     for (int i = 0 ; i < num_entry_fields; i++) {
1232       _entry_field_records->at_put(i, entry_fields->at(i));
1233     }
1234   }
1235 
1236   // the Klasses of the objects in the sub-graphs
1237   GrowableArray<Klass*>* subgraph_object_klasses = info->subgraph_object_klasses();
1238   if (subgraph_object_klasses != nullptr) {
1239     int num_subgraphs_klasses = subgraph_object_klasses->length();
1240     _subgraph_object_klasses =
1241       ArchiveBuilder::new_ro_array<Klass*>(num_subgraphs_klasses);
1242     bool is_special = (_k == ArchiveBuilder::get_buffered_klass(vmClasses::Object_klass()));
1243     for (int i = 0; i < num_subgraphs_klasses; i++) {
1244       Klass* subgraph_k = subgraph_object_klasses->at(i);
1245       if (log_is_enabled(Info, cds, heap)) {
1246         ResourceMark rm;
1247         const char* owner_name =  is_special ? "<special>" : _k->external_name();
1248         if (subgraph_k->is_instance_klass()) {
1249           InstanceKlass* src_ik = InstanceKlass::cast(ArchiveBuilder::current()->get_source_addr(subgraph_k));
1250         }
1251         log_info(cds, heap)(
1252           "Archived object klass %s (%2d) => %s",
1253           owner_name, i, subgraph_k->external_name());
1254       }
1255       _subgraph_object_klasses->at_put(i, subgraph_k);
1256       ArchivePtrMarker::mark_pointer(_subgraph_object_klasses->adr_at(i));
1257     }
1258   }
1259 
1260   ArchivePtrMarker::mark_pointer(&_k);
1261   ArchivePtrMarker::mark_pointer(&_entry_field_records);
1262   ArchivePtrMarker::mark_pointer(&_subgraph_object_klasses);
1263 }
1264 
1265 class HeapShared::CopyKlassSubGraphInfoToArchive : StackObj {
1266   CompactHashtableWriter* _writer;
1267 public:
1268   CopyKlassSubGraphInfoToArchive(CompactHashtableWriter* writer) : _writer(writer) {}
1269 
1270   bool do_entry(Klass* klass, KlassSubGraphInfo& info) {
1271     if (info.subgraph_object_klasses() != nullptr || info.subgraph_entry_fields() != nullptr) {
1272       ArchivedKlassSubGraphInfoRecord* record = HeapShared::archive_subgraph_info(&info);
1273       Klass* buffered_k = ArchiveBuilder::get_buffered_klass(klass);
1274       unsigned int hash = SystemDictionaryShared::hash_for_shared_dictionary((address)buffered_k);
1275       u4 delta = ArchiveBuilder::current()->any_to_offset_u4(record);
1276       _writer->add(hash, delta);
1277     }
1278     return true; // keep on iterating
1279   }
1280 };
1281 
1282 ArchivedKlassSubGraphInfoRecord* HeapShared::archive_subgraph_info(KlassSubGraphInfo* info) {
1283   ArchivedKlassSubGraphInfoRecord* record =
1284       (ArchivedKlassSubGraphInfoRecord*)ArchiveBuilder::ro_region_alloc(sizeof(ArchivedKlassSubGraphInfoRecord));
1285   record->init(info);
1286   if (info ==  _dump_time_special_subgraph) {
1287     _run_time_special_subgraph = record;
1288   }
1289   return record;
1290 }
1291 
1292 // Build the records of archived subgraph infos, which include:
1293 // - Entry points to all subgraphs from the containing class mirror. The entry
1294 //   points are static fields in the mirror. For each entry point, the field
1295 //   offset, and value are recorded in the sub-graph
1296 //   info. The value is stored back to the corresponding field at runtime.
1297 // - A list of klasses that need to be loaded/initialized before archived
1298 //   java object sub-graph can be accessed at runtime.
1299 void HeapShared::write_subgraph_info_table() {
1300   // Allocate the contents of the hashtable(s) inside the RO region of the CDS archive.
1301   DumpTimeKlassSubGraphInfoTable* d_table = _dump_time_subgraph_info_table;
1302   CompactHashtableStats stats;
1303 
1304   _run_time_subgraph_info_table.reset();
1305 
1306   CompactHashtableWriter writer(d_table->_count, &stats);
1307   CopyKlassSubGraphInfoToArchive copy(&writer);
1308   d_table->iterate(&copy);
1309   writer.dump(&_run_time_subgraph_info_table, "subgraphs");
1310 
1311 #ifndef PRODUCT
1312   if (ArchiveHeapTestClass != nullptr) {
1313     size_t len = strlen(ArchiveHeapTestClass) + 1;
1314     Array<char>* array = ArchiveBuilder::new_ro_array<char>((int)len);
1315     strncpy(array->adr_at(0), ArchiveHeapTestClass, len);
1316     _archived_ArchiveHeapTestClass = array;
1317   }
1318 #endif
1319   if (log_is_enabled(Info, cds, heap)) {
1320     print_stats();
1321   }
1322 }
1323 
1324 void HeapShared::add_root_segment(objArrayOop segment_oop) {
1325   assert(segment_oop != nullptr, "must be");
1326   assert(ArchiveHeapLoader::is_in_use(), "must be");
1327   if (_root_segments == nullptr) {
1328     _root_segments = new GrowableArrayCHeap<OopHandle, mtClassShared>(10);
1329   }
1330   _root_segments->push(OopHandle(Universe::vm_global(), segment_oop));
1331 }
1332 
1333 void HeapShared::init_root_segment_sizes(int max_size_elems) {
1334   _root_segment_max_size_elems = max_size_elems;
1335 }
1336 
1337 void HeapShared::serialize_tables(SerializeClosure* soc) {
1338 
1339 #ifndef PRODUCT
1340   soc->do_ptr(&_archived_ArchiveHeapTestClass);
1341   if (soc->reading() && _archived_ArchiveHeapTestClass != nullptr) {
1342     _test_class_name = _archived_ArchiveHeapTestClass->adr_at(0);
1343     setup_test_class(_test_class_name);
1344   }
1345 #endif
1346 
1347   _run_time_subgraph_info_table.serialize_header(soc);
1348   soc->do_ptr(&_run_time_special_subgraph);
1349 }
1350 
1351 static void verify_the_heap(Klass* k, const char* which) {
1352   if (VerifyArchivedFields > 0) {
1353     ResourceMark rm;
1354     log_info(cds, heap)("Verify heap %s initializing static field(s) in %s",
1355                         which, k->external_name());
1356 
1357     VM_Verify verify_op;
1358     VMThread::execute(&verify_op);
1359 
1360     if (VerifyArchivedFields > 1 && is_init_completed()) {
1361       // At this time, the oop->klass() of some archived objects in the heap may not
1362       // have been loaded into the system dictionary yet. Nevertheless, oop->klass() should
1363       // have enough information (object size, oop maps, etc) so that a GC can be safely
1364       // performed.
1365       //
1366       // -XX:VerifyArchivedFields=2 force a GC to happen in such an early stage
1367       // to check for GC safety.
1368       log_info(cds, heap)("Trigger GC %s initializing static field(s) in %s",
1369                           which, k->external_name());
1370       FlagSetting fs1(VerifyBeforeGC, true);
1371       FlagSetting fs2(VerifyDuringGC, true);
1372       FlagSetting fs3(VerifyAfterGC,  true);
1373       Universe::heap()->collect(GCCause::_java_lang_system_gc);
1374     }
1375   }
1376 }
1377 
1378 // Before GC can execute, we must ensure that all oops reachable from HeapShared::roots()
1379 // have a valid klass. I.e., oopDesc::klass() must have already been resolved.
1380 //
1381 // Note: if a ArchivedKlassSubGraphInfoRecord contains non-early classes, and JVMTI
1382 // ClassFileLoadHook is enabled, it's possible for this class to be dynamically replaced. In
1383 // this case, we will not load the ArchivedKlassSubGraphInfoRecord and will clear its roots.
1384 void HeapShared::resolve_classes(JavaThread* current) {
1385   assert(CDSConfig::is_using_archive(), "runtime only!");
1386   if (!ArchiveHeapLoader::is_in_use()) {
1387     return; // nothing to do
1388   }
1389   resolve_classes_for_subgraphs(current, archive_subgraph_entry_fields);
1390   resolve_classes_for_subgraphs(current, fmg_archive_subgraph_entry_fields);
1391 }
1392 
1393 void HeapShared::resolve_classes_for_subgraphs(JavaThread* current, ArchivableStaticFieldInfo fields[]) {
1394   for (int i = 0; fields[i].valid(); i++) {
1395     ArchivableStaticFieldInfo* info = &fields[i];
1396     TempNewSymbol klass_name = SymbolTable::new_symbol(info->klass_name);
1397     InstanceKlass* k = SystemDictionaryShared::find_builtin_class(klass_name);
1398     assert(k != nullptr && k->is_shared_boot_class(), "sanity");
1399     resolve_classes_for_subgraph_of(current, k);
1400   }
1401 }
1402 
1403 void HeapShared::resolve_classes_for_subgraph_of(JavaThread* current, Klass* k) {
1404   JavaThread* THREAD = current;
1405   ExceptionMark em(THREAD);
1406   const ArchivedKlassSubGraphInfoRecord* record =
1407    resolve_or_init_classes_for_subgraph_of(k, /*do_init=*/false, THREAD);
1408   if (HAS_PENDING_EXCEPTION) {
1409    CLEAR_PENDING_EXCEPTION;
1410   }
1411   if (record == nullptr) {
1412    clear_archived_roots_of(k);
1413   }
1414 }
1415 
1416 void HeapShared::initialize_java_lang_invoke(TRAPS) {
1417   if (CDSConfig::is_loading_invokedynamic() || CDSConfig::is_dumping_invokedynamic()) {
1418     resolve_or_init("java/lang/invoke/Invokers$Holder", true, CHECK);
1419     resolve_or_init("java/lang/invoke/MethodHandle", true, CHECK);
1420     resolve_or_init("java/lang/invoke/MethodHandleNatives", true, CHECK);
1421     resolve_or_init("java/lang/invoke/DirectMethodHandle$Holder", true, CHECK);
1422     resolve_or_init("java/lang/invoke/DelegatingMethodHandle$Holder", true, CHECK);
1423     resolve_or_init("java/lang/invoke/LambdaForm$Holder", true, CHECK);
1424     resolve_or_init("java/lang/invoke/BoundMethodHandle$Species_L", true, CHECK);
1425   }
1426 }
1427 
1428 // Initialize the InstanceKlasses of objects that are reachable from the following roots:
1429 //   - interned strings
1430 //   - Klass::java_mirror() -- including aot-initialized mirrors such as those of Enum klasses.
1431 //   - ConstantPool::resolved_references()
1432 //   - Universe::<xxx>_exception_instance()
1433 //
1434 // For example, if this enum class is initialized at AOT cache assembly time:
1435 //
1436 //    enum Fruit {
1437 //       APPLE, ORANGE, BANANA;
1438 //       static final Set<Fruit> HAVE_SEEDS = new HashSet<>(Arrays.asList(APPLE, ORANGE));
1439 //   }
1440 //
1441 // the aot-initialized mirror of Fruit has a static field that references HashSet, which
1442 // should be initialized before any Java code can access the Fruit class. Note that
1443 // HashSet itself doesn't necessary need to be an aot-initialized class.
1444 void HeapShared::init_classes_for_special_subgraph(Handle class_loader, TRAPS) {
1445   if (!ArchiveHeapLoader::is_in_use()) {
1446     return;
1447   }
1448 
1449   assert( _run_time_special_subgraph != nullptr, "must be");
1450   Array<Klass*>* klasses = _run_time_special_subgraph->subgraph_object_klasses();
1451   if (klasses != nullptr) {
1452     for (int pass = 0; pass < 2; pass ++) {
1453       for (int i = 0; i < klasses->length(); i++) {
1454         Klass* k = klasses->at(i);
1455         if (k->class_loader_data() == nullptr) {
1456           // This class is not yet loaded. We will initialize it in a later phase.
1457           // For example, we have loaded only AOTLinkedClassCategory::BOOT1 classes
1458           // but k is part of AOTLinkedClassCategory::BOOT2.
1459           continue;
1460         }
1461         if (k->class_loader() == class_loader()) {
1462           if (pass == 0) {
1463             if (k->is_instance_klass()) {
1464               InstanceKlass::cast(k)->link_class(CHECK);
1465             }
1466           } else {
1467             resolve_or_init(k, /*do_init*/true, CHECK);
1468           }
1469         }
1470       }
1471     }
1472   }
1473 }
1474 
1475 void HeapShared::initialize_from_archived_subgraph(JavaThread* current, Klass* k) {
1476   JavaThread* THREAD = current;
1477   if (!ArchiveHeapLoader::is_in_use()) {
1478     return; // nothing to do
1479   }
1480 
1481   if (k->name()->equals("jdk/internal/module/ArchivedModuleGraph") &&
1482       !CDSConfig::is_using_optimized_module_handling() &&
1483       // archive was created with --module-path
1484       ClassLoaderExt::num_module_paths() > 0) {
1485     // ArchivedModuleGraph was created with a --module-path that's different than the runtime --module-path.
1486     // Thus, it might contain references to modules that do not exist at runtime. We cannot use it.
1487     log_info(cds, heap)("Skip initializing ArchivedModuleGraph subgraph: is_using_optimized_module_handling=%s num_module_paths=%d",
1488                         BOOL_TO_STR(CDSConfig::is_using_optimized_module_handling()), ClassLoaderExt::num_module_paths());
1489     return;
1490   }
1491 
1492   ExceptionMark em(THREAD);
1493   const ArchivedKlassSubGraphInfoRecord* record =
1494     resolve_or_init_classes_for_subgraph_of(k, /*do_init=*/true, THREAD);
1495 
1496   if (HAS_PENDING_EXCEPTION) {
1497     CLEAR_PENDING_EXCEPTION;
1498     // None of the field value will be set if there was an exception when initializing the classes.
1499     // The java code will not see any of the archived objects in the
1500     // subgraphs referenced from k in this case.
1501     return;
1502   }
1503 
1504   if (record != nullptr) {
1505     init_archived_fields_for(k, record);
1506   }
1507 }
1508 
1509 const ArchivedKlassSubGraphInfoRecord*
1510 HeapShared::resolve_or_init_classes_for_subgraph_of(Klass* k, bool do_init, TRAPS) {
1511   assert(!CDSConfig::is_dumping_heap(), "Should not be called when dumping heap");
1512 
1513   if (!k->is_shared()) {
1514     return nullptr;
1515   }
1516   unsigned int hash = SystemDictionaryShared::hash_for_shared_dictionary_quick(k);
1517   const ArchivedKlassSubGraphInfoRecord* record = _run_time_subgraph_info_table.lookup(k, hash, 0);
1518 
1519 #ifndef PRODUCT
1520   if (_test_class_name != nullptr && k->name()->equals(_test_class_name) && record != nullptr) {
1521     _test_class = k;
1522     _test_class_record = record;
1523   }
1524 #endif
1525 
1526   // Initialize from archived data. Currently this is done only
1527   // during VM initialization time. No lock is needed.
1528   if (record == nullptr) {
1529     if (log_is_enabled(Info, cds, heap)) {
1530       ResourceMark rm(THREAD);
1531       log_info(cds, heap)("subgraph %s is not recorded",
1532                           k->external_name());
1533     }
1534     return nullptr;
1535   } else {
1536     if (record->is_full_module_graph() && !CDSConfig::is_using_full_module_graph()) {
1537       if (log_is_enabled(Info, cds, heap)) {
1538         ResourceMark rm(THREAD);
1539         log_info(cds, heap)("subgraph %s cannot be used because full module graph is disabled",
1540                             k->external_name());
1541       }
1542       return nullptr;
1543     }
1544 
1545     if (record->has_non_early_klasses() && JvmtiExport::should_post_class_file_load_hook()) {
1546       if (log_is_enabled(Info, cds, heap)) {
1547         ResourceMark rm(THREAD);
1548         log_info(cds, heap)("subgraph %s cannot be used because JVMTI ClassFileLoadHook is enabled",
1549                             k->external_name());
1550       }
1551       return nullptr;
1552     }
1553 
1554     if (log_is_enabled(Info, cds, heap)) {
1555       ResourceMark rm;
1556       log_info(cds, heap)("%s subgraph %s ", do_init ? "init" : "resolve", k->external_name());
1557     }
1558 
1559     resolve_or_init(k, do_init, CHECK_NULL);
1560 
1561     // Load/link/initialize the klasses of the objects in the subgraph.
1562     // nullptr class loader is used.
1563     Array<Klass*>* klasses = record->subgraph_object_klasses();
1564     if (klasses != nullptr) {
1565       for (int i = 0; i < klasses->length(); i++) {
1566         Klass* klass = klasses->at(i);
1567         if (!klass->is_shared()) {
1568           return nullptr;
1569         }
1570         resolve_or_init(klass, do_init, CHECK_NULL);
1571       }
1572     }
1573   }
1574 
1575   return record;
1576 }
1577 
1578 void HeapShared::resolve_or_init(const char* klass_name, bool do_init, TRAPS) {
1579   TempNewSymbol klass_name_sym =  SymbolTable::new_symbol(klass_name);
1580   InstanceKlass* k = SystemDictionaryShared::find_builtin_class(klass_name_sym);
1581   if (k == nullptr) {
1582     return;
1583   }
1584   assert(k->is_shared_boot_class(), "sanity");
1585   resolve_or_init(k, false, CHECK);
1586   if (do_init) {
1587     resolve_or_init(k, true, CHECK);
1588   }
1589 }
1590 
1591 void HeapShared::resolve_or_init(Klass* k, bool do_init, TRAPS) {
1592   if (!do_init) {
1593     if (k->class_loader_data() == nullptr) {
1594       Klass* resolved_k = SystemDictionary::resolve_or_null(k->name(), CHECK);
1595       assert(resolved_k == k, "classes used by archived heap must not be replaced by JVMTI ClassFileLoadHook");
1596     }
1597   } else {
1598     assert(k->class_loader_data() != nullptr, "must have been resolved by HeapShared::resolve_classes");
1599     if (k->is_instance_klass()) {
1600       InstanceKlass* ik = InstanceKlass::cast(k);
1601       ik->initialize(CHECK);
1602     } else if (k->is_objArray_klass()) {
1603       ObjArrayKlass* oak = ObjArrayKlass::cast(k);
1604       oak->initialize(CHECK);
1605     }
1606   }
1607 }
1608 
1609 void HeapShared::init_archived_fields_for(Klass* k, const ArchivedKlassSubGraphInfoRecord* record) {
1610   verify_the_heap(k, "before");
1611 
1612   // Load the subgraph entry fields from the record and store them back to
1613   // the corresponding fields within the mirror.
1614   oop m = k->java_mirror();
1615   Array<int>* entry_field_records = record->entry_field_records();
1616   if (entry_field_records != nullptr) {
1617     int efr_len = entry_field_records->length();
1618     assert(efr_len % 2 == 0, "sanity");
1619     for (int i = 0; i < efr_len; i += 2) {
1620       int field_offset = entry_field_records->at(i);
1621       int root_index = entry_field_records->at(i+1);
1622       oop v = get_root(root_index, /*clear=*/true);
1623       if (k->has_aot_initialized_mirror()) {
1624         assert(v == m->obj_field(field_offset), "must be aot-initialized");
1625       } else {
1626         m->obj_field_put(field_offset, v);
1627       }
1628       log_debug(cds, heap)("  " PTR_FORMAT " init field @ %2d = " PTR_FORMAT, p2i(k), field_offset, p2i(v));
1629     }
1630 
1631     // Done. Java code can see the archived sub-graphs referenced from k's
1632     // mirror after this point.
1633     if (log_is_enabled(Info, cds, heap)) {
1634       ResourceMark rm;
1635       log_info(cds, heap)("initialize_from_archived_subgraph %s " PTR_FORMAT "%s%s",
1636                           k->external_name(), p2i(k), JvmtiExport::is_early_phase() ? " (early)" : "",
1637                           k->has_aot_initialized_mirror() ? " (aot-inited)" : "");
1638     }
1639   }
1640 
1641   verify_the_heap(k, "after ");
1642 }
1643 
1644 void HeapShared::clear_archived_roots_of(Klass* k) {
1645   unsigned int hash = SystemDictionaryShared::hash_for_shared_dictionary_quick(k);
1646   const ArchivedKlassSubGraphInfoRecord* record = _run_time_subgraph_info_table.lookup(k, hash, 0);
1647   if (record != nullptr) {
1648     Array<int>* entry_field_records = record->entry_field_records();
1649     if (entry_field_records != nullptr) {
1650       int efr_len = entry_field_records->length();
1651       assert(efr_len % 2 == 0, "sanity");
1652       for (int i = 0; i < efr_len; i += 2) {
1653         int root_index = entry_field_records->at(i+1);
1654         clear_root(root_index);
1655       }
1656     }
1657   }
1658 }
1659 
1660 class WalkOopAndArchiveClosure: public BasicOopIterateClosure {
1661   int _level;
1662   bool _record_klasses_only;
1663   KlassSubGraphInfo* _subgraph_info;
1664   oop _referencing_obj;
1665 
1666   // The following are for maintaining a stack for determining
1667   // CachedOopInfo::_referrer
1668   static WalkOopAndArchiveClosure* _current;
1669   WalkOopAndArchiveClosure* _last;
1670  public:
1671   WalkOopAndArchiveClosure(int level,
1672                            bool record_klasses_only,
1673                            KlassSubGraphInfo* subgraph_info,
1674                            oop orig) :
1675     _level(level),
1676     _record_klasses_only(record_klasses_only),
1677     _subgraph_info(subgraph_info),
1678     _referencing_obj(orig) {
1679     _last = _current;
1680     _current = this;
1681   }
1682   ~WalkOopAndArchiveClosure() {
1683     _current = _last;
1684   }
1685   void do_oop(narrowOop *p) { WalkOopAndArchiveClosure::do_oop_work(p); }
1686   void do_oop(      oop *p) { WalkOopAndArchiveClosure::do_oop_work(p); }
1687 
1688  protected:
1689   template <class T> void do_oop_work(T *p) {
1690     oop obj = RawAccess<>::oop_load(p);
1691     if (!CompressedOops::is_null(obj)) {
1692       size_t field_delta = pointer_delta(p, _referencing_obj, sizeof(char));
1693 
1694       if (!_record_klasses_only && log_is_enabled(Debug, cds, heap)) {
1695         ResourceMark rm;
1696         log_debug(cds, heap)("(%d) %s[" SIZE_FORMAT "] ==> " PTR_FORMAT " size " SIZE_FORMAT " %s", _level,
1697                              _referencing_obj->klass()->external_name(), field_delta,
1698                              p2i(obj), obj->size() * HeapWordSize, obj->klass()->external_name());
1699         if (log_is_enabled(Trace, cds, heap)) {
1700           LogTarget(Trace, cds, heap) log;
1701           LogStream out(log);
1702           obj->print_on(&out);
1703         }
1704       }
1705 
1706       bool success = HeapShared::archive_reachable_objects_from(
1707           _level + 1, _subgraph_info, obj);
1708       assert(success, "VM should have exited with unarchivable objects for _level > 1");
1709     }
1710   }
1711 
1712  public:
1713   static WalkOopAndArchiveClosure* current()  { return _current;              }
1714   oop referencing_obj()                       { return _referencing_obj;      }
1715   KlassSubGraphInfo* subgraph_info()          { return _subgraph_info;        }
1716 };
1717 
1718 WalkOopAndArchiveClosure* WalkOopAndArchiveClosure::_current = nullptr;
1719 
1720 // Checks if an oop has any non-null oop fields
1721 class PointsToOopsChecker : public BasicOopIterateClosure {
1722   bool _result;
1723 
1724   template <class T> void check(T *p) {
1725     _result |= (HeapAccess<>::oop_load(p) != nullptr);
1726   }
1727 
1728 public:
1729   PointsToOopsChecker() : _result(false) {}
1730   void do_oop(narrowOop *p) { check(p); }
1731   void do_oop(      oop *p) { check(p); }
1732   bool result() { return _result; }
1733 };
1734 
1735 HeapShared::CachedOopInfo HeapShared::make_cached_oop_info(oop obj) {
1736   WalkOopAndArchiveClosure* walker = WalkOopAndArchiveClosure::current();
1737   oop referrer = (walker == nullptr) ? nullptr : walker->referencing_obj();
1738   PointsToOopsChecker points_to_oops_checker;
1739   obj->oop_iterate(&points_to_oops_checker);
1740   return CachedOopInfo(referrer, points_to_oops_checker.result());
1741 }
1742 
1743 void HeapShared::init_box_classes(TRAPS) {
1744   if (ArchiveHeapLoader::is_in_use()) {
1745     vmClasses::Boolean_klass()->initialize(CHECK);
1746     vmClasses::Character_klass()->initialize(CHECK);
1747     vmClasses::Float_klass()->initialize(CHECK);
1748     vmClasses::Double_klass()->initialize(CHECK);
1749     vmClasses::Byte_klass()->initialize(CHECK);
1750     vmClasses::Short_klass()->initialize(CHECK);
1751     vmClasses::Integer_klass()->initialize(CHECK);
1752     vmClasses::Long_klass()->initialize(CHECK);
1753     vmClasses::Void_klass()->initialize(CHECK);
1754   }
1755 }
1756 
1757 // (1) If orig_obj has not been archived yet, archive it.
1758 // (2) If orig_obj has not been seen yet (since start_recording_subgraph() was called),
1759 //     trace all  objects that are reachable from it, and make sure these objects are archived.
1760 // (3) Record the klasses of all orig_obj and all reachable objects.
1761 bool HeapShared::archive_reachable_objects_from(int level,
1762                                                 KlassSubGraphInfo* subgraph_info,
1763                                                 oop orig_obj) {
1764   assert(orig_obj != nullptr, "must be");
1765 
1766   if (!JavaClasses::is_supported_for_archiving(orig_obj)) {
1767     // This object has injected fields that cannot be supported easily, so we disallow them for now.
1768     // If you get an error here, you probably made a change in the JDK library that has added
1769     // these objects that are referenced (directly or indirectly) by static fields.
1770     ResourceMark rm;
1771     log_error(cds, heap)("Cannot archive object " PTR_FORMAT " of class %s", p2i(orig_obj), orig_obj->klass()->external_name());
1772     debug_trace();
1773     MetaspaceShared::unrecoverable_writing_error();
1774   }
1775 
1776   if (log_is_enabled(Debug, cds, heap) && java_lang_Class::is_instance(orig_obj)) {
1777     ResourceMark rm;
1778     LogTarget(Debug, cds, heap) log;
1779     LogStream out(log);
1780     out.print("Found java mirror " PTR_FORMAT " ", p2i(orig_obj));
1781     Klass* k = java_lang_Class::as_Klass(orig_obj);
1782     if (k != nullptr) {
1783       out.print("%s", k->external_name());
1784     } else {
1785       out.print("primitive");
1786     }
1787     out.print_cr("; scratch mirror = "  PTR_FORMAT,
1788                  p2i(scratch_java_mirror(orig_obj)));
1789   }
1790 
1791   if (CDSConfig::is_initing_classes_at_dump_time()) {
1792     if (java_lang_Class::is_instance(orig_obj)) {
1793       orig_obj = scratch_java_mirror(orig_obj);
1794       assert(orig_obj != nullptr, "must be archived");
1795     }
1796   } else if (java_lang_Class::is_instance(orig_obj) && subgraph_info != _dump_time_special_subgraph) {
1797     // Without CDSConfig::is_initing_classes_at_dump_time(), we only allow archived objects to
1798     // point to the mirrors of (1) j.l.Object, (2) primitive classes, and (3) box classes. These are initialized
1799     // very early by HeapShared::init_box_classes().
1800     if (orig_obj == vmClasses::Object_klass()->java_mirror()
1801         || java_lang_Class::is_primitive(orig_obj)
1802         || orig_obj == vmClasses::Boolean_klass()->java_mirror()
1803         || orig_obj == vmClasses::Character_klass()->java_mirror()
1804         || orig_obj == vmClasses::Float_klass()->java_mirror()
1805         || orig_obj == vmClasses::Double_klass()->java_mirror()
1806         || orig_obj == vmClasses::Byte_klass()->java_mirror()
1807         || orig_obj == vmClasses::Short_klass()->java_mirror()
1808         || orig_obj == vmClasses::Integer_klass()->java_mirror()
1809         || orig_obj == vmClasses::Long_klass()->java_mirror()
1810         || orig_obj == vmClasses::Void_klass()->java_mirror()) {
1811       orig_obj = scratch_java_mirror(orig_obj);
1812       assert(orig_obj != nullptr, "must be archived");
1813     } else {
1814       // If you get an error here, you probably made a change in the JDK library that has added a Class
1815       // object that is referenced (directly or indirectly) by an ArchivableStaticFieldInfo
1816       // defined at the top of this file.
1817       log_error(cds, heap)("(%d) Unknown java.lang.Class object is in the archived sub-graph", level);
1818       debug_trace();
1819       MetaspaceShared::unrecoverable_writing_error();
1820     }
1821   }
1822 
1823   if (has_been_seen_during_subgraph_recording(orig_obj)) {
1824     // orig_obj has already been archived and traced. Nothing more to do.
1825     return true;
1826   } else {
1827     set_has_been_seen_during_subgraph_recording(orig_obj);
1828   }
1829 
1830   bool already_archived = has_been_archived(orig_obj);
1831   bool record_klasses_only = already_archived;
1832   if (!already_archived) {
1833     ++_num_new_archived_objs;
1834     if (!archive_object(orig_obj)) {
1835       // Skip archiving the sub-graph referenced from the current entry field.
1836       ResourceMark rm;
1837       log_error(cds, heap)(
1838         "Cannot archive the sub-graph referenced from %s object ("
1839         PTR_FORMAT ") size " SIZE_FORMAT ", skipped.",
1840         orig_obj->klass()->external_name(), p2i(orig_obj), orig_obj->size() * HeapWordSize);
1841       if (level == 1) {
1842         // Don't archive a subgraph root that's too big. For archives static fields, that's OK
1843         // as the Java code will take care of initializing this field dynamically.
1844         return false;
1845       } else {
1846         // We don't know how to handle an object that has been archived, but some of its reachable
1847         // objects cannot be archived. Bail out for now. We might need to fix this in the future if
1848         // we have a real use case.
1849         MetaspaceShared::unrecoverable_writing_error();
1850       }
1851     }
1852   }
1853 
1854   Klass *orig_k = orig_obj->klass();
1855   subgraph_info->add_subgraph_object_klass(orig_k);
1856 
1857   WalkOopAndArchiveClosure walker(level, record_klasses_only, subgraph_info, orig_obj);
1858   orig_obj->oop_iterate(&walker);
1859 
1860   if (CDSConfig::is_initing_classes_at_dump_time()) {
1861     // The enum klasses are archived with aot-initialized mirror.
1862     // See AOTClassInitializer::can_archive_initialized_mirror().
1863   } else {
1864     if (CDSEnumKlass::is_enum_obj(orig_obj)) {
1865       CDSEnumKlass::handle_enum_obj(level + 1, subgraph_info, orig_obj);
1866     }
1867   }
1868 
1869   return true;
1870 }
1871 
1872 //
1873 // Start from the given static field in a java mirror and archive the
1874 // complete sub-graph of java heap objects that are reached directly
1875 // or indirectly from the starting object by following references.
1876 // Sub-graph archiving restrictions (current):
1877 //
1878 // - All classes of objects in the archived sub-graph (including the
1879 //   entry class) must be boot class only.
1880 // - No java.lang.Class instance (java mirror) can be included inside
1881 //   an archived sub-graph. Mirror can only be the sub-graph entry object.
1882 //
1883 // The Java heap object sub-graph archiving process (see
1884 // WalkOopAndArchiveClosure):
1885 //
1886 // 1) Java object sub-graph archiving starts from a given static field
1887 // within a Class instance (java mirror). If the static field is a
1888 // reference field and points to a non-null java object, proceed to
1889 // the next step.
1890 //
1891 // 2) Archives the referenced java object. If an archived copy of the
1892 // current object already exists, updates the pointer in the archived
1893 // copy of the referencing object to point to the current archived object.
1894 // Otherwise, proceed to the next step.
1895 //
1896 // 3) Follows all references within the current java object and recursively
1897 // archive the sub-graph of objects starting from each reference.
1898 //
1899 // 4) Updates the pointer in the archived copy of referencing object to
1900 // point to the current archived object.
1901 //
1902 // 5) The Klass of the current java object is added to the list of Klasses
1903 // for loading and initializing before any object in the archived graph can
1904 // be accessed at runtime.
1905 //
1906 void HeapShared::archive_reachable_objects_from_static_field(InstanceKlass *k,
1907                                                              const char* klass_name,
1908                                                              int field_offset,
1909                                                              const char* field_name) {
1910   assert(CDSConfig::is_dumping_heap(), "dump time only");
1911   assert(k->is_shared_boot_class(), "must be boot class");
1912 
1913   oop m = k->java_mirror();
1914 
1915   KlassSubGraphInfo* subgraph_info = get_subgraph_info(k);
1916   oop f = m->obj_field(field_offset);
1917 
1918   log_debug(cds, heap)("Start archiving from: %s::%s (" PTR_FORMAT ")", klass_name, field_name, p2i(f));
1919 
1920   if (!CompressedOops::is_null(f)) {
1921     if (log_is_enabled(Trace, cds, heap)) {
1922       LogTarget(Trace, cds, heap) log;
1923       LogStream out(log);
1924       f->print_on(&out);
1925     }
1926 
1927     bool success = archive_reachable_objects_from(1, subgraph_info, f);
1928     if (!success) {
1929       log_error(cds, heap)("Archiving failed %s::%s (some reachable objects cannot be archived)",
1930                            klass_name, field_name);
1931     } else {
1932       // Note: the field value is not preserved in the archived mirror.
1933       // Record the field as a new subGraph entry point. The recorded
1934       // information is restored from the archive at runtime.
1935       subgraph_info->add_subgraph_entry_field(field_offset, f);
1936       log_info(cds, heap)("Archived field %s::%s => " PTR_FORMAT, klass_name, field_name, p2i(f));
1937     }
1938   } else {
1939     // The field contains null, we still need to record the entry point,
1940     // so it can be restored at runtime.
1941     subgraph_info->add_subgraph_entry_field(field_offset, nullptr);
1942   }
1943 }
1944 
1945 #ifndef PRODUCT
1946 class VerifySharedOopClosure: public BasicOopIterateClosure {
1947  public:
1948   void do_oop(narrowOop *p) { VerifySharedOopClosure::do_oop_work(p); }
1949   void do_oop(      oop *p) { VerifySharedOopClosure::do_oop_work(p); }
1950 
1951  protected:
1952   template <class T> void do_oop_work(T *p) {
1953     oop obj = RawAccess<>::oop_load(p);
1954     if (!CompressedOops::is_null(obj)) {
1955       HeapShared::verify_reachable_objects_from(obj);
1956     }
1957   }
1958 };
1959 
1960 void HeapShared::verify_subgraph_from_static_field(InstanceKlass* k, int field_offset) {
1961   assert(CDSConfig::is_dumping_heap(), "dump time only");
1962   assert(k->is_shared_boot_class(), "must be boot class");
1963 
1964   oop m = k->java_mirror();
1965   oop f = m->obj_field(field_offset);
1966   if (!CompressedOops::is_null(f)) {
1967     verify_subgraph_from(f);
1968   }
1969 }
1970 
1971 void HeapShared::verify_subgraph_from(oop orig_obj) {
1972   if (!has_been_archived(orig_obj)) {
1973     // It's OK for the root of a subgraph to be not archived. See comments in
1974     // archive_reachable_objects_from().
1975     return;
1976   }
1977 
1978   // Verify that all objects reachable from orig_obj are archived.
1979   init_seen_objects_table();
1980   verify_reachable_objects_from(orig_obj);
1981   delete_seen_objects_table();
1982 }
1983 
1984 void HeapShared::verify_reachable_objects_from(oop obj) {
1985   _num_total_verifications ++;
1986   if (java_lang_Class::is_instance(obj)) {
1987     obj = scratch_java_mirror(obj);
1988     assert(obj != nullptr, "must be");
1989   }
1990   if (!has_been_seen_during_subgraph_recording(obj)) {
1991     set_has_been_seen_during_subgraph_recording(obj);
1992     assert(has_been_archived(obj), "must be");
1993     VerifySharedOopClosure walker;
1994     obj->oop_iterate(&walker);
1995   }
1996 }
1997 #endif
1998 
1999 void HeapShared::check_special_subgraph_classes() {
2000   if (CDSConfig::is_initing_classes_at_dump_time()) {
2001     // We can have aot-initialized classes (such as Enums) that can reference objects
2002     // of arbitrary types. Currently, we trust the JEP 483 implementation to only
2003     // aot-initialize classes that are "safe".
2004     //
2005     // TODO: we need an automatic tool that checks the safety of aot-initialized
2006     // classes (when we extend the set of aot-initialized classes beyond JEP 483)
2007     return;
2008   } else {
2009     // In this case, the special subgraph should contain a few specific types
2010     GrowableArray<Klass*>* klasses = _dump_time_special_subgraph->subgraph_object_klasses();
2011     int num = klasses->length();
2012     for (int i = 0; i < num; i++) {
2013       Klass* subgraph_k = klasses->at(i);
2014       Symbol* name = ArchiveBuilder::current()->get_source_addr(subgraph_k->name());
2015       if (subgraph_k->is_instance_klass() &&
2016           name != vmSymbols::java_lang_Class() &&
2017           name != vmSymbols::java_lang_String() &&
2018           name != vmSymbols::java_lang_ArithmeticException() &&
2019           name != vmSymbols::java_lang_ArrayIndexOutOfBoundsException() &&
2020           name != vmSymbols::java_lang_ArrayStoreException() &&
2021           name != vmSymbols::java_lang_ClassCastException() &&
2022           name != vmSymbols::java_lang_InternalError() &&
2023           name != vmSymbols::java_lang_NullPointerException()) {
2024         ResourceMark rm;
2025         fatal("special subgraph cannot have objects of type %s", subgraph_k->external_name());
2026       }
2027     }
2028   }
2029 }
2030 
2031 HeapShared::SeenObjectsTable* HeapShared::_seen_objects_table = nullptr;
2032 int HeapShared::_num_new_walked_objs;
2033 int HeapShared::_num_new_archived_objs;
2034 int HeapShared::_num_old_recorded_klasses;
2035 
2036 int HeapShared::_num_total_subgraph_recordings = 0;
2037 int HeapShared::_num_total_walked_objs = 0;
2038 int HeapShared::_num_total_archived_objs = 0;
2039 int HeapShared::_num_total_recorded_klasses = 0;
2040 int HeapShared::_num_total_verifications = 0;
2041 
2042 bool HeapShared::has_been_seen_during_subgraph_recording(oop obj) {
2043   return _seen_objects_table->get(obj) != nullptr;
2044 }
2045 
2046 void HeapShared::set_has_been_seen_during_subgraph_recording(oop obj) {
2047   assert(!has_been_seen_during_subgraph_recording(obj), "sanity");
2048   _seen_objects_table->put_when_absent(obj, true);
2049   _seen_objects_table->maybe_grow();
2050   ++ _num_new_walked_objs;
2051 }
2052 
2053 void HeapShared::start_recording_subgraph(InstanceKlass *k, const char* class_name, bool is_full_module_graph) {
2054   log_info(cds, heap)("Start recording subgraph(s) for archived fields in %s", class_name);
2055   init_subgraph_info(k, is_full_module_graph);
2056   init_seen_objects_table();
2057   _num_new_walked_objs = 0;
2058   _num_new_archived_objs = 0;
2059   _num_old_recorded_klasses = get_subgraph_info(k)->num_subgraph_object_klasses();
2060 }
2061 
2062 void HeapShared::done_recording_subgraph(InstanceKlass *k, const char* class_name) {
2063   int num_new_recorded_klasses = get_subgraph_info(k)->num_subgraph_object_klasses() -
2064     _num_old_recorded_klasses;
2065   log_info(cds, heap)("Done recording subgraph(s) for archived fields in %s: "
2066                       "walked %d objs, archived %d new objs, recorded %d classes",
2067                       class_name, _num_new_walked_objs, _num_new_archived_objs,
2068                       num_new_recorded_klasses);
2069 
2070   delete_seen_objects_table();
2071 
2072   _num_total_subgraph_recordings ++;
2073   _num_total_walked_objs      += _num_new_walked_objs;
2074   _num_total_archived_objs    += _num_new_archived_objs;
2075   _num_total_recorded_klasses +=  num_new_recorded_klasses;
2076 }
2077 
2078 class ArchivableStaticFieldFinder: public FieldClosure {
2079   InstanceKlass* _ik;
2080   Symbol* _field_name;
2081   bool _found;
2082   int _offset;
2083 public:
2084   ArchivableStaticFieldFinder(InstanceKlass* ik, Symbol* field_name) :
2085     _ik(ik), _field_name(field_name), _found(false), _offset(-1) {}
2086 
2087   virtual void do_field(fieldDescriptor* fd) {
2088     if (fd->name() == _field_name) {
2089       assert(!_found, "fields can never be overloaded");
2090       if (is_reference_type(fd->field_type())) {
2091         _found = true;
2092         _offset = fd->offset();
2093       }
2094     }
2095   }
2096   bool found()     { return _found;  }
2097   int offset()     { return _offset; }
2098 };
2099 
2100 void HeapShared::init_subgraph_entry_fields(ArchivableStaticFieldInfo fields[],
2101                                             TRAPS) {
2102   for (int i = 0; fields[i].valid(); i++) {
2103     ArchivableStaticFieldInfo* info = &fields[i];
2104     TempNewSymbol klass_name =  SymbolTable::new_symbol(info->klass_name);
2105     TempNewSymbol field_name =  SymbolTable::new_symbol(info->field_name);
2106     ResourceMark rm; // for stringStream::as_string() etc.
2107 
2108 #ifndef PRODUCT
2109     bool is_test_class = (ArchiveHeapTestClass != nullptr) && (strcmp(info->klass_name, ArchiveHeapTestClass) == 0);
2110     const char* test_class_name = ArchiveHeapTestClass;
2111 #else
2112     bool is_test_class = false;
2113     const char* test_class_name = ""; // avoid C++ printf checks warnings.
2114 #endif
2115 
2116     if (is_test_class) {
2117       log_warning(cds)("Loading ArchiveHeapTestClass %s ...", test_class_name);
2118     }
2119 
2120     Klass* k = SystemDictionary::resolve_or_fail(klass_name, true, THREAD);
2121     if (HAS_PENDING_EXCEPTION) {
2122       CLEAR_PENDING_EXCEPTION;
2123       stringStream st;
2124       st.print("Fail to initialize archive heap: %s cannot be loaded by the boot loader", info->klass_name);
2125       THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), st.as_string());
2126     }
2127 
2128     if (!k->is_instance_klass()) {
2129       stringStream st;
2130       st.print("Fail to initialize archive heap: %s is not an instance class", info->klass_name);
2131       THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), st.as_string());
2132     }
2133 
2134     InstanceKlass* ik = InstanceKlass::cast(k);
2135     assert(InstanceKlass::cast(ik)->is_shared_boot_class(),
2136            "Only support boot classes");
2137 
2138     if (is_test_class) {
2139       if (ik->module()->is_named()) {
2140         // We don't want ArchiveHeapTestClass to be abused to easily load/initialize arbitrary
2141         // core-lib classes. You need to at least append to the bootclasspath.
2142         stringStream st;
2143         st.print("ArchiveHeapTestClass %s is not in unnamed module", test_class_name);
2144         THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), st.as_string());
2145       }
2146 
2147       if (ik->package() != nullptr) {
2148         // This restriction makes HeapShared::is_a_test_class_in_unnamed_module() easy.
2149         stringStream st;
2150         st.print("ArchiveHeapTestClass %s is not in unnamed package", test_class_name);
2151         THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), st.as_string());
2152       }
2153     } else {
2154       if (ik->module()->name() != vmSymbols::java_base()) {
2155         // We don't want to deal with cases when a module is unavailable at runtime.
2156         // FUTURE -- load from archived heap only when module graph has not changed
2157         //           between dump and runtime.
2158         stringStream st;
2159         st.print("%s is not in java.base module", info->klass_name);
2160         THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), st.as_string());
2161       }
2162     }
2163 
2164     if (is_test_class) {
2165       log_warning(cds)("Initializing ArchiveHeapTestClass %s ...", test_class_name);
2166     }
2167     ik->initialize(CHECK);
2168 
2169     ArchivableStaticFieldFinder finder(ik, field_name);
2170     ik->do_local_static_fields(&finder);
2171     if (!finder.found()) {
2172       stringStream st;
2173       st.print("Unable to find the static T_OBJECT field %s::%s", info->klass_name, info->field_name);
2174       THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), st.as_string());
2175     }
2176 
2177     info->klass = ik;
2178     info->offset = finder.offset();
2179   }
2180 }
2181 
2182 void HeapShared::init_subgraph_entry_fields(TRAPS) {
2183   assert(HeapShared::can_write(), "must be");
2184   _dump_time_subgraph_info_table = new (mtClass)DumpTimeKlassSubGraphInfoTable();
2185   init_subgraph_entry_fields(archive_subgraph_entry_fields, CHECK);
2186   if (CDSConfig::is_dumping_full_module_graph()) {
2187     init_subgraph_entry_fields(fmg_archive_subgraph_entry_fields, CHECK);
2188   }
2189 }
2190 
2191 #ifndef PRODUCT
2192 void HeapShared::setup_test_class(const char* test_class_name) {
2193   ArchivableStaticFieldInfo* p = archive_subgraph_entry_fields;
2194   int num_slots = sizeof(archive_subgraph_entry_fields) / sizeof(ArchivableStaticFieldInfo);
2195   assert(p[num_slots - 2].klass_name == nullptr, "must have empty slot that's patched below");
2196   assert(p[num_slots - 1].klass_name == nullptr, "must have empty slot that marks the end of the list");
2197 
2198   if (test_class_name != nullptr) {
2199     p[num_slots - 2].klass_name = test_class_name;
2200     p[num_slots - 2].field_name = ARCHIVE_TEST_FIELD_NAME;
2201   }
2202 }
2203 
2204 // See if ik is one of the test classes that are pulled in by -XX:ArchiveHeapTestClass
2205 // during runtime. This may be called before the module system is initialized so
2206 // we cannot rely on InstanceKlass::module(), etc.
2207 bool HeapShared::is_a_test_class_in_unnamed_module(Klass* ik) {
2208   if (_test_class != nullptr) {
2209     if (ik == _test_class) {
2210       return true;
2211     }
2212     Array<Klass*>* klasses = _test_class_record->subgraph_object_klasses();
2213     if (klasses == nullptr) {
2214       return false;
2215     }
2216 
2217     for (int i = 0; i < klasses->length(); i++) {
2218       Klass* k = klasses->at(i);
2219       if (k == ik) {
2220         Symbol* name;
2221         if (k->is_instance_klass()) {
2222           name = InstanceKlass::cast(k)->name();
2223         } else if (k->is_objArray_klass()) {
2224           Klass* bk = ObjArrayKlass::cast(k)->bottom_klass();
2225           if (!bk->is_instance_klass()) {
2226             return false;
2227           }
2228           name = bk->name();
2229         } else {
2230           return false;
2231         }
2232 
2233         // See KlassSubGraphInfo::check_allowed_klass() - we only allow test classes
2234         // to be:
2235         //   (A) java.base classes (which must not be in the unnamed module)
2236         //   (B) test classes which must be in the unnamed package of the unnamed module.
2237         // So if we see a '/' character in the class name, it must be in (A);
2238         // otherwise it must be in (B).
2239         if (name->index_of_at(0, "/", 1)  >= 0) {
2240           return false; // (A)
2241         }
2242 
2243         return true; // (B)
2244       }
2245     }
2246   }
2247 
2248   return false;
2249 }
2250 
2251 void HeapShared::initialize_test_class_from_archive(JavaThread* current) {
2252   Klass* k = _test_class;
2253   if (k != nullptr && ArchiveHeapLoader::is_in_use()) {
2254     JavaThread* THREAD = current;
2255     ExceptionMark em(THREAD);
2256     const ArchivedKlassSubGraphInfoRecord* record =
2257       resolve_or_init_classes_for_subgraph_of(k, /*do_init=*/false, THREAD);
2258 
2259     // The _test_class is in the unnamed module, so it can't call CDS.initializeFromArchive()
2260     // from its <clinit> method. So we set up its "archivedObjects" field first, before
2261     // calling its <clinit>. This is not strictly clean, but it's a convenient way to write unit
2262     // test cases (see test/hotspot/jtreg/runtime/cds/appcds/cacheObject/ArchiveHeapTestClass.java).
2263     if (record != nullptr) {
2264       init_archived_fields_for(k, record);
2265     }
2266     resolve_or_init_classes_for_subgraph_of(k, /*do_init=*/true, THREAD);
2267   }
2268 }
2269 #endif
2270 
2271 void HeapShared::init_for_dumping(TRAPS) {
2272   if (HeapShared::can_write()) {
2273     setup_test_class(ArchiveHeapTestClass);
2274     _dumped_interned_strings = new (mtClass)DumpedInternedStrings(INITIAL_TABLE_SIZE, MAX_TABLE_SIZE);
2275     init_subgraph_entry_fields(CHECK);
2276   }
2277 }
2278 
2279 void HeapShared::archive_object_subgraphs(ArchivableStaticFieldInfo fields[],
2280                                           bool is_full_module_graph) {
2281   _num_total_subgraph_recordings = 0;
2282   _num_total_walked_objs = 0;
2283   _num_total_archived_objs = 0;
2284   _num_total_recorded_klasses = 0;
2285   _num_total_verifications = 0;
2286 
2287   // For each class X that has one or more archived fields:
2288   // [1] Dump the subgraph of each archived field
2289   // [2] Create a list of all the class of the objects that can be reached
2290   //     by any of these static fields.
2291   //     At runtime, these classes are initialized before X's archived fields
2292   //     are restored by HeapShared::initialize_from_archived_subgraph().
2293   for (int i = 0; fields[i].valid(); ) {
2294     ArchivableStaticFieldInfo* info = &fields[i];
2295     const char* klass_name = info->klass_name;
2296     start_recording_subgraph(info->klass, klass_name, is_full_module_graph);
2297 
2298     // If you have specified consecutive fields of the same klass in
2299     // fields[], these will be archived in the same
2300     // {start_recording_subgraph ... done_recording_subgraph} pass to
2301     // save time.
2302     for (; fields[i].valid(); i++) {
2303       ArchivableStaticFieldInfo* f = &fields[i];
2304       if (f->klass_name != klass_name) {
2305         break;
2306       }
2307 
2308       archive_reachable_objects_from_static_field(f->klass, f->klass_name,
2309                                                   f->offset, f->field_name);
2310     }
2311     done_recording_subgraph(info->klass, klass_name);
2312   }
2313 
2314   log_info(cds, heap)("Archived subgraph records = %d",
2315                       _num_total_subgraph_recordings);
2316   log_info(cds, heap)("  Walked %d objects", _num_total_walked_objs);
2317   log_info(cds, heap)("  Archived %d objects", _num_total_archived_objs);
2318   log_info(cds, heap)("  Recorded %d klasses", _num_total_recorded_klasses);
2319 
2320 #ifndef PRODUCT
2321   for (int i = 0; fields[i].valid(); i++) {
2322     ArchivableStaticFieldInfo* f = &fields[i];
2323     verify_subgraph_from_static_field(f->klass, f->offset);
2324   }
2325   log_info(cds, heap)("  Verified %d references", _num_total_verifications);
2326 #endif
2327 }
2328 
2329 // Not all the strings in the global StringTable are dumped into the archive, because
2330 // some of those strings may be only referenced by classes that are excluded from
2331 // the archive. We need to explicitly mark the strings that are:
2332 //   [1] used by classes that WILL be archived;
2333 //   [2] included in the SharedArchiveConfigFile.
2334 void HeapShared::add_to_dumped_interned_strings(oop string) {
2335   assert_at_safepoint(); // DumpedInternedStrings uses raw oops
2336   assert(!ArchiveHeapWriter::is_string_too_large_to_archive(string), "must be");
2337   bool created;
2338   _dumped_interned_strings->put_if_absent(string, true, &created);
2339   if (created) {
2340     _dumped_interned_strings->maybe_grow();
2341   }
2342 }
2343 
2344 void HeapShared::debug_trace() {
2345   ResourceMark rm;
2346   WalkOopAndArchiveClosure* walker = WalkOopAndArchiveClosure::current();
2347   if (walker != nullptr) {
2348     LogStream ls(Log(cds, heap)::error());
2349     CDSHeapVerifier::trace_to_root(&ls, walker->referencing_obj());
2350   }
2351 }
2352 
2353 #ifndef PRODUCT
2354 // At dump-time, find the location of all the non-null oop pointers in an archived heap
2355 // region. This way we can quickly relocate all the pointers without using
2356 // BasicOopIterateClosure at runtime.
2357 class FindEmbeddedNonNullPointers: public BasicOopIterateClosure {
2358   void* _start;
2359   BitMap *_oopmap;
2360   int _num_total_oops;
2361   int _num_null_oops;
2362  public:
2363   FindEmbeddedNonNullPointers(void* start, BitMap* oopmap)
2364     : _start(start), _oopmap(oopmap), _num_total_oops(0),  _num_null_oops(0) {}
2365 
2366   virtual void do_oop(narrowOop* p) {
2367     assert(UseCompressedOops, "sanity");
2368     _num_total_oops ++;
2369     narrowOop v = *p;
2370     if (!CompressedOops::is_null(v)) {
2371       size_t idx = p - (narrowOop*)_start;
2372       _oopmap->set_bit(idx);
2373     } else {
2374       _num_null_oops ++;
2375     }
2376   }
2377   virtual void do_oop(oop* p) {
2378     assert(!UseCompressedOops, "sanity");
2379     _num_total_oops ++;
2380     if ((*p) != nullptr) {
2381       size_t idx = p - (oop*)_start;
2382       _oopmap->set_bit(idx);
2383     } else {
2384       _num_null_oops ++;
2385     }
2386   }
2387   int num_total_oops() const { return _num_total_oops; }
2388   int num_null_oops()  const { return _num_null_oops; }
2389 };
2390 #endif
2391 
2392 void HeapShared::count_allocation(size_t size) {
2393   _total_obj_count ++;
2394   _total_obj_size += size;
2395   for (int i = 0; i < ALLOC_STAT_SLOTS; i++) {
2396     if (size <= (size_t(1) << i)) {
2397       _alloc_count[i] ++;
2398       _alloc_size[i] += size;
2399       return;
2400     }
2401   }
2402 }
2403 
2404 static double avg_size(size_t size, size_t count) {
2405   double avg = 0;
2406   if (count > 0) {
2407     avg = double(size * HeapWordSize) / double(count);
2408   }
2409   return avg;
2410 }
2411 
2412 void HeapShared::print_stats() {
2413   size_t huge_count = _total_obj_count;
2414   size_t huge_size = _total_obj_size;
2415 
2416   for (int i = 0; i < ALLOC_STAT_SLOTS; i++) {
2417     size_t byte_size_limit = (size_t(1) << i) * HeapWordSize;
2418     size_t count = _alloc_count[i];
2419     size_t size = _alloc_size[i];
2420     log_info(cds, heap)(SIZE_FORMAT_W(8) " objects are <= " SIZE_FORMAT_W(-6)
2421                         " bytes (total " SIZE_FORMAT_W(8) " bytes, avg %8.1f bytes)",
2422                         count, byte_size_limit, size * HeapWordSize, avg_size(size, count));
2423     huge_count -= count;
2424     huge_size -= size;
2425   }
2426 
2427   log_info(cds, heap)(SIZE_FORMAT_W(8) " huge  objects               (total "  SIZE_FORMAT_W(8) " bytes"
2428                       ", avg %8.1f bytes)",
2429                       huge_count, huge_size * HeapWordSize,
2430                       avg_size(huge_size, huge_count));
2431   log_info(cds, heap)(SIZE_FORMAT_W(8) " total objects               (total "  SIZE_FORMAT_W(8) " bytes"
2432                       ", avg %8.1f bytes)",
2433                       _total_obj_count, _total_obj_size * HeapWordSize,
2434                       avg_size(_total_obj_size, _total_obj_count));
2435 }
2436 
2437 bool HeapShared::is_archived_boot_layer_available(JavaThread* current) {
2438   TempNewSymbol klass_name = SymbolTable::new_symbol(ARCHIVED_BOOT_LAYER_CLASS);
2439   InstanceKlass* k = SystemDictionary::find_instance_klass(current, klass_name, Handle(), Handle());
2440   if (k == nullptr) {
2441     return false;
2442   } else {
2443     TempNewSymbol field_name = SymbolTable::new_symbol(ARCHIVED_BOOT_LAYER_FIELD);
2444     TempNewSymbol field_signature = SymbolTable::new_symbol("Ljdk/internal/module/ArchivedBootLayer;");
2445     fieldDescriptor fd;
2446     if (k->find_field(field_name, field_signature, true, &fd) != nullptr) {
2447       oop m = k->java_mirror();
2448       oop f = m->obj_field(fd.offset());
2449       if (CompressedOops::is_null(f)) {
2450         return false;
2451       }
2452     } else {
2453       return false;
2454     }
2455   }
2456   return true;
2457 }
2458 
2459 #endif // INCLUDE_CDS_JAVA_HEAP