Skip to content

Commit 5d3441c

Browse files
iklamiklam
committedJun 14, 2024
Hand-merged some changes from JDK-8293980 (in preparation for mainline merge)
·
jdk-24-leydenpremain+2
1 parent e4c038d commit 5d3441c

File tree

4 files changed

+217
-198
lines changed

4 files changed

+217
-198
lines changed
 

‎src/hotspot/share/oops/constantPool.cpp

+3-190
Original file line numberDiff line numberDiff line change
@@ -325,7 +325,7 @@ objArrayOop ConstantPool::prepare_resolved_references_for_archiving() {
325325
for (int i = 0; i < method_entries->length(); i++) {
326326
ResolvedMethodEntry* rme = method_entries->adr_at(i);
327327
if (rme->is_resolved(Bytecodes::_invokehandle) && rme->has_appendix() &&
328-
can_archive_resolved_method(rme)) {
328+
cache()->can_archive_resolved_method(rme)) {
329329
int rr_index = rme->resolved_references_index();
330330
keep_resolved_refs.at_put(rr_index, true);
331331
}
@@ -497,7 +497,7 @@ void ConstantPool::remove_unshareable_entries() {
497497
break;
498498
case JVM_CONSTANT_UnresolvedClassInError:
499499
tag_at_put(cp_index, JVM_CONSTANT_UnresolvedClass);
500-
ArchiveBuilder::alloc_stats()->record_klass_cp_entry(false, false);
500+
ArchiveBuilder::alloc_stats()->record_klass_cp_entry(false, true);
501501
break;
502502
case JVM_CONSTANT_MethodHandleInError:
503503
tag_at_put(cp_index, JVM_CONSTANT_MethodHandle);
@@ -518,9 +518,7 @@ void ConstantPool::remove_unshareable_entries() {
518518

519519
if (cache() != nullptr) {
520520
// cache() is null if this class is not yet linked.
521-
remove_resolved_field_entries_if_non_deterministic();
522-
remove_resolved_method_entries_if_non_deterministic();
523-
remove_resolved_indy_entries_if_non_deterministic();
521+
cache()->remove_unshareable_info();
524522
}
525523
}
526524

@@ -565,191 +563,6 @@ void ConstantPool::remove_resolved_klass_if_non_deterministic(int cp_index) {
565563

566564
ArchiveBuilder::alloc_stats()->record_klass_cp_entry(can_archive, /*reverted=*/!can_archive);
567565
}
568-
569-
void ConstantPool::remove_resolved_field_entries_if_non_deterministic() {
570-
ConstantPool* src_cp = ArchiveBuilder::current()->get_source_addr(this);
571-
Array<ResolvedFieldEntry>* field_entries = cache()->resolved_field_entries();
572-
if (field_entries != nullptr) {
573-
for (int i = 0; i < field_entries->length(); i++) {
574-
ResolvedFieldEntry* rfi = field_entries->adr_at(i);
575-
int cp_index = rfi->constant_pool_index();
576-
bool archived = false;
577-
bool resolved = rfi->is_resolved(Bytecodes::_getstatic) ||
578-
rfi->is_resolved(Bytecodes::_putstatic) ||
579-
rfi->is_resolved(Bytecodes::_putfield) ||
580-
rfi->is_resolved(Bytecodes::_putfield);
581-
if (resolved && ClassPrelinker::is_resolution_deterministic(src_cp, cp_index)) {
582-
rfi->mark_and_relocate();
583-
archived = true;
584-
} else {
585-
rfi->remove_unshareable_info();
586-
}
587-
if (resolved) {
588-
LogStreamHandle(Trace, cds, resolve) log;
589-
if (log.is_enabled()) {
590-
ResourceMark rm;
591-
int klass_cp_index = uncached_klass_ref_index_at(cp_index);
592-
Symbol* klass_name = klass_name_at(klass_cp_index);
593-
Symbol* name = uncached_name_ref_at(cp_index);
594-
Symbol* signature = uncached_signature_ref_at(cp_index);
595-
log.print("%s field CP entry [%3d]: %s %s %s.%s:%s",
596-
(archived ? "archived" : "reverted"),
597-
cp_index,
598-
pool_holder()->name()->as_C_string(),
599-
(archived ? "=>" : " "),
600-
klass_name->as_C_string(), name->as_C_string(), signature->as_C_string());
601-
}
602-
}
603-
ArchiveBuilder::alloc_stats()->record_field_cp_entry(archived, resolved && !archived);
604-
}
605-
}
606-
}
607-
608-
void ConstantPool::remove_resolved_method_entries_if_non_deterministic() {
609-
ConstantPool* src_cp = ArchiveBuilder::current()->get_source_addr(this);
610-
Array<ResolvedMethodEntry>* method_entries = cache()->resolved_method_entries();
611-
if (method_entries != nullptr) {
612-
for (int i = 0; i < method_entries->length(); i++) {
613-
ResolvedMethodEntry* rme = method_entries->adr_at(i);
614-
int cp_index = rme->constant_pool_index();
615-
bool archived = false;
616-
bool resolved = rme->is_resolved(Bytecodes::_invokevirtual) ||
617-
rme->is_resolved(Bytecodes::_invokespecial) ||
618-
rme->is_resolved(Bytecodes::_invokestatic) ||
619-
rme->is_resolved(Bytecodes::_invokeinterface) ||
620-
rme->is_resolved(Bytecodes::_invokehandle);
621-
if (resolved && can_archive_resolved_method(rme)) {
622-
rme->mark_and_relocate(src_cp);
623-
archived = true;
624-
} else {
625-
rme->remove_unshareable_info();
626-
}
627-
if (resolved) {
628-
LogStreamHandle(Trace, cds, resolve) log;
629-
if (log.is_enabled()) {
630-
ResourceMark rm;
631-
int klass_cp_index = uncached_klass_ref_index_at(cp_index);
632-
Symbol* klass_name = klass_name_at(klass_cp_index);
633-
Symbol* name = uncached_name_ref_at(cp_index);
634-
Symbol* signature = uncached_signature_ref_at(cp_index);
635-
log.print("%s%s method CP entry [%3d]: %s %s.%s:%s",
636-
(archived ? "archived" : "reverted"),
637-
(rme->is_resolved(Bytecodes::_invokeinterface) ? " interface" : ""),
638-
cp_index,
639-
pool_holder()->name()->as_C_string(),
640-
klass_name->as_C_string(), name->as_C_string(), signature->as_C_string());
641-
if (archived) {
642-
Klass* resolved_klass = resolved_klass_at(klass_cp_index);
643-
log.print(" => %s%s",
644-
resolved_klass->name()->as_C_string(),
645-
(rme->is_resolved(Bytecodes::_invokestatic) ? " *** static" : ""));
646-
}
647-
}
648-
}
649-
ArchiveBuilder::alloc_stats()->record_method_cp_entry(archived, resolved && !archived);
650-
}
651-
}
652-
}
653-
654-
void ConstantPool::remove_resolved_indy_entries_if_non_deterministic() {
655-
ConstantPool* src_cp = ArchiveBuilder::current()->get_source_addr(this);
656-
Array<ResolvedIndyEntry>* indy_entries = cache()->resolved_indy_entries();
657-
if (indy_entries != nullptr) {
658-
for (int i = 0; i < indy_entries->length(); i++) {
659-
ResolvedIndyEntry* rei = indy_entries->adr_at(i);
660-
int cp_index = rei->constant_pool_index();
661-
bool archived = false;
662-
bool resolved = rei->is_resolved();
663-
if (resolved && ClassPrelinker::is_resolution_deterministic(src_cp, cp_index)) {
664-
rei->mark_and_relocate();
665-
archived = true;
666-
} else {
667-
rei->remove_unshareable_info();
668-
}
669-
if (resolved) {
670-
LogStreamHandle(Trace, cds, resolve) log;
671-
if (log.is_enabled()) {
672-
ResourceMark rm;
673-
int bsm = bootstrap_method_ref_index_at(cp_index);
674-
int bsm_ref = method_handle_index_at(bsm);
675-
Symbol* bsm_name = uncached_name_ref_at(bsm_ref);
676-
Symbol* bsm_signature = uncached_signature_ref_at(bsm_ref);
677-
Symbol* bsm_klass = klass_name_at(uncached_klass_ref_index_at(bsm_ref));
678-
log.print("%s indy CP entry [%3d]: %s (%d)",
679-
(archived ? "archived" : "reverted"),
680-
cp_index, pool_holder()->name()->as_C_string(), i);
681-
log.print(" %s %s.%s:%s", (archived ? "=>" : " "), bsm_klass->as_C_string(), bsm_name->as_C_string(), bsm_signature->as_C_string());
682-
}
683-
}
684-
ArchiveBuilder::alloc_stats()->record_indy_cp_entry(archived, resolved && !archived);
685-
}
686-
}
687-
}
688-
689-
bool ConstantPool::can_archive_invokehandle(ResolvedMethodEntry* rme) {
690-
assert(rme->is_resolved(Bytecodes::_invokehandle), "sanity");
691-
692-
int cp_index = rme->constant_pool_index();
693-
int klass_cp_index = uncached_klass_ref_index_at(cp_index);
694-
Klass* resolved_klass = resolved_klass_at(klass_cp_index);
695-
if (!resolved_klass->is_instance_klass()) {
696-
// FIXME: can this ever happen?
697-
return false;
698-
}
699-
// FIXME -- any class referenced by the archived CP entries should be added to ArchiveBuilder::classes, or should be
700-
// filtered out.
701-
return true;
702-
}
703-
704-
bool ConstantPool::can_archive_resolved_method(ResolvedMethodEntry* method_entry) {
705-
if (!(pool_holder()->is_shared_boot_class() || pool_holder()->is_shared_platform_class() ||
706-
pool_holder()->is_shared_app_class())) {
707-
// Archiving resolved cp entries for classes from non-builtin loaders
708-
// is not yet supported.
709-
return false;
710-
}
711-
712-
if (CDSConfig::is_dumping_dynamic_archive()) {
713-
// InstanceKlass::methods() is has been resorted. We need to
714-
// update the vtable_index in method_entry (not implemented)
715-
return false;
716-
}
717-
718-
if (!method_entry->is_resolved(Bytecodes::_invokevirtual)) {
719-
if (method_entry->method() == nullptr) {
720-
return false;
721-
}
722-
if (method_entry->method()->is_continuation_native_intrinsic()) {
723-
return false; // FIXME: corresponding stub is generated on demand during method resolution (see LinkResolver::resolve_static_call).
724-
}
725-
}
726-
727-
int cp_index = method_entry->constant_pool_index();
728-
ConstantPool* src_cp = ArchiveBuilder::current()->get_source_addr(this);
729-
assert(src_cp->tag_at(cp_index).is_method() || src_cp->tag_at(cp_index).is_interface_method(), "sanity");
730-
731-
if (!ClassPrelinker::is_resolution_deterministic(src_cp, cp_index)) {
732-
return false;
733-
}
734-
735-
if (method_entry->is_resolved(Bytecodes::_invokehandle)) {
736-
if (!ArchiveInvokeDynamic) {
737-
// invokehandle depends on archived MethodType and LambdaForms.
738-
return false;
739-
} else if (!can_archive_invokehandle(method_entry)) {
740-
return false;
741-
}
742-
} else if (method_entry->is_resolved(Bytecodes::_invokestatic) ||
743-
method_entry->is_resolved(Bytecodes::_invokeinterface) ||
744-
method_entry->is_resolved(Bytecodes::_invokevirtual) ||
745-
method_entry->is_resolved(Bytecodes::_invokespecial)) {
746-
// OK
747-
} else {
748-
return false; // just to be safe.
749-
}
750-
751-
return true;
752-
}
753566
#endif // INCLUDE_CDS
754567

755568
int ConstantPool::cp_to_object_index(int cp_index) {

‎src/hotspot/share/oops/constantPool.hpp

+1-6
Original file line numberDiff line numberDiff line change
@@ -667,7 +667,7 @@ class ConstantPool : public Metadata {
667667

668668
bool is_resolved(int which, Bytecodes::Code code);
669669

670-
// Lookup for entries consisting of (name_index, signature_index)
670+
// Lookup for entries consisting of (name_index, signature_index)
671671
u2 name_ref_index_at(int cp_index); // == low-order jshort of name_and_type_at(cp_index)
672672
u2 signature_ref_index_at(int cp_index); // == high-order jshort of name_and_type_at(cp_index)
673673

@@ -683,16 +683,11 @@ class ConstantPool : public Metadata {
683683
// CDS support
684684
objArrayOop prepare_resolved_references_for_archiving() NOT_CDS_JAVA_HEAP_RETURN_(nullptr);
685685
void add_dumped_interned_strings() NOT_CDS_JAVA_HEAP_RETURN;
686-
bool can_archive_invokehandle(ResolvedMethodEntry* rme);
687-
bool can_archive_resolved_method(ResolvedMethodEntry* method_entry);
688686
void remove_unshareable_info();
689687
void remove_unshareable_entries();
690688
void restore_unshareable_info(TRAPS);
691689
private:
692690
void remove_resolved_klass_if_non_deterministic(int cp_index);
693-
void remove_resolved_field_entries_if_non_deterministic();
694-
void remove_resolved_method_entries_if_non_deterministic();
695-
void remove_resolved_indy_entries_if_non_deterministic();
696691
#endif
697692

698693
private:

‎src/hotspot/share/oops/cpCache.cpp

+200
Original file line numberDiff line numberDiff line change
@@ -24,6 +24,7 @@
2424

2525
#include "precompiled.hpp"
2626
#include "cds/cdsConfig.hpp"
27+
#include "cds/classPrelinker.hpp"
2728
#include "cds/heapShared.hpp"
2829
#include "classfile/resolutionErrors.hpp"
2930
#include "classfile/systemDictionary.hpp"
@@ -46,6 +47,7 @@
4647
#include "oops/cpCache.inline.hpp"
4748
#include "oops/objArrayOop.inline.hpp"
4849
#include "oops/oop.inline.hpp"
50+
#include "oops/method.inline.hpp"
4951
#include "oops/resolvedFieldEntry.hpp"
5052
#include "oops/resolvedIndyEntry.hpp"
5153
#include "oops/resolvedMethodEntry.hpp"
@@ -397,6 +399,204 @@ void ConstantPoolCache::record_gc_epoch() {
397399
_gc_epoch = CodeCache::gc_epoch();
398400
}
399401

402+
#if INCLUDE_CDS
403+
void ConstantPoolCache::remove_unshareable_info() {
404+
assert(CDSConfig::is_dumping_archive(), "sanity");
405+
406+
if (_resolved_indy_entries != nullptr) {
407+
remove_resolved_indy_entries_if_non_deterministic();
408+
}
409+
if (_resolved_field_entries != nullptr) {
410+
remove_resolved_field_entries_if_non_deterministic();
411+
}
412+
if (_resolved_method_entries != nullptr) {
413+
remove_resolved_method_entries_if_non_deterministic();
414+
}
415+
}
416+
417+
void ConstantPoolCache::remove_resolved_field_entries_if_non_deterministic() {
418+
ConstantPool* cp = constant_pool();
419+
ConstantPool* src_cp = ArchiveBuilder::current()->get_source_addr(cp);
420+
for (int i = 0; i < _resolved_field_entries->length(); i++) {
421+
ResolvedFieldEntry* rfi = _resolved_field_entries->adr_at(i);
422+
int cp_index = rfi->constant_pool_index();
423+
bool archived = false;
424+
bool resolved = rfi->is_resolved(Bytecodes::_getstatic) ||
425+
rfi->is_resolved(Bytecodes::_putstatic) ||
426+
rfi->is_resolved(Bytecodes::_getfield) ||
427+
rfi->is_resolved(Bytecodes::_putfield);
428+
if (resolved && ClassPrelinker::is_resolution_deterministic(src_cp, cp_index)) {
429+
rfi->mark_and_relocate();
430+
archived = true;
431+
} else {
432+
rfi->remove_unshareable_info();
433+
}
434+
if (resolved) {
435+
LogStreamHandle(Trace, cds, resolve) log;
436+
if (log.is_enabled()) {
437+
ResourceMark rm;
438+
int klass_cp_index = cp->uncached_klass_ref_index_at(cp_index);
439+
Symbol* klass_name = cp->klass_name_at(klass_cp_index);
440+
Symbol* name = cp->uncached_name_ref_at(cp_index);
441+
Symbol* signature = cp->uncached_signature_ref_at(cp_index);
442+
log.print("%s field CP entry [%3d]: %s %s %s.%s:%s",
443+
(archived ? "archived" : "reverted"),
444+
cp_index,
445+
cp->pool_holder()->name()->as_C_string(),
446+
(archived ? "=>" : " "),
447+
klass_name->as_C_string(), name->as_C_string(), signature->as_C_string());
448+
}
449+
}
450+
ArchiveBuilder::alloc_stats()->record_field_cp_entry(archived, resolved && !archived);
451+
}
452+
}
453+
454+
void ConstantPoolCache::remove_resolved_method_entries_if_non_deterministic() {
455+
ConstantPool* cp = constant_pool();
456+
ConstantPool* src_cp = ArchiveBuilder::current()->get_source_addr(cp);
457+
for (int i = 0; i < _resolved_method_entries->length(); i++) {
458+
ResolvedMethodEntry* rme = _resolved_method_entries->adr_at(i);
459+
int cp_index = rme->constant_pool_index();
460+
bool archived = false;
461+
bool resolved = rme->is_resolved(Bytecodes::_invokevirtual) ||
462+
rme->is_resolved(Bytecodes::_invokespecial) ||
463+
rme->is_resolved(Bytecodes::_invokestatic) ||
464+
rme->is_resolved(Bytecodes::_invokeinterface) ||
465+
rme->is_resolved(Bytecodes::_invokehandle);
466+
if (resolved && can_archive_resolved_method(rme)) {
467+
rme->mark_and_relocate(src_cp);
468+
archived = true;
469+
} else {
470+
rme->remove_unshareable_info();
471+
}
472+
if (resolved) {
473+
LogStreamHandle(Trace, cds, resolve) log;
474+
if (log.is_enabled()) {
475+
ResourceMark rm;
476+
int klass_cp_index = cp->uncached_klass_ref_index_at(cp_index);
477+
Symbol* klass_name = cp->klass_name_at(klass_cp_index);
478+
Symbol* name = cp->uncached_name_ref_at(cp_index);
479+
Symbol* signature = cp->uncached_signature_ref_at(cp_index);
480+
log.print("%s%s method CP entry [%3d]: %s %s.%s:%s",
481+
(archived ? "archived" : "reverted"),
482+
(rme->is_resolved(Bytecodes::_invokeinterface) ? " interface" : ""),
483+
cp_index,
484+
cp->pool_holder()->name()->as_C_string(),
485+
klass_name->as_C_string(), name->as_C_string(), signature->as_C_string());
486+
if (archived) {
487+
Klass* resolved_klass = cp->resolved_klass_at(klass_cp_index);
488+
log.print(" => %s%s",
489+
resolved_klass->name()->as_C_string(),
490+
(rme->is_resolved(Bytecodes::_invokestatic) ? " *** static" : ""));
491+
}
492+
}
493+
ArchiveBuilder::alloc_stats()->record_method_cp_entry(archived, resolved && !archived);
494+
}
495+
}
496+
}
497+
498+
void ConstantPoolCache::remove_resolved_indy_entries_if_non_deterministic() {
499+
ConstantPool* cp = constant_pool();
500+
ConstantPool* src_cp = ArchiveBuilder::current()->get_source_addr(cp);
501+
for (int i = 0; i < _resolved_indy_entries->length(); i++) {
502+
ResolvedIndyEntry* rei = _resolved_indy_entries->adr_at(i);
503+
int cp_index = rei->constant_pool_index();
504+
bool archived = false;
505+
bool resolved = rei->is_resolved();
506+
if (resolved && ClassPrelinker::is_resolution_deterministic(src_cp, cp_index)) {
507+
rei->mark_and_relocate();
508+
archived = true;
509+
} else {
510+
rei->remove_unshareable_info();
511+
}
512+
if (resolved) {
513+
LogStreamHandle(Trace, cds, resolve) log;
514+
if (log.is_enabled()) {
515+
ResourceMark rm;
516+
int bsm = cp->bootstrap_method_ref_index_at(cp_index);
517+
int bsm_ref = cp->method_handle_index_at(bsm);
518+
Symbol* bsm_name = cp->uncached_name_ref_at(bsm_ref);
519+
Symbol* bsm_signature = cp->uncached_signature_ref_at(bsm_ref);
520+
Symbol* bsm_klass = cp->klass_name_at(cp->uncached_klass_ref_index_at(bsm_ref));
521+
log.print("%s indy CP entry [%3d]: %s (%d)",
522+
(archived ? "archived" : "reverted"),
523+
cp_index, cp->pool_holder()->name()->as_C_string(), i);
524+
log.print(" %s %s.%s:%s", (archived ? "=>" : " "), bsm_klass->as_C_string(),
525+
bsm_name->as_C_string(), bsm_signature->as_C_string());
526+
}
527+
ArchiveBuilder::alloc_stats()->record_indy_cp_entry(archived, resolved && !archived);
528+
}
529+
}
530+
}
531+
532+
bool ConstantPoolCache::can_archive_invokehandle(ResolvedMethodEntry* rme) {
533+
ConstantPool* cp = constant_pool();
534+
assert(rme->is_resolved(Bytecodes::_invokehandle), "sanity");
535+
536+
int cp_index = rme->constant_pool_index();
537+
int klass_cp_index = cp->uncached_klass_ref_index_at(cp_index);
538+
Klass* resolved_klass = cp->resolved_klass_at(klass_cp_index);
539+
if (!resolved_klass->is_instance_klass()) {
540+
// FIXME: can this ever happen?
541+
return false;
542+
}
543+
// FIXME -- any class referenced by the archived CP entries should be added to ArchiveBuilder::classes, or should be
544+
// filtered out.
545+
return true;
546+
}
547+
548+
bool ConstantPoolCache::can_archive_resolved_method(ResolvedMethodEntry* method_entry) {
549+
InstanceKlass* pool_holder = constant_pool()->pool_holder();
550+
if (!(pool_holder->is_shared_boot_class() || pool_holder->is_shared_platform_class() ||
551+
pool_holder->is_shared_app_class())) {
552+
// Archiving resolved cp entries for classes from non-builtin loaders
553+
// is not yet supported.
554+
return false;
555+
}
556+
557+
if (CDSConfig::is_dumping_dynamic_archive()) {
558+
// InstanceKlass::methods() is has been resorted. We need to
559+
// update the vtable_index in method_entry (not implemented)
560+
return false;
561+
}
562+
563+
if (!method_entry->is_resolved(Bytecodes::_invokevirtual)) {
564+
if (method_entry->method() == nullptr) {
565+
return false;
566+
}
567+
if (method_entry->method()->is_continuation_native_intrinsic()) {
568+
return false; // FIXME: corresponding stub is generated on demand during method resolution (see LinkResolver::resolve_static_call).
569+
}
570+
}
571+
572+
int cp_index = method_entry->constant_pool_index();
573+
ConstantPool* src_cp = ArchiveBuilder::current()->get_source_addr(constant_pool());
574+
assert(src_cp->tag_at(cp_index).is_method() || src_cp->tag_at(cp_index).is_interface_method(), "sanity");
575+
576+
if (!ClassPrelinker::is_resolution_deterministic(src_cp, cp_index)) {
577+
return false;
578+
}
579+
580+
if (method_entry->is_resolved(Bytecodes::_invokehandle)) {
581+
if (!ArchiveInvokeDynamic) {
582+
// invokehandle depends on archived MethodType and LambdaForms.
583+
return false;
584+
} else if (!can_archive_invokehandle(method_entry)) {
585+
return false;
586+
}
587+
} else if (method_entry->is_resolved(Bytecodes::_invokestatic) ||
588+
method_entry->is_resolved(Bytecodes::_invokeinterface) ||
589+
method_entry->is_resolved(Bytecodes::_invokevirtual) ||
590+
method_entry->is_resolved(Bytecodes::_invokespecial)) {
591+
// OK
592+
} else {
593+
return false; // just to be safe.
594+
}
595+
596+
return true;
597+
}
598+
#endif // INCLUDE_CDS
599+
400600
void ConstantPoolCache::deallocate_contents(ClassLoaderData* data) {
401601
assert(!is_shared(), "shared caches are not deallocated");
402602
data->remove_handle(_resolved_references);

‎src/hotspot/share/oops/cpCache.hpp

+13-2
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,5 @@
11
/*
2-
* Copyright (c) 1998, 2023, Oracle and/or its affiliates. All rights reserved.
2+
* Copyright (c) 1998, 2024, Oracle and/or its affiliates. All rights reserved.
33
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
44
*
55
* This code is free software; you can redistribute it and/or modify it
@@ -191,11 +191,14 @@ class ConstantPoolCache: public MetaspaceObj {
191191
static ByteSize field_entries_offset() { return byte_offset_of(ConstantPoolCache, _resolved_field_entries); }
192192
static ByteSize method_entries_offset() { return byte_offset_of(ConstantPoolCache, _resolved_method_entries); }
193193

194+
#if INCLUDE_CDS
195+
void remove_unshareable_info();
196+
#endif
197+
194198
public:
195199
static int size() { return align_metadata_size(sizeof(ConstantPoolCache) / wordSize); }
196200

197201
private:
198-
199202
// Helpers
200203
ConstantPool** constant_pool_addr() { return &_constant_pool; }
201204

@@ -219,6 +222,14 @@ class ConstantPoolCache: public MetaspaceObj {
219222
void dump_cache();
220223
#endif // INCLUDE_JVMTI
221224

225+
#if INCLUDE_CDS
226+
void remove_resolved_field_entries_if_non_deterministic();
227+
void remove_resolved_indy_entries_if_non_deterministic();
228+
void remove_resolved_method_entries_if_non_deterministic();
229+
bool can_archive_resolved_method(ResolvedMethodEntry* method_entry);
230+
bool can_archive_invokehandle(ResolvedMethodEntry* rme);
231+
#endif
232+
222233
// RedefineClasses support
223234
DEBUG_ONLY(bool on_stack() { return false; })
224235
void deallocate_contents(ClassLoaderData* data);

0 commit comments

Comments
 (0)
Please sign in to comment.