42 //
43 // Instances of java.lang.ClassLoader holds a pointer to a ClassLoaderData that
44 // that represent the loader's "linking domain" in the JVM.
45 //
46 // The bootstrap loader (represented by NULL) also has a ClassLoaderData,
47 // the singleton class the_null_class_loader_data().
48
49 #include "precompiled.hpp"
50 #include "classfile/classLoaderData.inline.hpp"
51 #include "classfile/classLoaderDataGraph.inline.hpp"
52 #include "classfile/dictionary.hpp"
53 #include "classfile/javaClasses.hpp"
54 #include "classfile/moduleEntry.hpp"
55 #include "classfile/packageEntry.hpp"
56 #include "classfile/symbolTable.hpp"
57 #include "classfile/systemDictionary.hpp"
58 #include "logging/log.hpp"
59 #include "logging/logStream.hpp"
60 #include "memory/allocation.inline.hpp"
61 #include "memory/metadataFactory.hpp"
62 #include "memory/metaspaceShared.hpp"
63 #include "memory/iterator.hpp"
64 #include "memory/resourceArea.hpp"
65 #include "memory/universe.hpp"
66 #include "oops/access.inline.hpp"
67 #include "oops/array.hpp"
68 #include "oops/oop.inline.hpp"
69 #include "oops/oopHandle.inline.hpp"
70 #include "oops/weakHandle.inline.hpp"
71 #include "runtime/atomic.hpp"
72 #include "runtime/handles.inline.hpp"
73 #include "runtime/mutex.hpp"
74 #include "runtime/safepoint.hpp"
75 #include "utilities/growableArray.hpp"
76 #include "utilities/macros.hpp"
77 #include "utilities/ostream.hpp"
78
79
80 #if INCLUDE_CDS_JAVA_HEAP
81 // Support for archiving full module graph in CDS
82
83 class ArchivedClassLoaderData {
84 Array<PackageEntry*>* _packages;
85 Array<ModuleEntry*>* _modules;
86
87 public:
88 ArchivedClassLoaderData() : _packages(NULL), _modules(NULL) {}
89
90 void allocate(ClassLoaderData* loader_data);
91 void init_archived_entries(ClassLoaderData* loader_data);
92 void init_archived_oops(ClassLoaderData* loader_data);
93
94 void serialize(SerializeClosure* f) {
95 f->do_ptr((void**)&_packages);
96 f->do_ptr((void**)&_modules);
97 }
98
99 void load_archived_entries(ClassLoaderData* loader_data);
100 void restore_archived_oops(ClassLoaderData* loader_data);
101 };
102
103 static ArchivedClassLoaderData _archived_boot_loader_data;
104 static ArchivedClassLoaderData _archived_platform_loader_data;
105 static ArchivedClassLoaderData _archived_system_loader_data;
106 static ModuleEntry* _archived_javabase_moduleEntry = NULL;
107
108 void ArchivedClassLoaderData::allocate(ClassLoaderData* loader_data) {
109 assert(DumpSharedSpaces, "must be");
110
111 // We can't create a hashtable at dump time because the hashcode dependes on the
112 // address of the Symbols, which may be relocated at run time due to ASLR.
113 if (loader_data) {
114 _packages = loader_data->packages()->allocate_archived_entries();
115 _modules = loader_data->modules() ->allocate_archived_entries();
116 }
117 }
118
119 void ArchivedClassLoaderData::init_archived_entries(ClassLoaderData* loader_data) {
120 assert(DumpSharedSpaces, "must be");
121 if (loader_data) {
122 loader_data->packages()->init_archived_entries(_packages);
123 loader_data->modules() ->init_archived_entries(_modules);
124 }
125 }
126
127 void ArchivedClassLoaderData::init_archived_oops(ClassLoaderData* loader_data) {
128 assert(DumpSharedSpaces, "must be");
129 if (loader_data) {
130 loader_data->modules()->init_archived_oops(_modules);
131 }
132 }
133
134 void ArchivedClassLoaderData::load_archived_entries(ClassLoaderData* loader_data) {
135 assert(UseSharedSpaces, "must be");
136 if (_modules) {
137 loader_data->modules()->load_archived_entries(loader_data, _modules);
138 loader_data->packages()->load_archived_entries(_packages);
139 }
140 }
141
142 void ArchivedClassLoaderData::restore_archived_oops(ClassLoaderData* loader_data) {
143 assert(UseSharedSpaces, "must be");
144 if (_modules) {
145 loader_data->modules()->restore_archived_oops(loader_data, _modules);
146 }
147 }
148
149 // ------------------------------
150
151 void ClassLoaderData::allocate_archived_tables() {
152 assert(DumpSharedSpaces, "must be");
153 if (MetaspaceShared::use_full_module_graph()) {
154 _archived_boot_loader_data.allocate (_the_null_class_loader_data);
155 _archived_platform_loader_data.allocate(class_loader_data_or_null(SystemDictionary::java_platform_loader()));
156 _archived_system_loader_data.allocate (class_loader_data_or_null(SystemDictionary::java_system_loader()));
157 }
158 }
159
160 void ClassLoaderData::init_archived_tables() {
161 assert(DumpSharedSpaces, "must be");
162 if (MetaspaceShared::use_full_module_graph()) {
163 _archived_boot_loader_data.init_archived_entries (_the_null_class_loader_data);
164 _archived_platform_loader_data.init_archived_entries(class_loader_data_or_null(SystemDictionary::java_platform_loader()));
165 _archived_system_loader_data.init_archived_entries (class_loader_data_or_null(SystemDictionary::java_system_loader()));
166 _archived_javabase_moduleEntry = ModuleEntry::get_archived_entry(ModuleEntryTable::javabase_moduleEntry());
167 }
168 }
169
170 void ClassLoaderData::init_archived_oops() {
171 assert(DumpSharedSpaces, "must be");
172 if (MetaspaceShared::use_full_module_graph()) {
173 _archived_boot_loader_data.init_archived_oops (_the_null_class_loader_data);
174 _archived_platform_loader_data.init_archived_oops(class_loader_data_or_null(SystemDictionary::java_platform_loader()));
175 _archived_system_loader_data.init_archived_oops (class_loader_data_or_null(SystemDictionary::java_system_loader()));
176 }
177 }
178
179 void ClassLoaderData::serialize(class SerializeClosure* f) {
180 _archived_boot_loader_data.serialize(f);
181 _archived_platform_loader_data.serialize(f);
182 _archived_system_loader_data.serialize(f);
183 f->do_ptr((void**)&_archived_javabase_moduleEntry);
184
185 if (f->reading() && MetaspaceShared::use_full_module_graph()) {
186 // Must be done before ClassLoader::create_javabase()
187 _archived_boot_loader_data.load_archived_entries(_the_null_class_loader_data);
188 ModuleEntryTable::set_javabase_moduleEntry(_archived_javabase_moduleEntry);
189 log_info(cds)("use_full_module_graph = true; java.base = " INTPTR_FORMAT,
190 p2i(_archived_javabase_moduleEntry));
191 }
192 }
193
194 void ClassLoaderData::restore_archived_oops_for_null_class_loader_data() {
195 assert(UseSharedSpaces, "must be");
196 if (MetaspaceShared::use_full_module_graph()) {
197 _archived_boot_loader_data.restore_archived_oops(_the_null_class_loader_data);
198 }
199 }
200
201 void ClassLoaderData::restore_java_platform_loader_from_archive() {
202 assert(UseSharedSpaces, "must be");
203 assert(MetaspaceShared::use_full_module_graph(), "must be");
204 assert(class_loader() == SystemDictionary::java_platform_loader(), "must be");
205 _archived_platform_loader_data.load_archived_entries(this);
206 _archived_platform_loader_data.restore_archived_oops(this);
207 }
208
209 void ClassLoaderData::restore_java_system_loader_from_archive() {
210 assert(UseSharedSpaces, "must be");
211 assert(MetaspaceShared::use_full_module_graph(), "must be");
212 assert(class_loader() == SystemDictionary::java_system_loader(), "must be");
213 _archived_system_loader_data.load_archived_entries(this);
214 _archived_system_loader_data.restore_archived_oops(this);
215 }
216
217 #endif // INCLUDE_JAVA_HEAP
218
219 ClassLoaderData * ClassLoaderData::_the_null_class_loader_data = NULL;
220
221 void ClassLoaderData::init_null_class_loader_data() {
222 assert(_the_null_class_loader_data == NULL, "cannot initialize twice");
223 assert(ClassLoaderDataGraph::_head == NULL, "cannot initialize twice");
224
225 _the_null_class_loader_data = new ClassLoaderData(Handle(), false);
226 ClassLoaderDataGraph::_head = _the_null_class_loader_data;
227 assert(_the_null_class_loader_data->is_the_null_class_loader_data(), "Must be");
228
229 LogTarget(Trace, class, loader, data) lt;
230 if (lt.is_enabled()) {
231 ResourceMark rm;
232 LogStream ls(lt);
233 ls.print("create ");
234 _the_null_class_loader_data->print_value_on(&ls);
235 ls.cr();
236 }
237 }
|
42 //
43 // Instances of java.lang.ClassLoader holds a pointer to a ClassLoaderData that
44 // that represent the loader's "linking domain" in the JVM.
45 //
46 // The bootstrap loader (represented by NULL) also has a ClassLoaderData,
47 // the singleton class the_null_class_loader_data().
48
49 #include "precompiled.hpp"
50 #include "classfile/classLoaderData.inline.hpp"
51 #include "classfile/classLoaderDataGraph.inline.hpp"
52 #include "classfile/dictionary.hpp"
53 #include "classfile/javaClasses.hpp"
54 #include "classfile/moduleEntry.hpp"
55 #include "classfile/packageEntry.hpp"
56 #include "classfile/symbolTable.hpp"
57 #include "classfile/systemDictionary.hpp"
58 #include "logging/log.hpp"
59 #include "logging/logStream.hpp"
60 #include "memory/allocation.inline.hpp"
61 #include "memory/metadataFactory.hpp"
62 #include "memory/iterator.hpp"
63 #include "memory/resourceArea.hpp"
64 #include "memory/universe.hpp"
65 #include "oops/access.inline.hpp"
66 #include "oops/array.hpp"
67 #include "oops/oop.inline.hpp"
68 #include "oops/oopHandle.inline.hpp"
69 #include "oops/weakHandle.inline.hpp"
70 #include "runtime/atomic.hpp"
71 #include "runtime/handles.inline.hpp"
72 #include "runtime/mutex.hpp"
73 #include "runtime/safepoint.hpp"
74 #include "utilities/growableArray.hpp"
75 #include "utilities/macros.hpp"
76 #include "utilities/ostream.hpp"
77
78 ClassLoaderData * ClassLoaderData::_the_null_class_loader_data = NULL;
79
80 void ClassLoaderData::init_null_class_loader_data() {
81 assert(_the_null_class_loader_data == NULL, "cannot initialize twice");
82 assert(ClassLoaderDataGraph::_head == NULL, "cannot initialize twice");
83
84 _the_null_class_loader_data = new ClassLoaderData(Handle(), false);
85 ClassLoaderDataGraph::_head = _the_null_class_loader_data;
86 assert(_the_null_class_loader_data->is_the_null_class_loader_data(), "Must be");
87
88 LogTarget(Trace, class, loader, data) lt;
89 if (lt.is_enabled()) {
90 ResourceMark rm;
91 LogStream ls(lt);
92 ls.print("create ");
93 _the_null_class_loader_data->print_value_on(&ls);
94 ls.cr();
95 }
96 }
|