669 // See "The Virtual Machine Specification" section 2.16.5 for a detailed explanation of the class initialization 670 // process. The step comments refers to the procedure described in that section. 671 // Note: implementation moved to static method to expose the this pointer. 672 void InstanceKlass::initialize(TRAPS) { 673 if (this->should_be_initialized()) { 674 initialize_impl(CHECK); 675 // Note: at this point the class may be initialized 676 // OR it may be in the state of being initialized 677 // in case of recursive initialization! 678 } else { 679 assert(is_initialized(), "sanity check"); 680 } 681 } 682 683 684 bool InstanceKlass::verify_code(TRAPS) { 685 // 1) Verify the bytecodes 686 return Verifier::verify(this, should_verify_class(), THREAD); 687 } 688 689 690 // Used exclusively by the shared spaces dump mechanism to prevent 691 // classes mapped into the shared regions in new VMs from appearing linked. 692 693 void InstanceKlass::unlink_class() { 694 assert(is_linked(), "must be linked"); 695 _init_state = loaded; 696 } 697 698 void InstanceKlass::link_class(TRAPS) { 699 assert(is_loaded(), "must be loaded"); 700 if (!is_linked()) { 701 link_class_impl(CHECK); 702 } 703 } 704 705 // Called to verify that a class can link during initialization, without 706 // throwing a VerifyError. 707 bool InstanceKlass::link_class_or_fail(TRAPS) { 708 assert(is_loaded(), "must be loaded"); 709 if (!is_linked()) { 710 link_class_impl(CHECK_false); 711 } 712 return is_linked(); 713 } 714 715 bool InstanceKlass::link_class_impl(TRAPS) { 716 if (DumpSharedSpaces && is_in_error_state()) { 717 // This is for CDS dumping phase only -- we use the in_error_state to indicate that 2283 } 2284 } 2285 } 2286 } 2287 2288 it->push(&_nest_members); 2289 } 2290 2291 void InstanceKlass::remove_unshareable_info() { 2292 Klass::remove_unshareable_info(); 2293 2294 if (is_in_error_state()) { 2295 // Classes are attempted to link during dumping and may fail, 2296 // but these classes are still in the dictionary and class list in CLD. 2297 // Check in_error state first because in_error is > linked state, so 2298 // is_linked() is true. 2299 // If there's a linking error, there is nothing else to remove. 2300 return; 2301 } 2302 2303 // Unlink the class 2304 if (is_linked()) { 2305 unlink_class(); 2306 } 2307 { 2308 MutexLocker ml(Compile_lock); 2309 init_implementor(); 2310 } 2311 2312 constants()->remove_unshareable_info(); 2313 2314 for (int i = 0; i < methods()->length(); i++) { 2315 Method* m = methods()->at(i); 2316 m->remove_unshareable_info(); 2317 } 2318 2319 // do array classes also. 2320 if (array_klasses() != NULL) { 2321 array_klasses()->remove_unshareable_info(); 2322 } 2323 2324 // These are not allocated from metaspace, but they should should all be empty 2325 // during dump time, so we don't need to worry about them in InstanceKlass::iterate(). 2326 guarantee(_source_debug_extension == NULL, "must be"); 2333 #endif 2334 2335 _init_thread = NULL; 2336 _methods_jmethod_ids = NULL; 2337 _jni_ids = NULL; 2338 _oop_map_cache = NULL; 2339 // clear _nest_host to ensure re-load at runtime 2340 _nest_host = NULL; 2341 } 2342 2343 void InstanceKlass::remove_java_mirror() { 2344 Klass::remove_java_mirror(); 2345 2346 // do array classes also. 2347 if (array_klasses() != NULL) { 2348 array_klasses()->remove_java_mirror(); 2349 } 2350 } 2351 2352 void InstanceKlass::restore_unshareable_info(ClassLoaderData* loader_data, Handle protection_domain, TRAPS) { 2353 set_package(loader_data, CHECK); 2354 Klass::restore_unshareable_info(loader_data, protection_domain, CHECK); 2355 2356 Array<Method*>* methods = this->methods(); 2357 int num_methods = methods->length(); 2358 for (int index2 = 0; index2 < num_methods; ++index2) { 2359 methodHandle m(THREAD, methods->at(index2)); 2360 m->restore_unshareable_info(CHECK); 2361 } 2362 if (JvmtiExport::has_redefined_a_class()) { 2363 // Reinitialize vtable because RedefineClasses may have changed some 2364 // entries in this vtable for super classes so the CDS vtable might 2365 // point to old or obsolete entries. RedefineClasses doesn't fix up 2366 // vtables in the shared system dictionary, only the main one. 2367 // It also redefines the itable too so fix that too. 2368 vtable().initialize_vtable(false, CHECK); 2369 itable().initialize_itable(false, CHECK); 2370 } 2371 2372 // restore constant pool resolved references | 669 // See "The Virtual Machine Specification" section 2.16.5 for a detailed explanation of the class initialization 670 // process. The step comments refers to the procedure described in that section. 671 // Note: implementation moved to static method to expose the this pointer. 672 void InstanceKlass::initialize(TRAPS) { 673 if (this->should_be_initialized()) { 674 initialize_impl(CHECK); 675 // Note: at this point the class may be initialized 676 // OR it may be in the state of being initialized 677 // in case of recursive initialization! 678 } else { 679 assert(is_initialized(), "sanity check"); 680 } 681 } 682 683 684 bool InstanceKlass::verify_code(TRAPS) { 685 // 1) Verify the bytecodes 686 return Verifier::verify(this, should_verify_class(), THREAD); 687 } 688 689 void InstanceKlass::link_class(TRAPS) { 690 assert(is_loaded(), "must be loaded"); 691 if (!is_linked()) { 692 link_class_impl(CHECK); 693 } 694 } 695 696 // Called to verify that a class can link during initialization, without 697 // throwing a VerifyError. 698 bool InstanceKlass::link_class_or_fail(TRAPS) { 699 assert(is_loaded(), "must be loaded"); 700 if (!is_linked()) { 701 link_class_impl(CHECK_false); 702 } 703 return is_linked(); 704 } 705 706 bool InstanceKlass::link_class_impl(TRAPS) { 707 if (DumpSharedSpaces && is_in_error_state()) { 708 // This is for CDS dumping phase only -- we use the in_error_state to indicate that 2274 } 2275 } 2276 } 2277 } 2278 2279 it->push(&_nest_members); 2280 } 2281 2282 void InstanceKlass::remove_unshareable_info() { 2283 Klass::remove_unshareable_info(); 2284 2285 if (is_in_error_state()) { 2286 // Classes are attempted to link during dumping and may fail, 2287 // but these classes are still in the dictionary and class list in CLD. 2288 // Check in_error state first because in_error is > linked state, so 2289 // is_linked() is true. 2290 // If there's a linking error, there is nothing else to remove. 2291 return; 2292 } 2293 2294 // Reset to the 'allocated' state to prevent any premature accessing to 2295 // a shared class at runtime while the class is still being loaded and 2296 // restored. A class' init_state is set to 'loaded' at runtime when it's 2297 // being added to class hierarchy (see SystemDictionary:::add_to_hierarchy()). 2298 _init_state = allocated; 2299 2300 { 2301 MutexLocker ml(Compile_lock); 2302 init_implementor(); 2303 } 2304 2305 constants()->remove_unshareable_info(); 2306 2307 for (int i = 0; i < methods()->length(); i++) { 2308 Method* m = methods()->at(i); 2309 m->remove_unshareable_info(); 2310 } 2311 2312 // do array classes also. 2313 if (array_klasses() != NULL) { 2314 array_klasses()->remove_unshareable_info(); 2315 } 2316 2317 // These are not allocated from metaspace, but they should should all be empty 2318 // during dump time, so we don't need to worry about them in InstanceKlass::iterate(). 2319 guarantee(_source_debug_extension == NULL, "must be"); 2326 #endif 2327 2328 _init_thread = NULL; 2329 _methods_jmethod_ids = NULL; 2330 _jni_ids = NULL; 2331 _oop_map_cache = NULL; 2332 // clear _nest_host to ensure re-load at runtime 2333 _nest_host = NULL; 2334 } 2335 2336 void InstanceKlass::remove_java_mirror() { 2337 Klass::remove_java_mirror(); 2338 2339 // do array classes also. 2340 if (array_klasses() != NULL) { 2341 array_klasses()->remove_java_mirror(); 2342 } 2343 } 2344 2345 void InstanceKlass::restore_unshareable_info(ClassLoaderData* loader_data, Handle protection_domain, TRAPS) { 2346 // SystemDictionary::add_to_hierarchy() sets the init_state to loaded 2347 // before the InstanceKlass is added to the SystemDictionary. Make 2348 // sure the current state is <loaded. 2349 assert(!is_loaded(), "invalid init state"); 2350 set_package(loader_data, CHECK); 2351 Klass::restore_unshareable_info(loader_data, protection_domain, CHECK); 2352 2353 Array<Method*>* methods = this->methods(); 2354 int num_methods = methods->length(); 2355 for (int index2 = 0; index2 < num_methods; ++index2) { 2356 methodHandle m(THREAD, methods->at(index2)); 2357 m->restore_unshareable_info(CHECK); 2358 } 2359 if (JvmtiExport::has_redefined_a_class()) { 2360 // Reinitialize vtable because RedefineClasses may have changed some 2361 // entries in this vtable for super classes so the CDS vtable might 2362 // point to old or obsolete entries. RedefineClasses doesn't fix up 2363 // vtables in the shared system dictionary, only the main one. 2364 // It also redefines the itable too so fix that too. 2365 vtable().initialize_vtable(false, CHECK); 2366 itable().initialize_itable(false, CHECK); 2367 } 2368 2369 // restore constant pool resolved references |