< prev index next > src/hotspot/share/cds/heapShared.cpp
Print this page
* questions.
*
*/
#include "cds/aotArtifactFinder.hpp"
+ #include "cds/aotCacheAccess.hpp"
#include "cds/aotClassInitializer.hpp"
#include "cds/aotClassLocation.hpp"
#include "cds/aotCompressedPointers.hpp"
+ #include "cds/aotConstantPoolResolver.hpp"
#include "cds/aotLogging.hpp"
#include "cds/aotMappedHeapLoader.hpp"
#include "cds/aotMappedHeapWriter.hpp"
#include "cds/aotMetaspace.hpp"
#include "cds/aotOopChecker.hpp"
#include "classfile/symbolTable.hpp"
#include "classfile/systemDictionary.hpp"
#include "classfile/systemDictionaryShared.hpp"
#include "classfile/vmClasses.hpp"
#include "classfile/vmSymbols.hpp"
+ #include "code/aotCodeCache.hpp"
#include "gc/shared/collectedHeap.hpp"
#include "gc/shared/gcLocker.hpp"
#include "gc/shared/gcVMOperations.hpp"
#include "logging/log.hpp"
#include "logging/logStream.hpp"
{"jdk/internal/module/ArchivedModuleGraph", "archivedModuleGraph"},
{"java/util/ImmutableCollections", "archivedObjects"},
{"java/lang/ModuleLayer", "EMPTY_LAYER"},
{"java/lang/module/Configuration", "EMPTY_CONFIGURATION"},
{"jdk/internal/math/FDBigInteger", "archivedCaches"},
+ {"java/lang/reflect/Proxy$ProxyBuilder", "archivedData"}, // FIXME -- requires AOTClassLinking
#ifndef PRODUCT
{nullptr, nullptr}, // Extra slot for -XX:ArchiveHeapTestClass
#endif
{nullptr, nullptr},
m = RegeneratedClasses::get_regenerated_object(m);
}
InstanceKlass* method_holder = m->method_holder();
AOTArtifactFinder::add_cached_class(method_holder);
}
+ } else if (AOTCodeCache::is_dumping_code() &&
+ (java_lang_invoke_MethodHandle::is_instance(obj) || is_interned_string(obj))) {
+ // Needed by AOT compiler.
+ append_root(obj);
}
}
if (log_is_enabled(Debug, aot, heap)) {
ResourceMark rm;
switch (fd.field_type()) {
case T_OBJECT:
case T_ARRAY:
{
oop field_obj = orig_mirror->obj_field(offset);
- if (offset == java_lang_Class::reflection_data_offset()) {
- // Class::reflectData use SoftReference, which cannot be archived. Set it
- // to null and it will be recreated at runtime.
- field_obj = nullptr;
- }
m->obj_field_put(offset, field_obj);
if (field_obj != nullptr) {
bool success = archive_reachable_objects_from(1, _dump_time_special_subgraph, field_obj);
assert(success, "sanity");
}
if (CDSConfig::is_dumping_aot_linked_classes()) {
java_lang_Class::set_module(scratch_m, java_lang_Class::module(orig_mirror));
java_lang_Class::set_protection_domain(scratch_m, java_lang_Class::protection_domain(orig_mirror));
}
+
+ Klass* k = java_lang_Class::as_Klass(orig_mirror); // is null Universe::void_mirror();
+ if (CDSConfig::is_dumping_reflection_data() &&
+ k != nullptr && k->is_instance_klass() &&
+ java_lang_Class::reflection_data(orig_mirror) != nullptr &&
+ AOTConstantPoolResolver::can_archive_reflection_data(InstanceKlass::cast(k))) {
+ java_lang_Class::set_reflection_data(scratch_m, java_lang_Class::reflection_data(orig_mirror));
+ }
}
static objArrayOop get_archived_resolved_references(InstanceKlass* src_ik) {
if (SystemDictionaryShared::is_builtin_loader(src_ik->class_loader_data())) {
objArrayOop rr = src_ik->constants()->resolved_references_or_null();
}
void HeapShared::write_heap(AOTMappedHeapInfo* mapped_heap_info, AOTStreamedHeapInfo* streamed_heap_info) {
{
NoSafepointVerifier nsv;
- CDSHeapVerifier::verify();
+ if (!SkipArchiveHeapVerification) {
+ CDSHeapVerifier::verify();
+ }
check_special_subgraph_classes();
}
if (HeapShared::is_writing_mapping_mode()) {
StringTable::write_shared_table();
oop m = scratch_java_mirror(orig_mirror);
if (m != nullptr) { // nullptr if for custom class loader
copy_java_mirror(orig_mirror, m);
bool success = archive_reachable_objects_from(1, _dump_time_special_subgraph, m);
assert(success, "sanity");
+
+ oop extra;
+ if ((extra = java_lang_Class::reflection_data(m)) != nullptr) {
+ success = archive_reachable_objects_from(1, _dump_time_special_subgraph, extra);
+ assert(success, "sanity");
+ }
}
}
void HeapShared::scan_java_class(Klass* orig_k) {
scan_java_mirror(orig_k->java_mirror());
if (_subgraph_entry_fields == nullptr) {
_subgraph_entry_fields =
new (mtClass) GrowableArray<int>(10, mtClass);
}
_subgraph_entry_fields->append(static_field_offset);
- _subgraph_entry_fields->append(HeapShared::append_root(v));
+
+ // Leyden: Temp fix for JDK-8371655 {
+ if (v == nullptr) {
+ _subgraph_entry_fields->append(-1);
+ } else {
+ _subgraph_entry_fields->append(HeapShared::append_root(v));
+ }
+ // }
}
// Add the Klass* for an object in the current KlassSubGraphInfo's subgraphs.
// Only objects of boot classes can be included in sub-graph.
void KlassSubGraphInfo::add_subgraph_object_klass(Klass* orig_k) {
if (record == nullptr) {
clear_archived_roots_of(k);
}
}
+ static const char* java_lang_invoke_core_klasses[] = {
+ "java/lang/invoke/Invokers$Holder",
+ "java/lang/invoke/MethodHandle",
+ "java/lang/invoke/MethodHandleNatives",
+ "java/lang/invoke/DirectMethodHandle$Holder",
+ "java/lang/invoke/DelegatingMethodHandle$Holder",
+ "java/lang/invoke/LambdaForm$Holder",
+ "java/lang/invoke/BoundMethodHandle$Species_L",
+ };
+
void HeapShared::initialize_java_lang_invoke(TRAPS) {
if (CDSConfig::is_using_aot_linked_classes() || CDSConfig::is_dumping_method_handles()) {
- resolve_or_init("java/lang/invoke/Invokers$Holder", true, CHECK);
- resolve_or_init("java/lang/invoke/MethodHandle", true, CHECK);
- resolve_or_init("java/lang/invoke/MethodHandleNatives", true, CHECK);
- resolve_or_init("java/lang/invoke/DirectMethodHandle$Holder", true, CHECK);
- resolve_or_init("java/lang/invoke/DelegatingMethodHandle$Holder", true, CHECK);
- resolve_or_init("java/lang/invoke/LambdaForm$Holder", true, CHECK);
- resolve_or_init("java/lang/invoke/BoundMethodHandle$Species_L", true, CHECK);
+ int len = sizeof(java_lang_invoke_core_klasses)/sizeof(char*);
+ for (int i = 0; i < len; i++) {
+ resolve_or_init(java_lang_invoke_core_klasses[i], true, CHECK);
+ }
}
}
// Initialize the InstanceKlasses of objects that are reachable from the following roots:
// - interned strings
for (int i = 0; i < efr_len; i += 2) {
int field_offset = entry_field_records->at(i);
int root_index = entry_field_records->at(i+1);
// Load the subgraph entry fields from the record and store them back to
// the corresponding fields within the mirror.
- oop v = get_root(root_index, /*clear=*/true);
+
+ // Leyden: Temp fix for JDK-8371655 {
+ oop v;
+ if (root_index < 0) {
+ v = nullptr;
+ } else {
+ v = get_root(root_index, /*clear=*/true);
+ }
+ // }
+
oop m = k->java_mirror();
if (k->has_aot_initialized_mirror()) {
assert(v == m->obj_field(field_offset), "must be aot-initialized");
} else {
m->obj_field_put(field_offset, v);
< prev index next >