42 // system loaders (e.g., if you create a custom JDK image with only java.base).
43 if (loader_data != NULL) {
44 assert(!loader_data->has_class_mirror_holder(),
45 "loaders for non-strong hidden classes or unsafe anonymous classes not supported");
46 }
47 }
48 public:
49 ArchivedClassLoaderData() : _packages(NULL), _modules(NULL) {}
50
51 void iterate_symbols(ClassLoaderData* loader_data, MetaspaceClosure* closure);
52 void allocate(ClassLoaderData* loader_data);
53 void init_archived_entries(ClassLoaderData* loader_data);
54 void init_archived_oops(ClassLoaderData* loader_data);
55
56 void serialize(SerializeClosure* f) {
57 f->do_ptr((void**)&_packages);
58 f->do_ptr((void**)&_modules);
59 }
60
61 void restore(ClassLoaderData* loader_data, bool do_entries, bool do_oops);
62 };
63
64 static ArchivedClassLoaderData _archived_boot_loader_data;
65 static ArchivedClassLoaderData _archived_platform_loader_data;
66 static ArchivedClassLoaderData _archived_system_loader_data;
67 static ModuleEntry* _archived_javabase_moduleEntry = NULL;
68
69 void ArchivedClassLoaderData::iterate_symbols(ClassLoaderData* loader_data, MetaspaceClosure* closure) {
70 assert(DumpSharedSpaces, "must be");
71 assert_valid(loader_data);
72 if (loader_data != NULL) {
73 loader_data->packages()->iterate_symbols(closure);
74 loader_data->modules() ->iterate_symbols(closure);
75 }
76 }
77
78 void ArchivedClassLoaderData::allocate(ClassLoaderData* loader_data) {
79 assert(DumpSharedSpaces, "must be");
80 assert_valid(loader_data);
81 if (loader_data != NULL) {
106 }
107
108 void ArchivedClassLoaderData::restore(ClassLoaderData* loader_data, bool do_entries, bool do_oops) {
109 assert(UseSharedSpaces, "must be");
110 assert_valid(loader_data);
111 if (_modules != NULL) { // Could be NULL if we have archived no modules for platform/system loaders
112 ModuleEntryTable* modules = loader_data->modules();
113 PackageEntryTable* packages = loader_data->packages();
114
115 MutexLocker m1(Module_lock);
116 if (do_entries) {
117 modules->load_archived_entries(loader_data, _modules);
118 packages->load_archived_entries(_packages);
119 }
120 if (do_oops) {
121 modules->restore_archived_oops(loader_data, _modules);
122 }
123 }
124 }
125
126 // ------------------------------
127
128 static ClassLoaderData* null_class_loader_data() {
129 ClassLoaderData* loader_data = ClassLoaderData::the_null_class_loader_data();
130 assert(loader_data != NULL, "must be");
131 return loader_data;
132 }
133
134 static ClassLoaderData* java_platform_loader_data_or_null() {
135 return ClassLoaderData::class_loader_data_or_null(SystemDictionary::java_platform_loader());
136 }
137
138 static ClassLoaderData* java_system_loader_data_or_null() {
139 return ClassLoaderData::class_loader_data_or_null(SystemDictionary::java_system_loader());
140 }
141
142 void ClassLoaderDataShared::iterate_symbols(MetaspaceClosure* closure) {
143 assert(DumpSharedSpaces && MetaspaceShared::use_full_module_graph(), "must be");
144 _archived_boot_loader_data.iterate_symbols (null_class_loader_data(), closure);
145 _archived_platform_loader_data.iterate_symbols(java_platform_loader_data_or_null(), closure);
166 _archived_boot_loader_data.init_archived_oops (null_class_loader_data());
167 _archived_platform_loader_data.init_archived_oops(java_platform_loader_data_or_null());
168 _archived_system_loader_data.init_archived_oops (java_system_loader_data_or_null());
169 }
170
171 void ClassLoaderDataShared::serialize(SerializeClosure* f) {
172 _archived_boot_loader_data.serialize(f);
173 _archived_platform_loader_data.serialize(f);
174 _archived_system_loader_data.serialize(f);
175 f->do_ptr((void**)&_archived_javabase_moduleEntry);
176
177 if (f->reading() && MetaspaceShared::use_full_module_graph()) {
178 // Must be done before ClassLoader::create_javabase()
179 _archived_boot_loader_data.restore(null_class_loader_data(), true, false);
180 ModuleEntryTable::set_javabase_moduleEntry(_archived_javabase_moduleEntry);
181 log_info(cds)("use_full_module_graph = true; java.base = " INTPTR_FORMAT,
182 p2i(_archived_javabase_moduleEntry));
183 }
184 }
185
186 oop ClassLoaderDataShared::restore_archived_oops_for_null_class_loader_data() {
187 assert(UseSharedSpaces && MetaspaceShared::use_full_module_graph(), "must be");
188 _archived_boot_loader_data.restore(null_class_loader_data(), false, true);
189 return _archived_javabase_moduleEntry->module();
190 }
191
192 void ClassLoaderDataShared::restore_java_platform_loader_from_archive(ClassLoaderData* loader_data) {
193 assert(UseSharedSpaces && MetaspaceShared::use_full_module_graph(), "must be");
194 _archived_platform_loader_data.restore(loader_data, true, true);
195 }
196
197 void ClassLoaderDataShared::restore_java_system_loader_from_archive(ClassLoaderData* loader_data) {
198 assert(UseSharedSpaces && MetaspaceShared::use_full_module_graph(), "must be");
199 _archived_system_loader_data.restore(loader_data, true, true);
200 }
201
202 #endif // INCLUDE_CDS_JAVA_HEAP
|
42 // system loaders (e.g., if you create a custom JDK image with only java.base).
43 if (loader_data != NULL) {
44 assert(!loader_data->has_class_mirror_holder(),
45 "loaders for non-strong hidden classes or unsafe anonymous classes not supported");
46 }
47 }
48 public:
49 ArchivedClassLoaderData() : _packages(NULL), _modules(NULL) {}
50
51 void iterate_symbols(ClassLoaderData* loader_data, MetaspaceClosure* closure);
52 void allocate(ClassLoaderData* loader_data);
53 void init_archived_entries(ClassLoaderData* loader_data);
54 void init_archived_oops(ClassLoaderData* loader_data);
55
56 void serialize(SerializeClosure* f) {
57 f->do_ptr((void**)&_packages);
58 f->do_ptr((void**)&_modules);
59 }
60
61 void restore(ClassLoaderData* loader_data, bool do_entries, bool do_oops);
62 void clear_archived_oops();
63 };
64
65 static ArchivedClassLoaderData _archived_boot_loader_data;
66 static ArchivedClassLoaderData _archived_platform_loader_data;
67 static ArchivedClassLoaderData _archived_system_loader_data;
68 static ModuleEntry* _archived_javabase_moduleEntry = NULL;
69
70 void ArchivedClassLoaderData::iterate_symbols(ClassLoaderData* loader_data, MetaspaceClosure* closure) {
71 assert(DumpSharedSpaces, "must be");
72 assert_valid(loader_data);
73 if (loader_data != NULL) {
74 loader_data->packages()->iterate_symbols(closure);
75 loader_data->modules() ->iterate_symbols(closure);
76 }
77 }
78
79 void ArchivedClassLoaderData::allocate(ClassLoaderData* loader_data) {
80 assert(DumpSharedSpaces, "must be");
81 assert_valid(loader_data);
82 if (loader_data != NULL) {
107 }
108
109 void ArchivedClassLoaderData::restore(ClassLoaderData* loader_data, bool do_entries, bool do_oops) {
110 assert(UseSharedSpaces, "must be");
111 assert_valid(loader_data);
112 if (_modules != NULL) { // Could be NULL if we have archived no modules for platform/system loaders
113 ModuleEntryTable* modules = loader_data->modules();
114 PackageEntryTable* packages = loader_data->packages();
115
116 MutexLocker m1(Module_lock);
117 if (do_entries) {
118 modules->load_archived_entries(loader_data, _modules);
119 packages->load_archived_entries(_packages);
120 }
121 if (do_oops) {
122 modules->restore_archived_oops(loader_data, _modules);
123 }
124 }
125 }
126
127 void ArchivedClassLoaderData::clear_archived_oops() {
128 assert(UseSharedSpaces, "must be");
129 if (_modules != NULL) {
130 for (int i = 0; i < _modules->length(); i++) {
131 _modules->at(i)->clear_archived_oops();
132 }
133 }
134 }
135
136 // ------------------------------
137
138 static ClassLoaderData* null_class_loader_data() {
139 ClassLoaderData* loader_data = ClassLoaderData::the_null_class_loader_data();
140 assert(loader_data != NULL, "must be");
141 return loader_data;
142 }
143
144 static ClassLoaderData* java_platform_loader_data_or_null() {
145 return ClassLoaderData::class_loader_data_or_null(SystemDictionary::java_platform_loader());
146 }
147
148 static ClassLoaderData* java_system_loader_data_or_null() {
149 return ClassLoaderData::class_loader_data_or_null(SystemDictionary::java_system_loader());
150 }
151
152 void ClassLoaderDataShared::iterate_symbols(MetaspaceClosure* closure) {
153 assert(DumpSharedSpaces && MetaspaceShared::use_full_module_graph(), "must be");
154 _archived_boot_loader_data.iterate_symbols (null_class_loader_data(), closure);
155 _archived_platform_loader_data.iterate_symbols(java_platform_loader_data_or_null(), closure);
176 _archived_boot_loader_data.init_archived_oops (null_class_loader_data());
177 _archived_platform_loader_data.init_archived_oops(java_platform_loader_data_or_null());
178 _archived_system_loader_data.init_archived_oops (java_system_loader_data_or_null());
179 }
180
181 void ClassLoaderDataShared::serialize(SerializeClosure* f) {
182 _archived_boot_loader_data.serialize(f);
183 _archived_platform_loader_data.serialize(f);
184 _archived_system_loader_data.serialize(f);
185 f->do_ptr((void**)&_archived_javabase_moduleEntry);
186
187 if (f->reading() && MetaspaceShared::use_full_module_graph()) {
188 // Must be done before ClassLoader::create_javabase()
189 _archived_boot_loader_data.restore(null_class_loader_data(), true, false);
190 ModuleEntryTable::set_javabase_moduleEntry(_archived_javabase_moduleEntry);
191 log_info(cds)("use_full_module_graph = true; java.base = " INTPTR_FORMAT,
192 p2i(_archived_javabase_moduleEntry));
193 }
194 }
195
196 void ClassLoaderDataShared::clear_archived_oops() {
197 assert(UseSharedSpaces && !MetaspaceShared::use_full_module_graph(), "must be");
198 _archived_boot_loader_data.clear_archived_oops();
199 _archived_platform_loader_data.clear_archived_oops();
200 _archived_system_loader_data.clear_archived_oops();
201 }
202
203 oop ClassLoaderDataShared::restore_archived_oops_for_null_class_loader_data() {
204 assert(UseSharedSpaces && MetaspaceShared::use_full_module_graph(), "must be");
205 _archived_boot_loader_data.restore(null_class_loader_data(), false, true);
206 return _archived_javabase_moduleEntry->module();
207 }
208
209 void ClassLoaderDataShared::restore_java_platform_loader_from_archive(ClassLoaderData* loader_data) {
210 assert(UseSharedSpaces && MetaspaceShared::use_full_module_graph(), "must be");
211 _archived_platform_loader_data.restore(loader_data, true, true);
212 }
213
214 void ClassLoaderDataShared::restore_java_system_loader_from_archive(ClassLoaderData* loader_data) {
215 assert(UseSharedSpaces && MetaspaceShared::use_full_module_graph(), "must be");
216 _archived_system_loader_data.restore(loader_data, true, true);
217 }
218
219 #endif // INCLUDE_CDS_JAVA_HEAP
|