< prev index next >

src/hotspot/share/memory/universe.cpp

Print this page

 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   }
< prev index next >