stan/jdk-24
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

8261479: CDS runtime code should check exceptions

Browse Source 
Reviewed-by: minqi, dholmes, iklam
This commit is contained in:
Calvin Cheung 2021-03-23 19:05:50 +00:00
parent 087c8bfb5f
commit 1c9817b0bc
13 changed files with 66 additions and 68 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/hotspot/share/classfile/classListParser.cpp
View File

@ -464,7 +464,7 @@ InstanceKlass* ClassListParser::load_class_from_source(Symbol* class_name, TRAPS
_interfaces->length(), k->local_interfaces()->length());
}
bool added = SystemDictionaryShared::add_unregistered_class(k, CHECK_NULL);
bool added = SystemDictionaryShared::add_unregistered_class(THREAD, k);
if (!added) {
// We allow only a single unregistered class for each unique name.
error("Duplicated class %s", _class_name);

35
src/hotspot/share/classfile/classLoader.cpp
View File

@ -237,11 +237,11 @@ const char* ClassPathEntry::copy_path(const char* path) {
return copy;
}
ClassFileStream* ClassPathDirEntry::open_stream(const char* name, TRAPS) {
ClassFileStream* ClassPathDirEntry::open_stream(Thread* current, const char* name) {
// construct full path name
assert((_dir != NULL) && (name != NULL), "sanity");
size_t path_len = strlen(_dir) + strlen(name) + strlen(os::file_separator()) + 1;
char* path = NEW_RESOURCE_ARRAY_IN_THREAD(THREAD, char, path_len);
char* path = NEW_RESOURCE_ARRAY_IN_THREAD(current, char, path_len);
int len = jio_snprintf(path, path_len, "%s%s%s", _dir, os::file_separator(), name);
assert(len == (int)(path_len - 1), "sanity");
// check if file exists
@ -285,10 +285,9 @@ ClassPathZipEntry::~ClassPathZipEntry() {
FREE_C_HEAP_ARRAY(char, _zip_name);
}
u1* ClassPathZipEntry::open_entry(const char* name, jint* filesize, bool nul_terminate, TRAPS) {
// enable call to C land
JavaThread* thread = THREAD->as_Java_thread();
ThreadToNativeFromVM ttn(thread);
u1* ClassPathZipEntry::open_entry(Thread* current, const char* name, jint* filesize, bool nul_terminate) {
// enable call to C land
ThreadToNativeFromVM ttn(current->as_Java_thread());
// check whether zip archive contains name
jint name_len;
jzentry* entry = (*FindEntry)(_zip, name, filesize, &name_len);
@ -314,9 +313,9 @@ u1* ClassPathZipEntry::open_entry(const char* name, jint* filesize, bool nul_ter
return buffer;
}
ClassFileStream* ClassPathZipEntry::open_stream(const char* name, TRAPS) {
ClassFileStream* ClassPathZipEntry::open_stream(Thread* current, const char* name) {
jint filesize;
u1* buffer = open_entry(name, &filesize, false, CHECK_NULL);
u1* buffer = open_entry(current, name, &filesize, false);
if (buffer == NULL) {
return NULL;
}
@ -374,8 +373,8 @@ ClassPathImageEntry::~ClassPathImageEntry() {
}
}
ClassFileStream* ClassPathImageEntry::open_stream(const char* name, TRAPS) {
return open_stream_for_loader(name, ClassLoaderData::the_null_class_loader_data(), THREAD);
ClassFileStream* ClassPathImageEntry::open_stream(Thread* current, const char* name) {
return open_stream_for_loader(current, name, ClassLoaderData::the_null_class_loader_data());
}
// For a class in a named module, look it up in the jimage file using this syntax:
@ -385,7 +384,7 @@ ClassFileStream* ClassPathImageEntry::open_stream(const char* name, TRAPS) {
// 1. There are no unnamed modules in the jimage file.
// 2. A package is in at most one module in the jimage file.
//
ClassFileStream* ClassPathImageEntry::open_stream_for_loader(const char* name, ClassLoaderData* loader_data, TRAPS) {
ClassFileStream* ClassPathImageEntry::open_stream_for_loader(Thread* current, const char* name, ClassLoaderData* loader_data) {
jlong size;
JImageLocationRef location = (*JImageFindResource)(_jimage, "", get_jimage_version_string(), name, &size);
@ -399,7 +398,7 @@ ClassFileStream* ClassPathImageEntry::open_stream_for_loader(const char* name, C
} else {
PackageEntry* package_entry = ClassLoader::get_package_entry(pkg_name, loader_data);
if (package_entry != NULL) {
ResourceMark rm(THREAD);
ResourceMark rm(current);
// Get the module name
ModuleEntry* module = package_entry->module();
assert(module != NULL, "Boot classLoader package missing module");
@ -1156,7 +1155,7 @@ ClassFileStream* ClassLoader::search_module_entries(const GrowableArray<ModuleCl
// Try to load the class from the module's ClassPathEntry list.
while (e != NULL) {
stream = e->open_stream(file_name, CHECK_NULL);
stream = e->open_stream(THREAD, file_name);
// No context.check is required since CDS is not supported
// for an exploded modules build or if --patch-module is specified.
if (NULL != stream) {
@ -1227,7 +1226,7 @@ InstanceKlass* ClassLoader::load_class(Symbol* name, bool search_append_only, TR
if (!search_append_only && (NULL == stream)) {
if (has_jrt_entry()) {
e = _jrt_entry;
stream = _jrt_entry->open_stream(file_name, CHECK_NULL);
stream = _jrt_entry->open_stream(THREAD, file_name);
} else {
// Exploded build - attempt to locate class in its defining module's location.
assert(_exploded_entries != NULL, "No exploded build entries present");
@ -1245,7 +1244,7 @@ InstanceKlass* ClassLoader::load_class(Symbol* name, bool search_append_only, TR
e = first_append_entry();
while (e != NULL) {
stream = e->open_stream(file_name, CHECK_NULL);
stream = e->open_stream(THREAD, file_name);
if (NULL != stream) {
break;
}
@ -1295,7 +1294,7 @@ char* ClassLoader::skip_uri_protocol(char* source) {
// Record the shared classpath index and loader type for classes loaded
// by the builtin loaders at dump time.
void ClassLoader::record_result(InstanceKlass* ik, const ClassFileStream* stream, TRAPS) {
void ClassLoader::record_result(Thread* current, InstanceKlass* ik, const ClassFileStream* stream) {
Arguments::assert_is_dumping_archive();
assert(stream != NULL, "sanity");
@ -1317,7 +1316,7 @@ void ClassLoader::record_result(InstanceKlass* ik, const ClassFileStream* stream
assert(has_jrt_entry(), "CDS dumping does not support exploded JDK build");
ResourceMark rm(THREAD);
ResourceMark rm(current);
int classpath_index = -1;
PackageEntry* pkg_entry = ik->package();
@ -1401,7 +1400,7 @@ void ClassLoader::record_result(InstanceKlass* ik, const ClassFileStream* stream
ik->name()->utf8_length());
assert(file_name != NULL, "invariant");
ClassLoaderExt::record_result(classpath_index, ik, CHECK);
ClassLoaderExt::record_result(classpath_index, ik);
}
#endif // INCLUDE_CDS

18
src/hotspot/share/classfile/classLoader.hpp
View File

@ -65,10 +65,10 @@ public:
ClassPathEntry() : _next(NULL) {}
// Attempt to locate file_name through this class path entry.
// Returns a class file parsing stream if successfull.
virtual ClassFileStream* open_stream(const char* name, TRAPS) = 0;
virtual ClassFileStream* open_stream(Thread* current, const char* name) = 0;
// Open the stream for a specific class loader
virtual ClassFileStream* open_stream_for_loader(const char* name, ClassLoaderData* loader_data, TRAPS) {
return open_stream(name, THREAD);
virtual ClassFileStream* open_stream_for_loader(Thread* current, const char* name, ClassLoaderData* loader_data) {
return open_stream(current, name);
}
};
@ -81,7 +81,7 @@ class ClassPathDirEntry: public ClassPathEntry {
_dir = copy_path(dir);
}
virtual ~ClassPathDirEntry() {}
ClassFileStream* open_stream(const char* name, TRAPS);
ClassFileStream* open_stream(Thread* current, const char* name);
};
// Type definitions for zip file and zip file entry
@ -108,8 +108,8 @@ class ClassPathZipEntry: public ClassPathEntry {
const char* name() const { return _zip_name; }
ClassPathZipEntry(jzfile* zip, const char* zip_name, bool is_boot_append, bool from_class_path_attr);
virtual ~ClassPathZipEntry();
u1* open_entry(const char* name, jint* filesize, bool nul_terminate, TRAPS);
ClassFileStream* open_stream(const char* name, TRAPS);
u1* open_entry(Thread* current, const char* name, jint* filesize, bool nul_terminate);
ClassFileStream* open_stream(Thread* current, const char* name);
void contents_do(void f(const char* name, void* context), void* context);
};
@ -128,8 +128,8 @@ public:
void close_jimage();
ClassPathImageEntry(JImageFile* jimage, const char* name);
virtual ~ClassPathImageEntry();
ClassFileStream* open_stream(const char* name, TRAPS);
ClassFileStream* open_stream_for_loader(const char* name, ClassLoaderData* loader_data, TRAPS);
ClassFileStream* open_stream(Thread* current, const char* name);
ClassFileStream* open_stream_for_loader(Thread* current, const char* name, ClassLoaderData* loader_data);
};
// ModuleClassPathList contains a linked list of ClassPathEntry's
@ -365,7 +365,7 @@ class ClassLoader: AllStatic {
static int num_module_path_entries();
static void exit_with_path_failure(const char* error, const char* message);
static char* skip_uri_protocol(char* source);
static void record_result(InstanceKlass* ik, const ClassFileStream* stream, TRAPS);
static void record_result(Thread* current, InstanceKlass* ik, const ClassFileStream* stream);
#endif
static char* lookup_vm_options();

12
src/hotspot/share/classfile/classLoaderExt.cpp
View File

@ -103,13 +103,13 @@ void ClassLoaderExt::setup_module_paths(TRAPS) {
process_module_table(met, CHECK);
}
char* ClassLoaderExt::read_manifest(ClassPathEntry* entry, jint *manifest_size, bool clean_text, TRAPS) {
char* ClassLoaderExt::read_manifest(Thread* current, ClassPathEntry* entry, jint *manifest_size, bool clean_text) {
const char* name = "META-INF/MANIFEST.MF";
char* manifest;
jint size;
assert(entry->is_jar_file(), "must be");
manifest = (char*) ((ClassPathZipEntry*)entry )->open_entry(name, &size, true, CHECK_NULL);
manifest = (char*) ((ClassPathZipEntry*)entry )->open_entry(current, name, &size, true);
if (manifest == NULL) { // No Manifest
*manifest_size = 0;
@ -167,7 +167,7 @@ void ClassLoaderExt::process_jar_manifest(ClassPathEntry* entry,
bool check_for_duplicates, TRAPS) {
ResourceMark rm(THREAD);
jint manifest_size;
char* manifest = read_manifest(entry, &manifest_size, CHECK);
char* manifest = read_manifest(THREAD, entry, &manifest_size);
if (manifest == NULL) {
return;
@ -230,9 +230,7 @@ void ClassLoaderExt::setup_search_paths(TRAPS) {
ClassLoaderExt::setup_app_search_path(CHECK);
}
void ClassLoaderExt::record_result(const s2 classpath_index,
InstanceKlass* result,
TRAPS) {
void ClassLoaderExt::record_result(const s2 classpath_index, InstanceKlass* result) {
Arguments::assert_is_dumping_archive();
// We need to remember where the class comes from during dumping.
@ -275,7 +273,7 @@ InstanceKlass* ClassLoaderExt::load_class(Symbol* name, const char* path, TRAPS)
PerfClassTraceTime vmtimer(perf_sys_class_lookup_time(),
THREAD->as_Java_thread()->get_thread_stat()->perf_timers_addr(),
PerfClassTraceTime::CLASS_LOAD);
stream = e->open_stream(file_name, CHECK_NULL);
stream = e->open_stream(THREAD, file_name);
}
if (stream == NULL) {

13
src/hotspot/share/classfile/classLoaderExt.hpp
View File

@ -57,7 +57,7 @@ private:
static bool _has_app_classes;
static bool _has_platform_classes;
static char* read_manifest(ClassPathEntry* entry, jint *manifest_size, bool clean_text, TRAPS);
static char* read_manifest(Thread* current, ClassPathEntry* entry, jint *manifest_size, bool clean_text);
static ClassPathEntry* find_classpath_entry_from_cache(Thread* current, const char* path);
public:
@ -69,16 +69,16 @@ public:
static void setup_search_paths(TRAPS);
static void setup_module_paths(TRAPS);
static char* read_manifest(ClassPathEntry* entry, jint *manifest_size, TRAPS) {
static char* read_manifest(Thread* current, ClassPathEntry* entry, jint *manifest_size) {
// Remove all the new-line continuations (which wrap long lines at 72 characters, see
// http://docs.oracle.com/javase/6/docs/technotes/guides/jar/jar.html#JAR%20Manifest), so
// that the manifest is easier to parse.
return read_manifest(entry, manifest_size, true, THREAD);
return read_manifest(current, entry, manifest_size, true);
}
static char* read_raw_manifest(ClassPathEntry* entry, jint *manifest_size, TRAPS) {
static char* read_raw_manifest(Thread* current, ClassPathEntry* entry, jint *manifest_size) {
// Do not remove new-line continuations, so we can easily pass it as an argument to
// java.util.jar.Manifest.getManifest() at run-time.
return read_manifest(entry, manifest_size, false, THREAD);
return read_manifest(current, entry, manifest_size, false);
}
static jshort app_class_paths_start_index() { return _app_class_paths_start_index; }
@ -107,8 +107,7 @@ public:
return _has_app_classes || _has_platform_classes;
}
static void record_result(const s2 classpath_index,
InstanceKlass* result, TRAPS);
static void record_result(const s2 classpath_index, InstanceKlass* result);
static InstanceKlass* load_class(Symbol* h_name, const char* path, TRAPS);
static void set_has_app_classes() {
_has_app_classes = true;

2
src/hotspot/share/classfile/klassFactory.cpp
View File

@ -216,7 +216,7 @@ InstanceKlass* KlassFactory::create_from_stream(ClassFileStream* stream,
#if INCLUDE_CDS
if (Arguments::is_dumping_archive()) {
ClassLoader::record_result(result, stream, THREAD);
ClassLoader::record_result(THREAD, result, stream);
}
#endif // INCLUDE_CDS

11
src/hotspot/share/classfile/systemDictionaryShared.cpp
View File

@ -736,7 +736,7 @@ Handle SystemDictionaryShared::get_shared_jar_manifest(int shared_path_index, TR
// ByteArrayInputStream bais = new ByteArrayInputStream(buf);
const char* src = ent->manifest();
assert(src != NULL, "No Manifest data");
manifest = create_jar_manifest(src, size, THREAD);
manifest = create_jar_manifest(src, size, CHECK_NH);
atomic_set_shared_jar_manifest(shared_path_index, manifest());
}
manifest = Handle(THREAD, shared_jar_manifest(shared_path_index));
@ -896,7 +896,7 @@ Handle SystemDictionaryShared::init_security_info(Handle class_loader, InstanceK
// Modules::define_module().
assert(pkg_entry != NULL, "archived class in module image cannot be from unnamed package");
ModuleEntry* mod_entry = pkg_entry->module();
pd = get_shared_protection_domain(class_loader, mod_entry, THREAD);
pd = get_shared_protection_domain(class_loader, mod_entry, CHECK_(pd));
} else {
// For shared app/platform classes originated from JAR files on the class path:
// Each of the 3 SystemDictionaryShared::_shared_xxx arrays has the same length
@ -1180,7 +1180,7 @@ class LoadedUnregisteredClassesTable : public ResourceHashtable<
static LoadedUnregisteredClassesTable* _loaded_unregistered_classes = NULL;
bool SystemDictionaryShared::add_unregistered_class(InstanceKlass* k, TRAPS) {
bool SystemDictionaryShared::add_unregistered_class(Thread* current, InstanceKlass* k) {
// We don't allow duplicated unregistered classes of the same name.
assert(DumpSharedSpaces, "only when dumping");
Symbol* name = k->name();
@ -1190,7 +1190,7 @@ bool SystemDictionaryShared::add_unregistered_class(InstanceKlass* k, TRAPS) {
bool created = false;
_loaded_unregistered_classes->put_if_absent(name, true, &created);
if (created) {
MutexLocker mu_r(THREAD, Compile_lock); // add_to_hierarchy asserts this.
MutexLocker mu_r(current, Compile_lock); // add_to_hierarchy asserts this.
SystemDictionary::add_to_hierarchy(k);
}
return created;
@ -1602,7 +1602,8 @@ void SystemDictionaryShared::add_lambda_proxy_class(InstanceKlass* caller_ik,
lambda_ik->assign_class_loader_type();
lambda_ik->set_shared_classpath_index(caller_ik->shared_classpath_index());
InstanceKlass* nest_host = caller_ik->nest_host(THREAD);
InstanceKlass* nest_host = caller_ik->nest_host(CHECK);
assert(nest_host != NULL, "unexpected NULL nest_host");
DumpTimeSharedClassInfo* info = _dumptime_table->get(lambda_ik);
if (info != NULL && !lambda_ik->is_non_strong_hidden() && is_builtin(lambda_ik) && is_builtin(caller_ik)

2
src/hotspot/share/classfile/systemDictionaryShared.hpp
View File

@ -246,7 +246,7 @@ public:
// Check if sharing is supported for the class loader.
static bool is_sharing_possible(ClassLoaderData* loader_data);
static bool add_unregistered_class(InstanceKlass* k, TRAPS);
static bool add_unregistered_class(Thread* current, InstanceKlass* k);
static InstanceKlass* lookup_super_for_unregistered_class(Symbol* class_name,
Symbol* super_name, bool is_superclass);

2
src/hotspot/share/interpreter/linkResolver.cpp
View File

@ -1770,7 +1770,7 @@ void LinkResolver::resolve_invokedynamic(CallInfo& result, const constantPoolHan
// to CPCE state, including f1.
// Log dynamic info to CDS classlist.
ArchiveUtils::log_to_classlist(&bootstrap_specifier, THREAD);
ArchiveUtils::log_to_classlist(&bootstrap_specifier, CHECK);
}
void LinkResolver::resolve_dynamic_call(CallInfo& result,

2
src/hotspot/share/memory/archiveUtils.cpp
View File

@ -339,7 +339,7 @@ void ArchiveUtils::log_to_classlist(BootstrapInfo* bootstrap_specifier, TRAPS) {
ClassListWriter w;
w.stream()->print("%s %s", LAMBDA_PROXY_TAG, pool->pool_holder()->name()->as_C_string());
CDSIndyInfo cii;
ClassListParser::populate_cds_indy_info(pool, pool_index, &cii, THREAD);
ClassListParser::populate_cds_indy_info(pool, pool_index, &cii, CHECK);
GrowableArray<const char*>* indy_items = cii.items();
for (int i = 0; i < indy_items->length(); i++) {
w.stream()->print(" %s", indy_items->at(i));

9
src/hotspot/share/memory/filemap.cpp
View File

@ -657,7 +657,7 @@ void FileMapInfo::update_jar_manifest(ClassPathEntry *cpe, SharedClassPathEntry*
jint manifest_size;
assert(cpe->is_jar_file() && ent->is_jar(), "the shared class path entry is not a JAR file");
char* manifest = ClassLoaderExt::read_manifest(cpe, &manifest_size, CHECK);
char* manifest = ClassLoaderExt::read_manifest(THREAD, cpe, &manifest_size);
if (manifest != NULL) {
ManifestStream* stream = new ManifestStream((u1*)manifest,
manifest_size);
@ -665,7 +665,7 @@ void FileMapInfo::update_jar_manifest(ClassPathEntry *cpe, SharedClassPathEntry*
ent->set_is_signed();
} else {
// Copy the manifest into the shared archive
manifest = ClassLoaderExt::read_raw_manifest(cpe, &manifest_size, CHECK);
manifest = ClassLoaderExt::read_raw_manifest(THREAD, cpe, &manifest_size);
Array<u1>* buf = MetadataFactory::new_array<u1>(loader_data,
manifest_size,
CHECK);
@ -2370,9 +2370,8 @@ ClassFileStream* FileMapInfo::open_stream_for_jvmti(InstanceKlass* ik, Handle cl
const char* const file_name = ClassLoader::file_name_for_class_name(class_name,
name->utf8_length());
ClassLoaderData* loader_data = ClassLoaderData::class_loader_data(class_loader());
ClassFileStream* cfs = cpe->open_stream_for_loader(file_name, loader_data, THREAD);
assert(!HAS_PENDING_EXCEPTION &&
cfs != NULL, "must be able to read the classfile data of shared classes for built-in loaders.");
ClassFileStream* cfs = cpe->open_stream_for_loader(THREAD, file_name, loader_data);
assert(cfs != NULL, "must be able to read the classfile data of shared classes for built-in loaders.");
log_debug(cds, jvmti)("classfile data for %s [%d: %s] = %d bytes", class_name, path_index,
cfs->source(), cfs->length());
return cfs;

16
src/hotspot/share/memory/heapShared.cpp
View File

@ -700,14 +700,15 @@ void HeapShared::resolve_classes_for_subgraphs(ArchivableStaticFieldInfo fields[
}
void HeapShared::resolve_classes_for_subgraph_of(Klass* k, Thread* THREAD) {
const ArchivedKlassSubGraphInfoRecord* record =
ExceptionMark em(THREAD);
const ArchivedKlassSubGraphInfoRecord* record =
resolve_or_init_classes_for_subgraph_of(k, /*do_init=*/false, THREAD);
if (HAS_PENDING_EXCEPTION) {
if (HAS_PENDING_EXCEPTION) {
CLEAR_PENDING_EXCEPTION;
}
if (record == NULL) {
}
if (record == NULL) {
clear_archived_roots_of(k);
}
}
}
void HeapShared::initialize_from_archived_subgraph(Klass* k, Thread* THREAD) {
@ -715,6 +716,7 @@ void HeapShared::initialize_from_archived_subgraph(Klass* k, Thread* THREAD) {
return; // nothing to do
}
ExceptionMark em(THREAD);
const ArchivedKlassSubGraphInfoRecord* record =
resolve_or_init_classes_for_subgraph_of(k, /*do_init=*/true, THREAD);
@ -746,7 +748,7 @@ HeapShared::resolve_or_init_classes_for_subgraph_of(Klass* k, bool do_init, TRAP
if (record != NULL) {
if (record->is_full_module_graph() && !MetaspaceShared::use_full_module_graph()) {
if (log_is_enabled(Info, cds, heap)) {
ResourceMark rm;
ResourceMark rm(THREAD);
log_info(cds, heap)("subgraph %s cannot be used because full module graph is disabled",
k->external_name());
}
@ -755,7 +757,7 @@ HeapShared::resolve_or_init_classes_for_subgraph_of(Klass* k, bool do_init, TRAP
if (record->has_non_early_klasses() && JvmtiExport::should_post_class_file_load_hook()) {
if (log_is_enabled(Info, cds, heap)) {
ResourceMark rm;
ResourceMark rm(THREAD);
log_info(cds, heap)("subgraph %s cannot be used because JVMTI ClassFileLoadHook is enabled",
k->external_name());
}

10
src/hotspot/share/memory/metaspaceShared.cpp
View File

@ -218,7 +218,7 @@ void MetaspaceShared::post_initialize(TRAPS) {
if (UseSharedSpaces) {
int size = FileMapInfo::get_number_of_shared_paths();
if (size > 0) {
SystemDictionaryShared::allocate_shared_data_arrays(size, THREAD);
SystemDictionaryShared::allocate_shared_data_arrays(size, CHECK);
if (!DynamicDumpSharedSpaces) {
FileMapInfo* info;
if (FileMapInfo::dynamic_info() == NULL) {
@ -558,7 +558,7 @@ bool MetaspaceShared::link_class_for_cds(InstanceKlass* ik, TRAPS) {
// The following function is used to resolve all Strings in the statically
// dumped classes to archive all the Strings. The archive heap is not supported
// for the dynamic archive.
ik->constants()->resolve_class_constants(CHECK_0); // may throw OOM when interning strings.
ik->constants()->resolve_class_constants(CHECK_(false)); // may throw OOM when interning strings.
}
return res;
}
@ -709,9 +709,9 @@ void MetaspaceShared::preload_and_dump_impl(TRAPS) {
log_info(cds)("Rewriting and linking classes: done");
#if INCLUDE_CDS_JAVA_HEAP
if (use_full_module_graph()) {
HeapShared::reset_archived_object_states(CHECK);
}
if (use_full_module_graph()) {
HeapShared::reset_archived_object_states(CHECK);
}
#endif
VM_PopulateDumpSharedSpace op;