58 #include "code/codeCache.hpp" 59 #include "gc/shared/gcLocker.hpp" 60 #include "logging/log.hpp" 61 #include "logging/logStream.hpp" 62 #include "memory/metadataFactory.hpp" 63 #include "memory/metaspaceShared.hpp" 64 #include "memory/oopFactory.hpp" 65 #include "memory/resourceArea.hpp" 66 #include "oops/objArrayOop.inline.hpp" 67 #include "oops/oop.inline.hpp" 68 #include "runtime/atomic.hpp" 69 #include "runtime/javaCalls.hpp" 70 #include "runtime/jniHandles.hpp" 71 #include "runtime/mutex.hpp" 72 #include "runtime/orderAccess.hpp" 73 #include "runtime/safepoint.hpp" 74 #include "runtime/synchronizer.hpp" 75 #include "utilities/growableArray.hpp" 76 #include "utilities/macros.hpp" 77 #include "utilities/ostream.hpp" 78 #if INCLUDE_TRACE 79 #include "trace/tracing.hpp" 80 #endif 81 82 // helper function to avoid in-line casts 83 template <typename T> static T* load_ptr_acquire(T* volatile *p) { 84 return static_cast<T*>(OrderAccess::load_ptr_acquire(p)); 85 } 86 87 ClassLoaderData * ClassLoaderData::_the_null_class_loader_data = NULL; 88 89 ClassLoaderData::ClassLoaderData(Handle h_class_loader, bool is_anonymous, Dependencies dependencies) : 90 _class_loader(h_class_loader()), 91 _is_anonymous(is_anonymous), 92 // An anonymous class loader data doesn't have anything to keep 93 // it from being unloaded during parsing of the anonymous class. 94 // The null-class-loader should always be kept alive. 95 _keep_alive((is_anonymous || h_class_loader.is_null()) ? 1 : 0), 96 _metaspace(NULL), _unloading(false), _klasses(NULL), 97 _modules(NULL), _packages(NULL), 745 } 746 metaspace = new Metaspace(_metaspace_lock, Metaspace::AnonymousMetaspaceType); 747 } else if (class_loader()->is_a(SystemDictionary::reflect_DelegatingClassLoader_klass())) { 748 if (class_loader() != NULL) { 749 log_trace(class, loader, data)("is_reflection: %s", class_loader()->klass()->internal_name()); 750 } 751 metaspace = new Metaspace(_metaspace_lock, Metaspace::ReflectionMetaspaceType); 752 } else { 753 metaspace = new Metaspace(_metaspace_lock, Metaspace::StandardMetaspaceType); 754 } 755 // Ensure _metaspace is stable, since it is examined without a lock 756 OrderAccess::release_store_ptr(&_metaspace, metaspace); 757 } 758 } 759 return metaspace; 760 } 761 762 OopHandle ClassLoaderData::add_handle(Handle h) { 763 MutexLockerEx ml(metaspace_lock(), Mutex::_no_safepoint_check_flag); 764 return OopHandle(_handles.add(h())); 765 } 766 767 void ClassLoaderData::init_handle_locked(OopHandle& dest, Handle h) { 768 MutexLockerEx ml(metaspace_lock(), Mutex::_no_safepoint_check_flag); 769 if (dest.resolve() != NULL) { 770 return; 771 } else { 772 dest = _handles.add(h()); 773 } 774 } 775 776 // Add this metadata pointer to be freed when it's safe. This is only during 777 // class unloading because Handles might point to this metadata field. 778 void ClassLoaderData::add_to_deallocate_list(Metadata* m) { 779 // Metadata in shared region isn't deleted. 780 if (!m->is_shared()) { 781 MutexLockerEx ml(metaspace_lock(), Mutex::_no_safepoint_check_flag); 782 if (_deallocate_list == NULL) { 783 _deallocate_list = new (ResourceObj::C_HEAP, mtClass) GrowableArray<Metadata*>(100, true); 784 } | 58 #include "code/codeCache.hpp" 59 #include "gc/shared/gcLocker.hpp" 60 #include "logging/log.hpp" 61 #include "logging/logStream.hpp" 62 #include "memory/metadataFactory.hpp" 63 #include "memory/metaspaceShared.hpp" 64 #include "memory/oopFactory.hpp" 65 #include "memory/resourceArea.hpp" 66 #include "oops/objArrayOop.inline.hpp" 67 #include "oops/oop.inline.hpp" 68 #include "runtime/atomic.hpp" 69 #include "runtime/javaCalls.hpp" 70 #include "runtime/jniHandles.hpp" 71 #include "runtime/mutex.hpp" 72 #include "runtime/orderAccess.hpp" 73 #include "runtime/safepoint.hpp" 74 #include "runtime/synchronizer.hpp" 75 #include "utilities/growableArray.hpp" 76 #include "utilities/macros.hpp" 77 #include "utilities/ostream.hpp" 78 #if INCLUDE_ALL_GCS 79 #include "gc/g1/g1SATBCardTableModRefBS.hpp" 80 #endif // INCLUDE_ALL_GCS 81 #if INCLUDE_TRACE 82 #include "trace/tracing.hpp" 83 #endif 84 85 // helper function to avoid in-line casts 86 template <typename T> static T* load_ptr_acquire(T* volatile *p) { 87 return static_cast<T*>(OrderAccess::load_ptr_acquire(p)); 88 } 89 90 ClassLoaderData * ClassLoaderData::_the_null_class_loader_data = NULL; 91 92 ClassLoaderData::ClassLoaderData(Handle h_class_loader, bool is_anonymous, Dependencies dependencies) : 93 _class_loader(h_class_loader()), 94 _is_anonymous(is_anonymous), 95 // An anonymous class loader data doesn't have anything to keep 96 // it from being unloaded during parsing of the anonymous class. 97 // The null-class-loader should always be kept alive. 98 _keep_alive((is_anonymous || h_class_loader.is_null()) ? 1 : 0), 99 _metaspace(NULL), _unloading(false), _klasses(NULL), 100 _modules(NULL), _packages(NULL), 748 } 749 metaspace = new Metaspace(_metaspace_lock, Metaspace::AnonymousMetaspaceType); 750 } else if (class_loader()->is_a(SystemDictionary::reflect_DelegatingClassLoader_klass())) { 751 if (class_loader() != NULL) { 752 log_trace(class, loader, data)("is_reflection: %s", class_loader()->klass()->internal_name()); 753 } 754 metaspace = new Metaspace(_metaspace_lock, Metaspace::ReflectionMetaspaceType); 755 } else { 756 metaspace = new Metaspace(_metaspace_lock, Metaspace::StandardMetaspaceType); 757 } 758 // Ensure _metaspace is stable, since it is examined without a lock 759 OrderAccess::release_store_ptr(&_metaspace, metaspace); 760 } 761 } 762 return metaspace; 763 } 764 765 OopHandle ClassLoaderData::add_handle(Handle h) { 766 MutexLockerEx ml(metaspace_lock(), Mutex::_no_safepoint_check_flag); 767 return OopHandle(_handles.add(h())); 768 } 769 770 void ClassLoaderData::remove_handle(OopHandle h) { 771 oop* ptr = h.ptr_raw(); 772 if (ptr != NULL) { 773 assert(_handles.contains(ptr), "Got unexpected handle " PTR_FORMAT, p2i(ptr)); 774 #if INCLUDE_ALL_GCS 775 // This barrier is used by G1 to remember the old oop values, so 776 // that we don't forget any objects that were live at the snapshot at 777 // the beginning. 778 if (UseG1GC) { 779 oop obj = *ptr; 780 if (obj != NULL) { 781 G1SATBCardTableModRefBS::enqueue(obj); 782 } 783 } 784 #endif 785 *ptr = NULL; 786 } 787 } 788 789 void ClassLoaderData::init_handle_locked(OopHandle& dest, Handle h) { 790 MutexLockerEx ml(metaspace_lock(), Mutex::_no_safepoint_check_flag); 791 if (dest.resolve() != NULL) { 792 return; 793 } else { 794 dest = _handles.add(h()); 795 } 796 } 797 798 // Add this metadata pointer to be freed when it's safe. This is only during 799 // class unloading because Handles might point to this metadata field. 800 void ClassLoaderData::add_to_deallocate_list(Metadata* m) { 801 // Metadata in shared region isn't deleted. 802 if (!m->is_shared()) { 803 MutexLockerEx ml(metaspace_lock(), Mutex::_no_safepoint_check_flag); 804 if (_deallocate_list == NULL) { 805 _deallocate_list = new (ResourceObj::C_HEAP, mtClass) GrowableArray<Metadata*>(100, true); 806 } |