114 OopHandle Universe::_preallocated_out_of_memory_error_array;
115 volatile jint Universe::_preallocated_out_of_memory_error_avail_count = 0;
116
117 // Message details for OOME objects, preallocate these objects since they could be
118 // used when throwing OOME, we should try to avoid further allocation in such case
119 OopHandle Universe::_msg_metaspace;
120 OopHandle Universe::_msg_class_metaspace;
121
122 OopHandle Universe::_null_ptr_exception_instance;
123 OopHandle Universe::_arithmetic_exception_instance;
124 OopHandle Universe::_virtual_machine_error_instance;
125
126 OopHandle Universe::_reference_pending_list;
127
128 Array<Klass*>* Universe::_the_array_interfaces_array = NULL;
129 LatestMethodCache* Universe::_finalizer_register_cache = NULL;
130 LatestMethodCache* Universe::_loader_addClass_cache = NULL;
131 LatestMethodCache* Universe::_throw_illegal_access_error_cache = NULL;
132 LatestMethodCache* Universe::_throw_no_such_method_error_cache = NULL;
133 LatestMethodCache* Universe::_do_stack_walk_cache = NULL;
134
135 long Universe::verify_flags = Universe::Verify_All;
136
137 Array<int>* Universe::_the_empty_int_array = NULL;
138 Array<u2>* Universe::_the_empty_short_array = NULL;
139 Array<Klass*>* Universe::_the_empty_klass_array = NULL;
140 Array<InstanceKlass*>* Universe::_the_empty_instance_klass_array = NULL;
141 Array<Method*>* Universe::_the_empty_method_array = NULL;
142
143 // These variables are guarded by FullGCALot_lock.
144 debug_only(OopHandle Universe::_fullgc_alot_dummy_array;)
145 debug_only(int Universe::_fullgc_alot_dummy_next = 0;)
146
147 // Heap
148 int Universe::_verify_count = 0;
149
150 // Oop verification (see MacroAssembler::verify_oop)
151 uintptr_t Universe::_verify_oop_mask = 0;
152 uintptr_t Universe::_verify_oop_bits = (uintptr_t) -1;
153
217
218 void Universe::metaspace_pointers_do(MetaspaceClosure* it) {
219 it->push(&_fillerArrayKlassObj);
220 for (int i = 0; i < T_LONG+1; i++) {
221 it->push(&_typeArrayKlassObjs[i]);
222 }
223 it->push(&_objectArrayKlassObj);
224
225 it->push(&_the_empty_int_array);
226 it->push(&_the_empty_short_array);
227 it->push(&_the_empty_klass_array);
228 it->push(&_the_empty_instance_klass_array);
229 it->push(&_the_empty_method_array);
230 it->push(&_the_array_interfaces_array);
231
232 _finalizer_register_cache->metaspace_pointers_do(it);
233 _loader_addClass_cache->metaspace_pointers_do(it);
234 _throw_illegal_access_error_cache->metaspace_pointers_do(it);
235 _throw_no_such_method_error_cache->metaspace_pointers_do(it);
236 _do_stack_walk_cache->metaspace_pointers_do(it);
237 }
238
239 // Serialize metadata and pointers to primitive type mirrors in and out of CDS archive
240 void Universe::serialize(SerializeClosure* f) {
241
242 #if INCLUDE_CDS_JAVA_HEAP
243 {
244 oop mirror_oop;
245 for (int i = T_BOOLEAN; i < T_VOID+1; i++) {
246 if (f->reading()) {
247 f->do_oop(&mirror_oop); // read from archive
248 assert(oopDesc::is_oop_or_null(mirror_oop), "is oop");
249 // Only create an OopHandle for non-null mirrors
250 if (mirror_oop != NULL) {
251 _mirrors[i] = OopHandle(vm_global(), mirror_oop);
252 }
253 } else {
254 if (HeapShared::can_write()) {
255 mirror_oop = _mirrors[i].resolve();
256 } else {
265 }
266 #endif
267
268 f->do_ptr((void**)&_fillerArrayKlassObj);
269 for (int i = 0; i < T_LONG+1; i++) {
270 f->do_ptr((void**)&_typeArrayKlassObjs[i]);
271 }
272
273 f->do_ptr((void**)&_objectArrayKlassObj);
274 f->do_ptr((void**)&_the_array_interfaces_array);
275 f->do_ptr((void**)&_the_empty_int_array);
276 f->do_ptr((void**)&_the_empty_short_array);
277 f->do_ptr((void**)&_the_empty_method_array);
278 f->do_ptr((void**)&_the_empty_klass_array);
279 f->do_ptr((void**)&_the_empty_instance_klass_array);
280 _finalizer_register_cache->serialize(f);
281 _loader_addClass_cache->serialize(f);
282 _throw_illegal_access_error_cache->serialize(f);
283 _throw_no_such_method_error_cache->serialize(f);
284 _do_stack_walk_cache->serialize(f);
285 }
286
287
288 void Universe::check_alignment(uintx size, uintx alignment, const char* name) {
289 if (size < alignment || size % alignment != 0) {
290 vm_exit_during_initialization(
291 err_msg("Size of %s (" UINTX_FORMAT " bytes) must be aligned to " UINTX_FORMAT " bytes", name, size, alignment));
292 }
293 }
294
295 void initialize_basic_type_klass(Klass* k, TRAPS) {
296 Klass* ok = vmClasses::Object_klass();
297 #if INCLUDE_CDS
298 if (UseSharedSpaces) {
299 ClassLoaderData* loader_data = ClassLoaderData::the_null_class_loader_data();
300 assert(k->super() == ok, "u3");
301 if (k->is_instance_klass()) {
302 InstanceKlass::cast(k)->restore_unshareable_info(loader_data, Handle(), NULL, CHECK);
303 } else {
304 ArrayKlass::cast(k)->restore_unshareable_info(loader_data, Handle(), CHECK);
345 }
346
347 vmSymbols::initialize();
348
349 SystemDictionary::initialize(CHECK);
350
351 // Create string constants
352 oop s = StringTable::intern("null", CHECK);
353 _the_null_string = OopHandle(vm_global(), s);
354 s = StringTable::intern("-2147483648", CHECK);
355 _the_min_jint_string = OopHandle(vm_global(), s);
356
357
358 #if INCLUDE_CDS
359 if (UseSharedSpaces) {
360 // Verify shared interfaces array.
361 assert(_the_array_interfaces_array->at(0) ==
362 vmClasses::Cloneable_klass(), "u3");
363 assert(_the_array_interfaces_array->at(1) ==
364 vmClasses::Serializable_klass(), "u3");
365 } else
366 #endif
367 {
368 // Set up shared interfaces array. (Do this before supers are set up.)
369 _the_array_interfaces_array->at_put(0, vmClasses::Cloneable_klass());
370 _the_array_interfaces_array->at_put(1, vmClasses::Serializable_klass());
371 }
372
373 initialize_basic_type_klass(_fillerArrayKlassObj, CHECK);
374
375 initialize_basic_type_klass(boolArrayKlassObj(), CHECK);
376 initialize_basic_type_klass(charArrayKlassObj(), CHECK);
377 initialize_basic_type_klass(floatArrayKlassObj(), CHECK);
378 initialize_basic_type_klass(doubleArrayKlassObj(), CHECK);
379 initialize_basic_type_klass(byteArrayKlassObj(), CHECK);
380 initialize_basic_type_klass(shortArrayKlassObj(), CHECK);
381 initialize_basic_type_klass(intArrayKlassObj(), CHECK);
382 initialize_basic_type_klass(longArrayKlassObj(), CHECK);
383
384 assert(_fillerArrayKlassObj != intArrayKlassObj(),
759 TraceTime timer("Genesis", TRACETIME_LOG(Info, startuptime));
760
761 initialize_global_behaviours();
762
763 GCLogPrecious::initialize();
764
765 #ifdef _LP64
766 MetaspaceShared::adjust_heap_sizes_for_dumping();
767 #endif // _LP64
768
769 GCConfig::arguments()->initialize_heap_sizes();
770
771 jint status = Universe::initialize_heap();
772 if (status != JNI_OK) {
773 return status;
774 }
775
776 Universe::initialize_tlab();
777
778 Metaspace::global_initialize();
779
780 // Initialize performance counters for metaspaces
781 MetaspaceCounters::initialize_performance_counters();
782
783 // Checks 'AfterMemoryInit' constraints.
784 if (!JVMFlagLimit::check_all_constraints(JVMFlagConstraintPhase::AfterMemoryInit)) {
785 return JNI_EINVAL;
786 }
787
788 // Create memory for metadata. Must be after initializing heap for
789 // DumpSharedSpaces.
790 ClassLoaderData::init_null_class_loader_data();
791
792 // We have a heap so create the Method* caches before
793 // Metaspace::initialize_shared_spaces() tries to populate them.
794 Universe::_finalizer_register_cache = new LatestMethodCache();
795 Universe::_loader_addClass_cache = new LatestMethodCache();
796 Universe::_throw_illegal_access_error_cache = new LatestMethodCache();
797 Universe::_throw_no_such_method_error_cache = new LatestMethodCache();
798 Universe::_do_stack_walk_cache = new LatestMethodCache();
799
800 #if INCLUDE_CDS
801 DynamicArchive::check_for_dynamic_dump();
802 if (UseSharedSpaces) {
803 // Read the data structures supporting the shared spaces (shared
804 // system dictionary, symbol table, etc.). After that, access to
805 // the file (other than the mapped regions) is no longer needed, and
806 // the file is closed. Closing the file does not affect the
807 // currently mapped regions.
808 MetaspaceShared::initialize_shared_spaces();
809 StringTable::create_table();
810 if (ArchiveHeapLoader::is_loaded()) {
811 StringTable::transfer_shared_strings_to_local_table();
812 }
813 } else
814 #endif
815 {
816 SymbolTable::create_table();
817 StringTable::create_table();
818 }
946 vmClasses::internal_Unsafe_klass(),
947 "throwIllegalAccessError",
948 vmSymbols::void_method_signature(), true, CHECK);
949
950 initialize_known_method(_throw_no_such_method_error_cache,
951 vmClasses::internal_Unsafe_klass(),
952 "throwNoSuchMethodError",
953 vmSymbols::void_method_signature(), true, CHECK);
954
955 // Set up method for registering loaded classes in class loader vector
956 initialize_known_method(_loader_addClass_cache,
957 vmClasses::ClassLoader_klass(),
958 "addClass",
959 vmSymbols::class_void_signature(), false, CHECK);
960
961 // Set up method for stack walking
962 initialize_known_method(_do_stack_walk_cache,
963 vmClasses::AbstractStackWalker_klass(),
964 "doStackWalk",
965 vmSymbols::doStackWalk_signature(), false, CHECK);
966 }
967
968 void universe2_init() {
969 EXCEPTION_MARK;
970 Universe::genesis(CATCH);
971 }
972
973 // Set after initialization of the module runtime, call_initModuleRuntime
974 void universe_post_module_init() {
975 Universe::_module_initialized = true;
976 }
977
978 bool universe_post_init() {
979 assert(!is_init_completed(), "Error: initialization not yet completed!");
980 Universe::_fully_initialized = true;
981 EXCEPTION_MARK;
982 if (!UseSharedSpaces) {
983 reinitialize_vtables();
984 reinitialize_itables();
985 }
|
114 OopHandle Universe::_preallocated_out_of_memory_error_array;
115 volatile jint Universe::_preallocated_out_of_memory_error_avail_count = 0;
116
117 // Message details for OOME objects, preallocate these objects since they could be
118 // used when throwing OOME, we should try to avoid further allocation in such case
119 OopHandle Universe::_msg_metaspace;
120 OopHandle Universe::_msg_class_metaspace;
121
122 OopHandle Universe::_null_ptr_exception_instance;
123 OopHandle Universe::_arithmetic_exception_instance;
124 OopHandle Universe::_virtual_machine_error_instance;
125
126 OopHandle Universe::_reference_pending_list;
127
128 Array<Klass*>* Universe::_the_array_interfaces_array = NULL;
129 LatestMethodCache* Universe::_finalizer_register_cache = NULL;
130 LatestMethodCache* Universe::_loader_addClass_cache = NULL;
131 LatestMethodCache* Universe::_throw_illegal_access_error_cache = NULL;
132 LatestMethodCache* Universe::_throw_no_such_method_error_cache = NULL;
133 LatestMethodCache* Universe::_do_stack_walk_cache = NULL;
134 LatestMethodCache* Universe::_is_substitutable_cache = NULL;
135 LatestMethodCache* Universe::_primitive_type_hash_code_cache = NULL;
136
137 long Universe::verify_flags = Universe::Verify_All;
138
139 Array<int>* Universe::_the_empty_int_array = NULL;
140 Array<u2>* Universe::_the_empty_short_array = NULL;
141 Array<Klass*>* Universe::_the_empty_klass_array = NULL;
142 Array<InstanceKlass*>* Universe::_the_empty_instance_klass_array = NULL;
143 Array<Method*>* Universe::_the_empty_method_array = NULL;
144
145 // These variables are guarded by FullGCALot_lock.
146 debug_only(OopHandle Universe::_fullgc_alot_dummy_array;)
147 debug_only(int Universe::_fullgc_alot_dummy_next = 0;)
148
149 // Heap
150 int Universe::_verify_count = 0;
151
152 // Oop verification (see MacroAssembler::verify_oop)
153 uintptr_t Universe::_verify_oop_mask = 0;
154 uintptr_t Universe::_verify_oop_bits = (uintptr_t) -1;
155
219
220 void Universe::metaspace_pointers_do(MetaspaceClosure* it) {
221 it->push(&_fillerArrayKlassObj);
222 for (int i = 0; i < T_LONG+1; i++) {
223 it->push(&_typeArrayKlassObjs[i]);
224 }
225 it->push(&_objectArrayKlassObj);
226
227 it->push(&_the_empty_int_array);
228 it->push(&_the_empty_short_array);
229 it->push(&_the_empty_klass_array);
230 it->push(&_the_empty_instance_klass_array);
231 it->push(&_the_empty_method_array);
232 it->push(&_the_array_interfaces_array);
233
234 _finalizer_register_cache->metaspace_pointers_do(it);
235 _loader_addClass_cache->metaspace_pointers_do(it);
236 _throw_illegal_access_error_cache->metaspace_pointers_do(it);
237 _throw_no_such_method_error_cache->metaspace_pointers_do(it);
238 _do_stack_walk_cache->metaspace_pointers_do(it);
239 _is_substitutable_cache->metaspace_pointers_do(it);
240 _primitive_type_hash_code_cache->metaspace_pointers_do(it);
241 }
242
243 // Serialize metadata and pointers to primitive type mirrors in and out of CDS archive
244 void Universe::serialize(SerializeClosure* f) {
245
246 #if INCLUDE_CDS_JAVA_HEAP
247 {
248 oop mirror_oop;
249 for (int i = T_BOOLEAN; i < T_VOID+1; i++) {
250 if (f->reading()) {
251 f->do_oop(&mirror_oop); // read from archive
252 assert(oopDesc::is_oop_or_null(mirror_oop), "is oop");
253 // Only create an OopHandle for non-null mirrors
254 if (mirror_oop != NULL) {
255 _mirrors[i] = OopHandle(vm_global(), mirror_oop);
256 }
257 } else {
258 if (HeapShared::can_write()) {
259 mirror_oop = _mirrors[i].resolve();
260 } else {
269 }
270 #endif
271
272 f->do_ptr((void**)&_fillerArrayKlassObj);
273 for (int i = 0; i < T_LONG+1; i++) {
274 f->do_ptr((void**)&_typeArrayKlassObjs[i]);
275 }
276
277 f->do_ptr((void**)&_objectArrayKlassObj);
278 f->do_ptr((void**)&_the_array_interfaces_array);
279 f->do_ptr((void**)&_the_empty_int_array);
280 f->do_ptr((void**)&_the_empty_short_array);
281 f->do_ptr((void**)&_the_empty_method_array);
282 f->do_ptr((void**)&_the_empty_klass_array);
283 f->do_ptr((void**)&_the_empty_instance_klass_array);
284 _finalizer_register_cache->serialize(f);
285 _loader_addClass_cache->serialize(f);
286 _throw_illegal_access_error_cache->serialize(f);
287 _throw_no_such_method_error_cache->serialize(f);
288 _do_stack_walk_cache->serialize(f);
289 _is_substitutable_cache->serialize(f);
290 _primitive_type_hash_code_cache->serialize(f);
291 }
292
293
294 void Universe::check_alignment(uintx size, uintx alignment, const char* name) {
295 if (size < alignment || size % alignment != 0) {
296 vm_exit_during_initialization(
297 err_msg("Size of %s (" UINTX_FORMAT " bytes) must be aligned to " UINTX_FORMAT " bytes", name, size, alignment));
298 }
299 }
300
301 void initialize_basic_type_klass(Klass* k, TRAPS) {
302 Klass* ok = vmClasses::Object_klass();
303 #if INCLUDE_CDS
304 if (UseSharedSpaces) {
305 ClassLoaderData* loader_data = ClassLoaderData::the_null_class_loader_data();
306 assert(k->super() == ok, "u3");
307 if (k->is_instance_klass()) {
308 InstanceKlass::cast(k)->restore_unshareable_info(loader_data, Handle(), NULL, CHECK);
309 } else {
310 ArrayKlass::cast(k)->restore_unshareable_info(loader_data, Handle(), CHECK);
351 }
352
353 vmSymbols::initialize();
354
355 SystemDictionary::initialize(CHECK);
356
357 // Create string constants
358 oop s = StringTable::intern("null", CHECK);
359 _the_null_string = OopHandle(vm_global(), s);
360 s = StringTable::intern("-2147483648", CHECK);
361 _the_min_jint_string = OopHandle(vm_global(), s);
362
363
364 #if INCLUDE_CDS
365 if (UseSharedSpaces) {
366 // Verify shared interfaces array.
367 assert(_the_array_interfaces_array->at(0) ==
368 vmClasses::Cloneable_klass(), "u3");
369 assert(_the_array_interfaces_array->at(1) ==
370 vmClasses::Serializable_klass(), "u3");
371
372 } else
373 #endif
374 {
375 // Set up shared interfaces array. (Do this before supers are set up.)
376 _the_array_interfaces_array->at_put(0, vmClasses::Cloneable_klass());
377 _the_array_interfaces_array->at_put(1, vmClasses::Serializable_klass());
378 }
379
380 initialize_basic_type_klass(_fillerArrayKlassObj, CHECK);
381
382 initialize_basic_type_klass(boolArrayKlassObj(), CHECK);
383 initialize_basic_type_klass(charArrayKlassObj(), CHECK);
384 initialize_basic_type_klass(floatArrayKlassObj(), CHECK);
385 initialize_basic_type_klass(doubleArrayKlassObj(), CHECK);
386 initialize_basic_type_klass(byteArrayKlassObj(), CHECK);
387 initialize_basic_type_klass(shortArrayKlassObj(), CHECK);
388 initialize_basic_type_klass(intArrayKlassObj(), CHECK);
389 initialize_basic_type_klass(longArrayKlassObj(), CHECK);
390
391 assert(_fillerArrayKlassObj != intArrayKlassObj(),
766 TraceTime timer("Genesis", TRACETIME_LOG(Info, startuptime));
767
768 initialize_global_behaviours();
769
770 GCLogPrecious::initialize();
771
772 #ifdef _LP64
773 MetaspaceShared::adjust_heap_sizes_for_dumping();
774 #endif // _LP64
775
776 GCConfig::arguments()->initialize_heap_sizes();
777
778 jint status = Universe::initialize_heap();
779 if (status != JNI_OK) {
780 return status;
781 }
782
783 Universe::initialize_tlab();
784
785 Metaspace::global_initialize();
786 // Initialize performance counters for metaspaces
787 MetaspaceCounters::initialize_performance_counters();
788
789 // Checks 'AfterMemoryInit' constraints.
790 if (!JVMFlagLimit::check_all_constraints(JVMFlagConstraintPhase::AfterMemoryInit)) {
791 return JNI_EINVAL;
792 }
793
794 // Create memory for metadata. Must be after initializing heap for
795 // DumpSharedSpaces.
796 ClassLoaderData::init_null_class_loader_data();
797
798 // We have a heap so create the Method* caches before
799 // Metaspace::initialize_shared_spaces() tries to populate them.
800 Universe::_finalizer_register_cache = new LatestMethodCache();
801 Universe::_loader_addClass_cache = new LatestMethodCache();
802 Universe::_throw_illegal_access_error_cache = new LatestMethodCache();
803 Universe::_throw_no_such_method_error_cache = new LatestMethodCache();
804 Universe::_do_stack_walk_cache = new LatestMethodCache();
805 Universe::_is_substitutable_cache = new LatestMethodCache();
806 Universe::_primitive_type_hash_code_cache = new LatestMethodCache();
807
808 #if INCLUDE_CDS
809 DynamicArchive::check_for_dynamic_dump();
810 if (UseSharedSpaces) {
811 // Read the data structures supporting the shared spaces (shared
812 // system dictionary, symbol table, etc.). After that, access to
813 // the file (other than the mapped regions) is no longer needed, and
814 // the file is closed. Closing the file does not affect the
815 // currently mapped regions.
816 MetaspaceShared::initialize_shared_spaces();
817 StringTable::create_table();
818 if (ArchiveHeapLoader::is_loaded()) {
819 StringTable::transfer_shared_strings_to_local_table();
820 }
821 } else
822 #endif
823 {
824 SymbolTable::create_table();
825 StringTable::create_table();
826 }
954 vmClasses::internal_Unsafe_klass(),
955 "throwIllegalAccessError",
956 vmSymbols::void_method_signature(), true, CHECK);
957
958 initialize_known_method(_throw_no_such_method_error_cache,
959 vmClasses::internal_Unsafe_klass(),
960 "throwNoSuchMethodError",
961 vmSymbols::void_method_signature(), true, CHECK);
962
963 // Set up method for registering loaded classes in class loader vector
964 initialize_known_method(_loader_addClass_cache,
965 vmClasses::ClassLoader_klass(),
966 "addClass",
967 vmSymbols::class_void_signature(), false, CHECK);
968
969 // Set up method for stack walking
970 initialize_known_method(_do_stack_walk_cache,
971 vmClasses::AbstractStackWalker_klass(),
972 "doStackWalk",
973 vmSymbols::doStackWalk_signature(), false, CHECK);
974
975 // Set up substitutability testing
976 ResourceMark rm;
977 initialize_known_method(_is_substitutable_cache,
978 vmClasses::PrimitiveObjectMethods_klass(),
979 vmSymbols::isSubstitutable_name()->as_C_string(),
980 vmSymbols::object_object_boolean_signature(), true, CHECK);
981 initialize_known_method(_primitive_type_hash_code_cache,
982 vmClasses::PrimitiveObjectMethods_klass(),
983 vmSymbols::primitiveObjectHashCode_name()->as_C_string(),
984 vmSymbols::object_int_signature(), true, CHECK);
985 }
986
987 void universe2_init() {
988 EXCEPTION_MARK;
989 Universe::genesis(CATCH);
990 }
991
992 // Set after initialization of the module runtime, call_initModuleRuntime
993 void universe_post_module_init() {
994 Universe::_module_initialized = true;
995 }
996
997 bool universe_post_init() {
998 assert(!is_init_completed(), "Error: initialization not yet completed!");
999 Universe::_fully_initialized = true;
1000 EXCEPTION_MARK;
1001 if (!UseSharedSpaces) {
1002 reinitialize_vtables();
1003 reinitialize_itables();
1004 }
|