167 }
168
169 void SystemDictionary::compute_java_loaders(TRAPS) {
170 JavaValue result(T_OBJECT);
171 InstanceKlass* class_loader_klass = SystemDictionary::ClassLoader_klass();
172 JavaCalls::call_static(&result,
173 class_loader_klass,
174 vmSymbols::getSystemClassLoader_name(),
175 vmSymbols::void_classloader_signature(),
176 CHECK);
177
178 _java_system_loader = OopHandle(Universe::vm_global(), (oop)result.get_jobject());
179
180 JavaCalls::call_static(&result,
181 class_loader_klass,
182 vmSymbols::getPlatformClassLoader_name(),
183 vmSymbols::void_classloader_signature(),
184 CHECK);
185
186 _java_platform_loader = OopHandle(Universe::vm_global(), (oop)result.get_jobject());
187 }
188
189 ClassLoaderData* SystemDictionary::register_loader(Handle class_loader, bool create_mirror_cld) {
190 if (create_mirror_cld) {
191 // Add a new class loader data to the graph.
192 return ClassLoaderDataGraph::add(class_loader, true);
193 } else {
194 return (class_loader() == NULL) ? ClassLoaderData::the_null_class_loader_data() :
195 ClassLoaderDataGraph::find_or_create(class_loader);
196 }
197 }
198
199 // ----------------------------------------------------------------------------
200 // Parallel class loading check
201
202 bool SystemDictionary::is_parallelCapable(Handle class_loader) {
203 if (class_loader.is_null()) return true;
204 if (AlwaysLockClassLoader) return false;
205 return java_lang_ClassLoader::parallelCapable(class_loader());
206 }
2104 WKID scan = FIRST_WKID;
2105 // first do Object, then String, Class
2106 #if INCLUDE_CDS
2107 if (UseSharedSpaces) {
2108 resolve_wk_klasses_through(WK_KLASS_ENUM_NAME(Object_klass), scan, CHECK);
2109
2110 // It's unsafe to access the archived heap regions before they
2111 // are fixed up, so we must do the fixup as early as possible
2112 // before the archived java objects are accessed by functions
2113 // such as java_lang_Class::restore_archived_mirror and
2114 // ConstantPool::restore_unshareable_info (restores the archived
2115 // resolved_references array object).
2116 //
2117 // HeapShared::fixup_mapped_heap_regions() fills the empty
2118 // spaces in the archived heap regions and may use
2119 // SystemDictionary::Object_klass(), so we can do this only after
2120 // Object_klass is resolved. See the above resolve_wk_klasses_through()
2121 // call. No mirror objects are accessed/restored in the above call.
2122 // Mirrors are restored after java.lang.Class is loaded.
2123 HeapShared::fixup_mapped_heap_regions();
2124
2125 // Initialize the constant pool for the Object_class
2126 assert(Object_klass()->is_shared(), "must be");
2127 Object_klass()->constants()->restore_unshareable_info(CHECK);
2128 resolve_wk_klasses_through(WK_KLASS_ENUM_NAME(Class_klass), scan, CHECK);
2129 } else
2130 #endif
2131 {
2132 resolve_wk_klasses_through(WK_KLASS_ENUM_NAME(Class_klass), scan, CHECK);
2133 }
2134
2135 assert(WK_KLASS(Object_klass) != NULL, "well-known classes should now be initialized");
2136
2137 java_lang_Object::register_natives(CHECK);
2138
2139 // Calculate offsets for String and Class classes since they are loaded and
2140 // can be used after this point.
2141 java_lang_String::compute_offsets();
2142 java_lang_Class::compute_offsets();
2143
|
167 }
168
169 void SystemDictionary::compute_java_loaders(TRAPS) {
170 JavaValue result(T_OBJECT);
171 InstanceKlass* class_loader_klass = SystemDictionary::ClassLoader_klass();
172 JavaCalls::call_static(&result,
173 class_loader_klass,
174 vmSymbols::getSystemClassLoader_name(),
175 vmSymbols::void_classloader_signature(),
176 CHECK);
177
178 _java_system_loader = OopHandle(Universe::vm_global(), (oop)result.get_jobject());
179
180 JavaCalls::call_static(&result,
181 class_loader_klass,
182 vmSymbols::getPlatformClassLoader_name(),
183 vmSymbols::void_classloader_signature(),
184 CHECK);
185
186 _java_platform_loader = OopHandle(Universe::vm_global(), (oop)result.get_jobject());
187
188 #if INCLUDE_CDS_JAVA_HEAP
189 if (UseSharedSpaces && MetaspaceShared::use_full_module_graph()) {
190 Handle platform_loader(THREAD, java_platform_loader());
191 register_loader(platform_loader)->restore_java_platform_loader_from_archive();
192
193 Handle system_loader(THREAD, java_system_loader());
194 register_loader(system_loader)->restore_java_system_loader_from_archive();
195 }
196 #endif
197 }
198
199 ClassLoaderData* SystemDictionary::register_loader(Handle class_loader, bool create_mirror_cld) {
200 if (create_mirror_cld) {
201 // Add a new class loader data to the graph.
202 return ClassLoaderDataGraph::add(class_loader, true);
203 } else {
204 return (class_loader() == NULL) ? ClassLoaderData::the_null_class_loader_data() :
205 ClassLoaderDataGraph::find_or_create(class_loader);
206 }
207 }
208
209 // ----------------------------------------------------------------------------
210 // Parallel class loading check
211
212 bool SystemDictionary::is_parallelCapable(Handle class_loader) {
213 if (class_loader.is_null()) return true;
214 if (AlwaysLockClassLoader) return false;
215 return java_lang_ClassLoader::parallelCapable(class_loader());
216 }
2114 WKID scan = FIRST_WKID;
2115 // first do Object, then String, Class
2116 #if INCLUDE_CDS
2117 if (UseSharedSpaces) {
2118 resolve_wk_klasses_through(WK_KLASS_ENUM_NAME(Object_klass), scan, CHECK);
2119
2120 // It's unsafe to access the archived heap regions before they
2121 // are fixed up, so we must do the fixup as early as possible
2122 // before the archived java objects are accessed by functions
2123 // such as java_lang_Class::restore_archived_mirror and
2124 // ConstantPool::restore_unshareable_info (restores the archived
2125 // resolved_references array object).
2126 //
2127 // HeapShared::fixup_mapped_heap_regions() fills the empty
2128 // spaces in the archived heap regions and may use
2129 // SystemDictionary::Object_klass(), so we can do this only after
2130 // Object_klass is resolved. See the above resolve_wk_klasses_through()
2131 // call. No mirror objects are accessed/restored in the above call.
2132 // Mirrors are restored after java.lang.Class is loaded.
2133 HeapShared::fixup_mapped_heap_regions();
2134 CDS_JAVA_HEAP_ONLY(ClassLoaderData::restore_archived_oops_for_null_class_loader_data());
2135
2136 // Initialize the constant pool for the Object_class
2137 assert(Object_klass()->is_shared(), "must be");
2138 Object_klass()->constants()->restore_unshareable_info(CHECK);
2139 resolve_wk_klasses_through(WK_KLASS_ENUM_NAME(Class_klass), scan, CHECK);
2140 } else
2141 #endif
2142 {
2143 resolve_wk_klasses_through(WK_KLASS_ENUM_NAME(Class_klass), scan, CHECK);
2144 }
2145
2146 assert(WK_KLASS(Object_klass) != NULL, "well-known classes should now be initialized");
2147
2148 java_lang_Object::register_natives(CHECK);
2149
2150 // Calculate offsets for String and Class classes since they are loaded and
2151 // can be used after this point.
2152 java_lang_String::compute_offsets();
2153 java_lang_Class::compute_offsets();
2154
|