infernap12/jdk
1
0
Fork 0
mirror of https://github.com/openjdk/jdk.git synced 2026-07-30 04:43:27 +00:00
Code Issues Packages Projects Releases Wiki Activity

8261127: Cleanup THREAD/TRAPS/CHECK usage in CDS code

Browse Source 
Reviewed-by: iklam, coleenp
This commit is contained in:
David Holmes 2021-02-08 23:16:47 +00:00
parent 7451962849
commit f03e839e48
9 changed files with 69 additions and 84 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
src/hotspot/share/classfile/javaClasses.cpp
View File

@ -863,7 +863,7 @@ static void initialize_static_field(fieldDescriptor* fd, Handle mirror, TRAPS) {
if (DumpSharedSpaces && HeapShared::is_archived_object(mirror())) {
// Archive the String field and update the pointer.
oop s = mirror()->obj_field(fd->offset());
oop archived_s = StringTable::create_archived_string(s, CHECK);
oop archived_s = StringTable::create_archived_string(s);
mirror()->obj_field_put(fd->offset(), archived_s);
} else {
oop string = fd->string_initial_value(CHECK);
@ -1140,7 +1140,7 @@ static void set_klass_field_in_archived_mirror(oop mirror_obj, int offset, Klass
mirror_obj->metadata_field_put(offset, def);
}
void java_lang_Class::archive_basic_type_mirrors(TRAPS) {
void java_lang_Class::archive_basic_type_mirrors() {
assert(HeapShared::is_heap_object_archiving_allowed(),
"HeapShared::is_heap_object_archiving_allowed() must be true");
@ -1149,7 +1149,7 @@ void java_lang_Class::archive_basic_type_mirrors(TRAPS) {
oop m = Universe::_mirrors[t].resolve();
if (m != NULL) {
// Update the field at _array_klass_offset to point to the relocated array klass.
oop archived_m = HeapShared::archive_heap_object(m, THREAD);
oop archived_m = HeapShared::archive_heap_object(m);
assert(archived_m != NULL, "sanity");
Klass *ak = (Klass*)(archived_m->metadata_field(_array_klass_offset));
assert(ak != NULL || t == T_VOID, "should not be NULL");
@ -1159,7 +1159,7 @@ void java_lang_Class::archive_basic_type_mirrors(TRAPS) {
// Clear the fields. Just to be safe
Klass *k = m->klass();
Handle archived_mirror_h(THREAD, archived_m);
Handle archived_mirror_h(Thread::current(), archived_m);
ResetMirrorField reset(archived_mirror_h);
InstanceKlass::cast(k)->do_nonstatic_fields(&reset);
@ -1179,7 +1179,7 @@ void java_lang_Class::archive_basic_type_mirrors(TRAPS) {
// archived mirror is restored. If archived java heap data cannot
// be used at runtime, new mirror object is created for the shared
// class. The _has_archived_raw_mirror is cleared also during the process.
oop java_lang_Class::archive_mirror(Klass* k, TRAPS) {
oop java_lang_Class::archive_mirror(Klass* k) {
assert(HeapShared::is_heap_object_archiving_allowed(),
"HeapShared::is_heap_object_archiving_allowed() must be true");
@ -1208,12 +1208,12 @@ oop java_lang_Class::archive_mirror(Klass* k, TRAPS) {
}
// Now start archiving the mirror object
oop archived_mirror = HeapShared::archive_heap_object(mirror, THREAD);
oop archived_mirror = HeapShared::archive_heap_object(mirror);
if (archived_mirror == NULL) {
return NULL;
}
archived_mirror = process_archived_mirror(k, mirror, archived_mirror, THREAD);
archived_mirror = process_archived_mirror(k, mirror, archived_mirror);
if (archived_mirror == NULL) {
return NULL;
}
@ -1230,12 +1230,11 @@ oop java_lang_Class::archive_mirror(Klass* k, TRAPS) {
// The process is based on create_mirror().
oop java_lang_Class::process_archived_mirror(Klass* k, oop mirror,
oop archived_mirror,
Thread *THREAD) {
oop archived_mirror) {
// Clear nonstatic fields in archived mirror. Some of the fields will be set
// to archived metadata and objects below.
Klass *c = archived_mirror->klass();
Handle archived_mirror_h(THREAD, archived_mirror);
Handle archived_mirror_h(Thread::current(), archived_mirror);
ResetMirrorField reset(archived_mirror_h);
InstanceKlass::cast(c)->do_nonstatic_fields(&reset);
@ -1250,7 +1249,7 @@ oop java_lang_Class::process_archived_mirror(Klass* k, oop mirror,
assert(k->is_objArray_klass(), "Must be");
Klass* element_klass = ObjArrayKlass::cast(k)->element_klass();
assert(element_klass != NULL, "Must have an element klass");
archived_comp_mirror = archive_mirror(element_klass, THREAD);
archived_comp_mirror = archive_mirror(element_klass);
if (archived_comp_mirror == NULL) {
return NULL;
}

6
src/hotspot/share/classfile/javaClasses.hpp
View File

@ -276,9 +276,9 @@ class java_lang_Class : AllStatic {
// Archiving
static void serialize_offsets(SerializeClosure* f) NOT_CDS_RETURN;
static void archive_basic_type_mirrors(TRAPS) NOT_CDS_JAVA_HEAP_RETURN;
static oop archive_mirror(Klass* k, TRAPS) NOT_CDS_JAVA_HEAP_RETURN_(NULL);
static oop process_archived_mirror(Klass* k, oop mirror, oop archived_mirror, Thread *THREAD)
static void archive_basic_type_mirrors() NOT_CDS_JAVA_HEAP_RETURN;
static oop archive_mirror(Klass* k) NOT_CDS_JAVA_HEAP_RETURN_(NULL);
static oop process_archived_mirror(Klass* k, oop mirror, oop archived_mirror)
NOT_CDS_JAVA_HEAP_RETURN_(NULL);
static bool restore_archived_mirror(Klass *k, Handle class_loader, Handle module,
Handle protection_domain,

8
src/hotspot/share/classfile/stringTable.cpp
View File

@ -717,18 +717,18 @@ oop StringTable::lookup_shared(const jchar* name, int len, unsigned int hash) {
return _shared_table.lookup(name, hash, len);
}
oop StringTable::create_archived_string(oop s, Thread* THREAD) {
oop StringTable::create_archived_string(oop s) {
assert(DumpSharedSpaces, "this function is only used with -Xshare:dump");
assert(java_lang_String::is_instance(s), "sanity");
assert(!HeapShared::is_archived_object(s), "sanity");
oop new_s = NULL;
typeArrayOop v = java_lang_String::value_no_keepalive(s);
typeArrayOop new_v = (typeArrayOop)HeapShared::archive_heap_object(v, THREAD);
typeArrayOop new_v = (typeArrayOop)HeapShared::archive_heap_object(v);
if (new_v == NULL) {
return NULL;
}
new_s = HeapShared::archive_heap_object(s, THREAD);
new_s = HeapShared::archive_heap_object(s);
if (new_s == NULL) {
return NULL;
}
@ -745,7 +745,7 @@ public:
bool do_entry(oop s, bool value_ignored) {
assert(s != NULL, "sanity");
unsigned int hash = java_lang_String::hash_code(s);
oop new_s = StringTable::create_archived_string(s, Thread::current());
oop new_s = StringTable::create_archived_string(s);
if (new_s == NULL) {
return true;
}

4
src/hotspot/share/classfile/stringTable.hpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 1997, 2020, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 1997, 2021, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -107,7 +107,7 @@ class StringTable : public CHeapObj<mtSymbol>{
private:
static oop lookup_shared(const jchar* name, int len, unsigned int hash) NOT_CDS_JAVA_HEAP_RETURN_(NULL);
public:
static oop create_archived_string(oop s, Thread* THREAD) NOT_CDS_JAVA_HEAP_RETURN_(NULL);
static oop create_archived_string(oop s) NOT_CDS_JAVA_HEAP_RETURN_(NULL);
static void shared_oops_do(OopClosure* f) NOT_CDS_JAVA_HEAP_RETURN;
static void write_to_archive(const DumpedInternedStrings* dumped_interned_strings) NOT_CDS_JAVA_HEAP_RETURN;
static void serialize_shared_table_header(SerializeClosure* soc) NOT_CDS_JAVA_HEAP_RETURN;

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

@ -1808,7 +1808,7 @@ void SystemDictionary::initialize(TRAPS) {
vmClasses::resolve_all(CHECK);
// Resolve classes used by archived heap objects
if (UseSharedSpaces) {
HeapShared::resolve_classes(CHECK);
HeapShared::resolve_classes(THREAD);
}
}

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

@ -166,7 +166,7 @@ static void reset_states(oop obj, TRAPS) {
void HeapShared::reset_archived_object_states(TRAPS) {
assert(DumpSharedSpaces, "dump-time only");
log_debug(cds)("Resetting platform loader");
reset_states(SystemDictionary::java_platform_loader(), THREAD);
reset_states(SystemDictionary::java_platform_loader(), CHECK);
log_debug(cds)("Resetting system loader");
reset_states(SystemDictionary::java_system_loader(), THREAD);
}
@ -247,7 +247,7 @@ void HeapShared::clear_root(int index) {
}
}
oop HeapShared::archive_heap_object(oop obj, Thread* THREAD) {
oop HeapShared::archive_heap_object(oop obj) {
assert(DumpSharedSpaces, "dump-time only");
oop ao = find_archived_heap_object(obj);
@ -297,19 +297,19 @@ oop HeapShared::archive_heap_object(oop obj, Thread* THREAD) {
return archived_oop;
}
void HeapShared::archive_klass_objects(Thread* THREAD) {
void HeapShared::archive_klass_objects() {
GrowableArray<Klass*>* klasses = MetaspaceShared::collected_klasses();
assert(klasses != NULL, "sanity");
for (int i = 0; i < klasses->length(); i++) {
Klass* k = ArchiveBuilder::get_relocated_klass(klasses->at(i));
// archive mirror object
java_lang_Class::archive_mirror(k, CHECK);
java_lang_Class::archive_mirror(k);
// archive the resolved_referenes array
if (k->is_instance_klass()) {
InstanceKlass* ik = InstanceKlass::cast(k);
ik->constants()->archive_resolved_references(THREAD);
ik->constants()->archive_resolved_references();
}
}
}
@ -369,8 +369,7 @@ void HeapShared::copy_closed_archive_heap_objects(
archive_object_subgraphs(closed_archive_subgraph_entry_fields,
num_closed_archive_subgraph_entry_fields,
true /* is_closed_archive */,
false /* is_full_module_graph */,
THREAD);
false /* is_full_module_graph */);
G1CollectedHeap::heap()->end_archive_alloc_range(closed_archive,
os::vm_allocation_granularity());
@ -380,24 +379,21 @@ void HeapShared::copy_open_archive_heap_objects(
GrowableArray<MemRegion> * open_archive) {
assert(is_heap_object_archiving_allowed(), "Cannot archive java heap objects");
Thread* THREAD = Thread::current();
G1CollectedHeap::heap()->begin_archive_alloc_range(true /* open */);
java_lang_Class::archive_basic_type_mirrors(THREAD);
java_lang_Class::archive_basic_type_mirrors();
archive_klass_objects(THREAD);
archive_klass_objects();
archive_object_subgraphs(open_archive_subgraph_entry_fields,
num_open_archive_subgraph_entry_fields,
false /* is_closed_archive */,
false /* is_full_module_graph */,
THREAD);
false /* is_full_module_graph */);
if (MetaspaceShared::use_full_module_graph()) {
archive_object_subgraphs(fmg_open_archive_subgraph_entry_fields,
num_fmg_open_archive_subgraph_entry_fields,
false /* is_closed_archive */,
true /* is_full_module_graph */,
THREAD);
true /* is_full_module_graph */);
ClassLoaderDataShared::init_archived_oops();
}
@ -678,34 +674,35 @@ static void verify_the_heap(Klass* k, const char* which) {
// Note: if a ArchivedKlassSubGraphInfoRecord contains non-early classes, and JVMTI
// ClassFileLoadHook is enabled, it's possible for this class to be dynamically replaced. In
// this case, we will not load the ArchivedKlassSubGraphInfoRecord and will clear its roots.
void HeapShared::resolve_classes(TRAPS) {
void HeapShared::resolve_classes(Thread* THREAD) {
if (!is_mapped()) {
return; // nothing to do
}
resolve_classes_for_subgraphs(closed_archive_subgraph_entry_fields,
num_closed_archive_subgraph_entry_fields,
CHECK);
THREAD);
resolve_classes_for_subgraphs(open_archive_subgraph_entry_fields,
num_open_archive_subgraph_entry_fields,
CHECK);
THREAD);
resolve_classes_for_subgraphs(fmg_open_archive_subgraph_entry_fields,
num_fmg_open_archive_subgraph_entry_fields,
CHECK);
THREAD);
}
void HeapShared::resolve_classes_for_subgraphs(ArchivableStaticFieldInfo fields[],
int num, TRAPS) {
int num, Thread* THREAD) {
for (int i = 0; i < num; i++) {
ArchivableStaticFieldInfo* info = &fields[i];
TempNewSymbol klass_name = SymbolTable::new_symbol(info->klass_name);
InstanceKlass* k = SystemDictionaryShared::find_builtin_class(klass_name);
assert(k != NULL && k->is_shared_boot_class(), "sanity");
resolve_classes_for_subgraph_of(k, CHECK);
resolve_classes_for_subgraph_of(k, THREAD);
}
}
void HeapShared::resolve_classes_for_subgraph_of(Klass* k, TRAPS) {
const ArchivedKlassSubGraphInfoRecord* record = resolve_or_init_classes_for_subgraph_of(k, /*do_init=*/false, THREAD);
void HeapShared::resolve_classes_for_subgraph_of(Klass* k, Thread* THREAD) {
const ArchivedKlassSubGraphInfoRecord* record =
resolve_or_init_classes_for_subgraph_of(k, /*do_init=*/false, THREAD);
if (HAS_PENDING_EXCEPTION) {
CLEAR_PENDING_EXCEPTION;
}
@ -714,7 +711,7 @@ void HeapShared::resolve_classes_for_subgraph_of(Klass* k, TRAPS) {
}
}
void HeapShared::initialize_from_archived_subgraph(Klass* k, TRAPS) {
void HeapShared::initialize_from_archived_subgraph(Klass* k, Thread* THREAD) {
if (!is_mapped()) {
return; // nothing to do
}
@ -731,7 +728,7 @@ void HeapShared::initialize_from_archived_subgraph(Klass* k, TRAPS) {
}
if (record != NULL) {
init_archived_fields_for(k, record, THREAD);
init_archived_fields_for(k, record);
}
}
@ -803,7 +800,7 @@ void HeapShared::resolve_or_init(Klass* k, bool do_init, TRAPS) {
}
}
void HeapShared::init_archived_fields_for(Klass* k, const ArchivedKlassSubGraphInfoRecord* record, TRAPS) {
void HeapShared::init_archived_fields_for(Klass* k, const ArchivedKlassSubGraphInfoRecord* record) {
verify_the_heap(k, "before");
// Load the subgraph entry fields from the record and store them back to
@ -856,18 +853,16 @@ class WalkOopAndArchiveClosure: public BasicOopIterateClosure {
KlassSubGraphInfo* _subgraph_info;
oop _orig_referencing_obj;
oop _archived_referencing_obj;
Thread* _thread;
public:
WalkOopAndArchiveClosure(int level,
bool is_closed_archive,
bool record_klasses_only,
KlassSubGraphInfo* subgraph_info,
oop orig, oop archived, TRAPS) :
oop orig, oop archived) :
_level(level), _is_closed_archive(is_closed_archive),
_record_klasses_only(record_klasses_only),
_subgraph_info(subgraph_info),
_orig_referencing_obj(orig), _archived_referencing_obj(archived),
_thread(THREAD) {}
_orig_referencing_obj(orig), _archived_referencing_obj(archived) {}
void do_oop(narrowOop *p) { WalkOopAndArchiveClosure::do_oop_work(p); }
void do_oop( oop *p) { WalkOopAndArchiveClosure::do_oop_work(p); }
@ -880,7 +875,6 @@ class WalkOopAndArchiveClosure: public BasicOopIterateClosure {
size_t field_delta = pointer_delta(p, _orig_referencing_obj, sizeof(char));
T* new_p = (T*)(cast_from_oop<address>(_archived_referencing_obj) + field_delta);
Thread* THREAD = _thread;
if (!_record_klasses_only && log_is_enabled(Debug, cds, heap)) {
ResourceMark rm;
@ -893,7 +887,7 @@ class WalkOopAndArchiveClosure: public BasicOopIterateClosure {
}
oop archived = HeapShared::archive_reachable_objects_from(
_level + 1, _subgraph_info, obj, _is_closed_archive, THREAD);
_level + 1, _subgraph_info, obj, _is_closed_archive);
assert(archived != NULL, "VM should have exited with unarchivable objects for _level > 1");
assert(HeapShared::is_archived_object(archived), "must be");
@ -907,14 +901,13 @@ class WalkOopAndArchiveClosure: public BasicOopIterateClosure {
}
};
void HeapShared::check_closed_archive_heap_region_object(InstanceKlass* k,
Thread* THREAD) {
void HeapShared::check_closed_archive_heap_region_object(InstanceKlass* k) {
// Check fields in the object
for (JavaFieldStream fs(k); !fs.done(); fs.next()) {
if (!fs.access_flags().is_static()) {
BasicType ft = fs.field_descriptor().field_type();
if (!fs.access_flags().is_final() && is_reference_type(ft)) {
ResourceMark rm(THREAD);
ResourceMark rm;
log_warning(cds, heap)(
"Please check reference field in %s instance in closed archive heap region: %s %s",
k->external_name(), (fs.name())->as_C_string(),
@ -950,8 +943,7 @@ void HeapShared::check_module_oop(oop orig_module_obj) {
oop HeapShared::archive_reachable_objects_from(int level,
KlassSubGraphInfo* subgraph_info,
oop orig_obj,
bool is_closed_archive,
TRAPS) {
bool is_closed_archive) {
assert(orig_obj != NULL, "must be");
assert(!is_archived_object(orig_obj), "sanity");
@ -991,7 +983,7 @@ oop HeapShared::archive_reachable_objects_from(int level,
bool record_klasses_only = (archived_obj != NULL);
if (archived_obj == NULL) {
++_num_new_archived_objs;
archived_obj = archive_heap_object(orig_obj, THREAD);
archived_obj = archive_heap_object(orig_obj);
if (archived_obj == NULL) {
// Skip archiving the sub-graph referenced from the current entry field.
ResourceMark rm;
@ -1029,10 +1021,10 @@ oop HeapShared::archive_reachable_objects_from(int level,
subgraph_info->add_subgraph_object_klass(orig_k);
WalkOopAndArchiveClosure walker(level, is_closed_archive, record_klasses_only,
subgraph_info, orig_obj, archived_obj, THREAD);
subgraph_info, orig_obj, archived_obj);
orig_obj->oop_iterate(&walker);
if (is_closed_archive && orig_k->is_instance_klass()) {
check_closed_archive_heap_region_object(InstanceKlass::cast(orig_k), THREAD);
check_closed_archive_heap_region_object(InstanceKlass::cast(orig_k));
}
return archived_obj;
}
@ -1075,8 +1067,7 @@ void HeapShared::archive_reachable_objects_from_static_field(InstanceKlass *k,
const char* klass_name,
int field_offset,
const char* field_name,
bool is_closed_archive,
TRAPS) {
bool is_closed_archive) {
assert(DumpSharedSpaces, "dump time only");
assert(k->is_shared_boot_class(), "must be boot class");
@ -1094,8 +1085,7 @@ void HeapShared::archive_reachable_objects_from_static_field(InstanceKlass *k,
f->print_on(&out);
}
oop af = archive_reachable_objects_from(1, subgraph_info, f,
is_closed_archive, CHECK);
oop af = archive_reachable_objects_from(1, subgraph_info, f, is_closed_archive);
if (af == NULL) {
log_error(cds, heap)("Archiving failed %s::%s (some reachable objects cannot be archived)",
@ -1308,8 +1298,7 @@ void HeapShared::init_for_dumping(Thread* THREAD) {
void HeapShared::archive_object_subgraphs(ArchivableStaticFieldInfo fields[],
int num, bool is_closed_archive,
bool is_full_module_graph,
Thread* THREAD) {
bool is_full_module_graph) {
_num_total_subgraph_recordings = 0;
_num_total_walked_objs = 0;
_num_total_archived_objs = 0;
@ -1340,7 +1329,7 @@ void HeapShared::archive_object_subgraphs(ArchivableStaticFieldInfo fields[],
archive_reachable_objects_from_static_field(f->klass, f->klass_name,
f->offset, f->field_name,
is_closed_archive, CHECK);
is_closed_archive);
}
done_recording_subgraph(info->klass, klass_name);
}

25
src/hotspot/share/memory/heapShared.hpp
View File

@ -200,21 +200,19 @@ private:
static DumpTimeKlassSubGraphInfoTable* _dump_time_subgraph_info_table;
static RunTimeKlassSubGraphInfoTable _run_time_subgraph_info_table;
static void check_closed_archive_heap_region_object(InstanceKlass* k,
Thread* THREAD);
static void check_closed_archive_heap_region_object(InstanceKlass* k);
static void archive_object_subgraphs(ArchivableStaticFieldInfo fields[],
int num,
bool is_closed_archive,
bool is_full_module_graph,
Thread* THREAD);
bool is_full_module_graph);
// Archive object sub-graph starting from the given static field
// in Klass k's mirror.
static void archive_reachable_objects_from_static_field(
InstanceKlass* k, const char* klass_name,
int field_offset, const char* field_name,
bool is_closed_archive, TRAPS);
bool is_closed_archive);
static void verify_subgraph_from_static_field(
InstanceKlass* k, int field_offset) PRODUCT_RETURN;
@ -276,13 +274,13 @@ private:
static void copy_roots();
static void resolve_classes_for_subgraphs(ArchivableStaticFieldInfo fields[],
int num, TRAPS);
static void resolve_classes_for_subgraph_of(Klass* k, TRAPS);
int num, Thread* THREAD);
static void resolve_classes_for_subgraph_of(Klass* k, Thread* THREAD);
static void clear_archived_roots_of(Klass* k);
static const ArchivedKlassSubGraphInfoRecord*
resolve_or_init_classes_for_subgraph_of(Klass* k, bool do_init, TRAPS);
static void resolve_or_init(Klass* k, bool do_init, TRAPS);
static void init_archived_fields_for(Klass* k, const ArchivedKlassSubGraphInfoRecord* record, TRAPS);
static void init_archived_fields_for(Klass* k, const ArchivedKlassSubGraphInfoRecord* record);
public:
static void reset_archived_object_states(TRAPS);
static void create_archived_object_cache() {
@ -298,9 +296,9 @@ private:
}
static oop find_archived_heap_object(oop obj);
static oop archive_heap_object(oop obj, Thread* THREAD);
static oop archive_heap_object(oop obj);
static void archive_klass_objects(Thread* THREAD);
static void archive_klass_objects();
static void set_archive_heap_region_fixed() {
_archive_heap_region_fixed = true;
@ -317,8 +315,7 @@ private:
static oop archive_reachable_objects_from(int level,
KlassSubGraphInfo* subgraph_info,
oop orig_obj,
bool is_closed_archive,
TRAPS);
bool is_closed_archive);
static ResourceBitMap calculate_oopmap(MemRegion region);
static void add_to_dumped_interned_strings(oop string);
@ -388,8 +385,8 @@ private:
inline static bool is_archived_object(oop p) NOT_CDS_JAVA_HEAP_RETURN_(false);
static void resolve_classes(TRAPS) NOT_CDS_JAVA_HEAP_RETURN;
static void initialize_from_archived_subgraph(Klass* k, TRAPS) NOT_CDS_JAVA_HEAP_RETURN;
static void resolve_classes(Thread* THREAD) NOT_CDS_JAVA_HEAP_RETURN;
static void initialize_from_archived_subgraph(Klass* k, Thread* THREAD) NOT_CDS_JAVA_HEAP_RETURN;
// NarrowOops stored in the CDS archive may use a different encoding scheme
// than CompressedOops::{base,shift} -- see FileMapInfo::map_heap_regions_impl.

4
src/hotspot/share/oops/constantPool.cpp
View File

@ -276,7 +276,7 @@ void ConstantPool::klass_at_put(int class_index, Klass* k) {
#if INCLUDE_CDS_JAVA_HEAP
// Archive the resolved references
void ConstantPool::archive_resolved_references(Thread* THREAD) {
void ConstantPool::archive_resolved_references() {
if (_cache == NULL) {
return; // nothing to do
}
@ -311,7 +311,7 @@ void ConstantPool::archive_resolved_references(Thread* THREAD) {
}
}
oop archived = HeapShared::archive_heap_object(rr, THREAD);
oop archived = HeapShared::archive_heap_object(rr);
// If the resolved references array is not archived (too large),
// the 'archived' object is NULL. No need to explicitly check
// the return value of archive_heap_object here. At runtime, the

2
src/hotspot/share/oops/constantPool.hpp
View File

@ -739,7 +739,7 @@ class ConstantPool : public Metadata {
}
// CDS support
void archive_resolved_references(Thread *THREAD) NOT_CDS_JAVA_HEAP_RETURN;
void archive_resolved_references() NOT_CDS_JAVA_HEAP_RETURN;
void add_dumped_interned_strings() NOT_CDS_JAVA_HEAP_RETURN;
void resolve_class_constants(TRAPS) NOT_CDS_JAVA_HEAP_RETURN;
void remove_unshareable_info();