47 // the singleton class the_null_class_loader_data().
  48 
  49 #include "precompiled.hpp"
  50 #include "classfile/classLoaderData.hpp"
  51 #include "classfile/classLoaderData.inline.hpp"
  52 #include "classfile/javaClasses.hpp"
  53 #include "classfile/metadataOnStackMark.hpp"
  54 #include "classfile/systemDictionary.hpp"
  55 #include "code/codeCache.hpp"
  56 #include "memory/gcLocker.hpp"
  57 #include "memory/metadataFactory.hpp"
  58 #include "memory/metaspaceShared.hpp"
  59 #include "memory/oopFactory.hpp"
  60 #include "runtime/jniHandles.hpp"
  61 #include "runtime/mutex.hpp"
  62 #include "runtime/safepoint.hpp"
  63 #include "runtime/synchronizer.hpp"
  64 #include "utilities/growableArray.hpp"
  65 #include "utilities/macros.hpp"
  66 #include "utilities/ostream.hpp"
  67 
  68 #if INCLUDE_TRACE
  69  #include "trace/tracing.hpp"
  70 #endif
  71 
  72 ClassLoaderData * ClassLoaderData::_the_null_class_loader_data = NULL;
  73 
  74 ClassLoaderData::ClassLoaderData(Handle h_class_loader, bool is_anonymous, Dependencies dependencies) :
  75   _class_loader(h_class_loader()),
  76   _is_anonymous(is_anonymous),
  77   // An anonymous class loader data doesn't have anything to keep
  78   // it from being unloaded during parsing of the anonymous class.
  79   // The null-class-loader should always be kept alive.
  80   _keep_alive(is_anonymous || h_class_loader.is_null()),
  81   _metaspace(NULL), _unloading(false), _klasses(NULL),
  82   _claimed(0), _jmethod_ids(NULL), _handles(NULL), _deallocate_list(NULL),
  83   _next(NULL), _dependencies(dependencies),
  84   _metaspace_lock(new Mutex(Monitor::leaf+1, "Metaspace allocation lock", true)) {
  85     // empty
  86 }
  87 
  88 void ClassLoaderData::init_dependencies(TRAPS) {
  89   assert(!Universe::is_fully_initialized(), "should only be called when initializing");

 967     class_loader()->print_value_on(out);
 968   }
 969 }
 970 
 971 #if INCLUDE_TRACE
 972 
 973 Ticks ClassLoaderDataGraph::_class_unload_time;
 974 
 975 void ClassLoaderDataGraph::class_unload_event(Klass* const k) {
 976 
 977   // post class unload event
 978   EventClassUnload event(UNTIMED);
 979   event.set_endtime(_class_unload_time);
 980   event.set_unloadedClass(k);
 981   oop defining_class_loader = k->class_loader();
 982   event.set_definingClassLoader(defining_class_loader != NULL ?
 983                                 defining_class_loader->klass() : (Klass*)NULL);
 984   event.commit();
 985 }
 986 
 987 #endif /* INCLUDE_TRACE */

  47 // the singleton class the_null_class_loader_data().
  48 
  49 #include "precompiled.hpp"
  50 #include "classfile/classLoaderData.hpp"
  51 #include "classfile/classLoaderData.inline.hpp"
  52 #include "classfile/javaClasses.hpp"
  53 #include "classfile/metadataOnStackMark.hpp"
  54 #include "classfile/systemDictionary.hpp"
  55 #include "code/codeCache.hpp"
  56 #include "memory/gcLocker.hpp"
  57 #include "memory/metadataFactory.hpp"
  58 #include "memory/metaspaceShared.hpp"
  59 #include "memory/oopFactory.hpp"
  60 #include "runtime/jniHandles.hpp"
  61 #include "runtime/mutex.hpp"
  62 #include "runtime/safepoint.hpp"
  63 #include "runtime/synchronizer.hpp"
  64 #include "utilities/growableArray.hpp"
  65 #include "utilities/macros.hpp"
  66 #include "utilities/ostream.hpp"

  67 #if INCLUDE_TRACE
  68 #include "trace/tracing.hpp"
  69 #endif
  70 
  71 ClassLoaderData * ClassLoaderData::_the_null_class_loader_data = NULL;
  72 
  73 ClassLoaderData::ClassLoaderData(Handle h_class_loader, bool is_anonymous, Dependencies dependencies) :
  74   _class_loader(h_class_loader()),
  75   _is_anonymous(is_anonymous),
  76   // An anonymous class loader data doesn't have anything to keep
  77   // it from being unloaded during parsing of the anonymous class.
  78   // The null-class-loader should always be kept alive.
  79   _keep_alive(is_anonymous || h_class_loader.is_null()),
  80   _metaspace(NULL), _unloading(false), _klasses(NULL),
  81   _claimed(0), _jmethod_ids(NULL), _handles(NULL), _deallocate_list(NULL),
  82   _next(NULL), _dependencies(dependencies),
  83   _metaspace_lock(new Mutex(Monitor::leaf+1, "Metaspace allocation lock", true)) {
  84     // empty
  85 }
  86 
  87 void ClassLoaderData::init_dependencies(TRAPS) {
  88   assert(!Universe::is_fully_initialized(), "should only be called when initializing");

 966     class_loader()->print_value_on(out);
 967   }
 968 }
 969 
 970 #if INCLUDE_TRACE
 971 
 972 Ticks ClassLoaderDataGraph::_class_unload_time;
 973 
 974 void ClassLoaderDataGraph::class_unload_event(Klass* const k) {
 975 
 976   // post class unload event
 977   EventClassUnload event(UNTIMED);
 978   event.set_endtime(_class_unload_time);
 979   event.set_unloadedClass(k);
 980   oop defining_class_loader = k->class_loader();
 981   event.set_definingClassLoader(defining_class_loader != NULL ?
 982                                 defining_class_loader->klass() : (Klass*)NULL);
 983   event.commit();
 984 }
 985 
 986 #endif // INCLUDE_TRACE