60 #include "classfile/vmClasses.hpp"
61 #include "classfile/vmSymbols.hpp"
62 #include "code/aotCodeCache.hpp"
63 #include "code/codeCache.hpp"
64 #include "gc/shared/gcVMOperations.hpp"
65 #include "interpreter/bytecodes.hpp"
66 #include "interpreter/bytecodeStream.hpp"
67 #include "jvm_io.h"
68 #include "logging/log.hpp"
69 #include "logging/logMessage.hpp"
70 #include "logging/logStream.hpp"
71 #include "memory/memoryReserver.hpp"
72 #include "memory/metaspace.hpp"
73 #include "memory/metaspaceClosure.hpp"
74 #include "memory/oopFactory.hpp"
75 #include "memory/resourceArea.hpp"
76 #include "memory/universe.hpp"
77 #include "nmt/memTracker.hpp"
78 #include "oops/compressedKlass.hpp"
79 #include "oops/constantPool.inline.hpp"
80 #include "oops/instanceMirrorKlass.hpp"
81 #include "oops/klass.inline.hpp"
82 #include "oops/objArrayOop.hpp"
83 #include "oops/oop.inline.hpp"
84 #include "oops/oopHandle.hpp"
85 #include "oops/resolvedFieldEntry.hpp"
86 #include "oops/trainingData.hpp"
87 #include "prims/jvmtiExport.hpp"
88 #include "runtime/arguments.hpp"
89 #include "runtime/globals.hpp"
90 #include "runtime/globals_extension.hpp"
91 #include "runtime/handles.inline.hpp"
92 #include "runtime/javaCalls.hpp"
93 #include "runtime/os.inline.hpp"
94 #include "runtime/safepointVerifiers.hpp"
95 #include "runtime/sharedRuntime.hpp"
96 #include "runtime/vmOperations.hpp"
97 #include "runtime/vmThread.hpp"
98 #include "sanitizers/leak.hpp"
99 #include "utilities/align.hpp"
465 // AOTMetaspace::early_serialize(). Such functions must not produce side effects that
466 // assume we will always decides to map the archive.
467
468 void AOTMetaspace::early_serialize(SerializeClosure* soc) {
469 int tag = 0;
470 soc->do_tag(--tag);
471 CDS_JAVA_HEAP_ONLY(Modules::serialize_archived_module_info(soc);)
472 soc->do_tag(666);
473 }
474
475 void AOTMetaspace::serialize(SerializeClosure* soc) {
476 int tag = 0;
477 soc->do_tag(--tag);
478
479 // Verify the sizes of various metadata in the system.
480 soc->do_tag(sizeof(Method));
481 soc->do_tag(sizeof(ConstMethod));
482 soc->do_tag(arrayOopDesc::base_offset_in_bytes(T_BYTE));
483 soc->do_tag(sizeof(ConstantPool));
484 soc->do_tag(sizeof(ConstantPoolCache));
485 soc->do_tag(objArrayOopDesc::base_offset_in_bytes());
486 soc->do_tag(typeArrayOopDesc::base_offset_in_bytes(T_BYTE));
487 soc->do_tag(sizeof(Symbol));
488
489 // Need to do this first, as subsequent steps may call virtual functions
490 // in archived Metadata objects.
491 CppVtables::serialize(soc);
492 soc->do_tag(--tag);
493
494 // Dump/restore miscellaneous metadata.
495 JavaClasses::serialize_offsets(soc);
496 Universe::serialize(soc);
497 soc->do_tag(--tag);
498
499 // Dump/restore references to commonly used names and signatures.
500 vmSymbols::serialize(soc);
501 soc->do_tag(--tag);
502
503 // Dump/restore the symbol/string/subgraph_info tables
504 SymbolTable::serialize_shared_table_header(soc);
505 StringTable::serialize_shared_table_header(soc);
1334 }
1335 ik->link_class(THREAD);
1336 if (HAS_PENDING_EXCEPTION) {
1337 ResourceMark rm(THREAD);
1338 aot_log_warning(aot)("Preload Warning: Verification failed for %s",
1339 ik->external_name());
1340 CLEAR_PENDING_EXCEPTION;
1341 SystemDictionaryShared::set_class_has_failed_verification(ik);
1342 } else {
1343 assert(!SystemDictionaryShared::has_class_failed_verification(ik), "sanity");
1344 ik->compute_has_loops_flag_for_methods();
1345 }
1346 BytecodeVerificationLocal = saved;
1347 return true;
1348 } else {
1349 return false;
1350 }
1351 }
1352
1353 void VM_PopulateDumpSharedSpace::dump_java_heap_objects() {
1354 if (CDSConfig::is_dumping_heap()) {
1355 HeapShared::write_heap(&_mapped_heap_info, &_streamed_heap_info);
1356 } else {
1357 CDSConfig::log_reasons_for_not_dumping_heap();
1358 }
1359 }
1360
1361 void AOTMetaspace::set_aot_metaspace_range(void* base, void *static_top, void* top) {
1362 assert(base <= static_top && static_top <= top, "must be");
1363 _aot_metaspace_static_top = static_top;
1364 MetaspaceObj::set_aot_metaspace_range(base, top);
1365 }
1366
1367 bool AOTMetaspace::in_aot_cache_dynamic_region(void* p) {
1368 if ((p < MetaspaceObj::aot_metaspace_top()) &&
1369 (p >= _aot_metaspace_static_top)) {
1370 return true;
1371 } else {
1372 return false;
1373 }
|
60 #include "classfile/vmClasses.hpp"
61 #include "classfile/vmSymbols.hpp"
62 #include "code/aotCodeCache.hpp"
63 #include "code/codeCache.hpp"
64 #include "gc/shared/gcVMOperations.hpp"
65 #include "interpreter/bytecodes.hpp"
66 #include "interpreter/bytecodeStream.hpp"
67 #include "jvm_io.h"
68 #include "logging/log.hpp"
69 #include "logging/logMessage.hpp"
70 #include "logging/logStream.hpp"
71 #include "memory/memoryReserver.hpp"
72 #include "memory/metaspace.hpp"
73 #include "memory/metaspaceClosure.hpp"
74 #include "memory/oopFactory.hpp"
75 #include "memory/resourceArea.hpp"
76 #include "memory/universe.hpp"
77 #include "nmt/memTracker.hpp"
78 #include "oops/compressedKlass.hpp"
79 #include "oops/constantPool.inline.hpp"
80 #include "oops/flatArrayKlass.hpp"
81 #include "oops/inlineKlass.hpp"
82 #include "oops/instanceMirrorKlass.hpp"
83 #include "oops/klass.inline.hpp"
84 #include "oops/objArrayOop.hpp"
85 #include "oops/oop.inline.hpp"
86 #include "oops/oopHandle.hpp"
87 #include "oops/resolvedFieldEntry.hpp"
88 #include "oops/trainingData.hpp"
89 #include "prims/jvmtiExport.hpp"
90 #include "runtime/arguments.hpp"
91 #include "runtime/globals.hpp"
92 #include "runtime/globals_extension.hpp"
93 #include "runtime/handles.inline.hpp"
94 #include "runtime/javaCalls.hpp"
95 #include "runtime/os.inline.hpp"
96 #include "runtime/safepointVerifiers.hpp"
97 #include "runtime/sharedRuntime.hpp"
98 #include "runtime/vmOperations.hpp"
99 #include "runtime/vmThread.hpp"
100 #include "sanitizers/leak.hpp"
101 #include "utilities/align.hpp"
467 // AOTMetaspace::early_serialize(). Such functions must not produce side effects that
468 // assume we will always decides to map the archive.
469
470 void AOTMetaspace::early_serialize(SerializeClosure* soc) {
471 int tag = 0;
472 soc->do_tag(--tag);
473 CDS_JAVA_HEAP_ONLY(Modules::serialize_archived_module_info(soc);)
474 soc->do_tag(666);
475 }
476
477 void AOTMetaspace::serialize(SerializeClosure* soc) {
478 int tag = 0;
479 soc->do_tag(--tag);
480
481 // Verify the sizes of various metadata in the system.
482 soc->do_tag(sizeof(Method));
483 soc->do_tag(sizeof(ConstMethod));
484 soc->do_tag(arrayOopDesc::base_offset_in_bytes(T_BYTE));
485 soc->do_tag(sizeof(ConstantPool));
486 soc->do_tag(sizeof(ConstantPoolCache));
487 soc->do_tag(refArrayOopDesc::base_offset_in_bytes());
488 soc->do_tag(typeArrayOopDesc::base_offset_in_bytes(T_BYTE));
489 soc->do_tag(sizeof(Symbol));
490
491 // Need to do this first, as subsequent steps may call virtual functions
492 // in archived Metadata objects.
493 CppVtables::serialize(soc);
494 soc->do_tag(--tag);
495
496 // Dump/restore miscellaneous metadata.
497 JavaClasses::serialize_offsets(soc);
498 Universe::serialize(soc);
499 soc->do_tag(--tag);
500
501 // Dump/restore references to commonly used names and signatures.
502 vmSymbols::serialize(soc);
503 soc->do_tag(--tag);
504
505 // Dump/restore the symbol/string/subgraph_info tables
506 SymbolTable::serialize_shared_table_header(soc);
507 StringTable::serialize_shared_table_header(soc);
1336 }
1337 ik->link_class(THREAD);
1338 if (HAS_PENDING_EXCEPTION) {
1339 ResourceMark rm(THREAD);
1340 aot_log_warning(aot)("Preload Warning: Verification failed for %s",
1341 ik->external_name());
1342 CLEAR_PENDING_EXCEPTION;
1343 SystemDictionaryShared::set_class_has_failed_verification(ik);
1344 } else {
1345 assert(!SystemDictionaryShared::has_class_failed_verification(ik), "sanity");
1346 ik->compute_has_loops_flag_for_methods();
1347 }
1348 BytecodeVerificationLocal = saved;
1349 return true;
1350 } else {
1351 return false;
1352 }
1353 }
1354
1355 void VM_PopulateDumpSharedSpace::dump_java_heap_objects() {
1356 if (CDSConfig::is_valhalla_preview()) {
1357 log_info(cds)("Archived java heap is not yet supported with Valhalla preview");
1358 return;
1359 }
1360
1361 if (CDSConfig::is_dumping_heap()) {
1362 HeapShared::write_heap(&_mapped_heap_info, &_streamed_heap_info);
1363 } else {
1364 CDSConfig::log_reasons_for_not_dumping_heap();
1365 }
1366 }
1367
1368 void AOTMetaspace::set_aot_metaspace_range(void* base, void *static_top, void* top) {
1369 assert(base <= static_top && static_top <= top, "must be");
1370 _aot_metaspace_static_top = static_top;
1371 MetaspaceObj::set_aot_metaspace_range(base, top);
1372 }
1373
1374 bool AOTMetaspace::in_aot_cache_dynamic_region(void* p) {
1375 if ((p < MetaspaceObj::aot_metaspace_top()) &&
1376 (p >= _aot_metaspace_static_top)) {
1377 return true;
1378 } else {
1379 return false;
1380 }
|