jdk8-mips64-public/hotspot: comparison src/share/vm/classfile/systemDictionary.cpp

-:c7a3e57fdf4a
+:b985cbb00e68
 #endif
 #include "classfile/vmSymbols.hpp"
 #include "compiler/compileBroker.hpp"
 #include "interpreter/bytecodeStream.hpp"
 #include "interpreter/interpreter.hpp"
+#include "jfr/jfrEvents.hpp"
 #include "memory/filemap.hpp"
 #include "memory/gcLocker.hpp"
 #include "memory/oopFactory.hpp"
 #include "oops/instanceKlass.hpp"
 #include "oops/instanceRefKlass.hpp"
 #include "runtime/signature.hpp"
 #include "services/classLoadingService.hpp"
 #include "services/threadService.hpp"
 #include "utilities/macros.hpp"
 #include "utilities/ticks.hpp"
-#if INCLUDE_TRACE
-#include "trace/tracing.hpp"
-#endif
 Dictionary*            SystemDictionary::_dictionary          = NULL;
 PlaceholderTable*      SystemDictionary::_placeholders        = NULL;
 Dictionary*            SystemDictionary::_shared_dictionary   = NULL;
 LoaderConstraintTable* SystemDictionary::_loader_constraints  = NULL;
 }
 }
 return (nh);
 }
+// utility function for class load event
+static void post_class_load_event(EventClassLoad &event,
+instanceKlassHandle k,
+Handle initiating_loader) {
+#if INCLUDE_JFR
+if (event.should_commit()) {
+event.set_loadedClass(k());
+event.set_definingClassLoader(k->class_loader_data());
+oop class_loader = initiating_loader.is_null() ? (oop)NULL : initiating_loader();
+event.set_initiatingClassLoader(class_loader != NULL ?
+ClassLoaderData::class_loader_data_or_null(class_loader) :
+(ClassLoaderData*)NULL);
+event.commit();
+}
+#endif // INCLUDE_JFR
+}
 Klass* SystemDictionary::resolve_instance_class_or_null(Symbol* name,
 Handle class_loader,
 Handle protection_domain,
 TRAPS) {
 assert(name != NULL && !FieldType::is_array(name) &&
 !FieldType::is_obj(name), "invalid class name");
-Ticks class_load_start_time = Ticks::now();
+EventClassLoad class_load_start_event;
 // UseNewReflection
 // Fix for 4474172; see evaluation for more details
 class_loader = Handle(THREAD, java_lang_ClassLoader::non_reflection_class_loader(class_loader()));
 ClassLoaderData *loader_data = register_loader(class_loader, CHECK_NULL);
 if (HAS_PENDING_EXCEPTION || k.is_null()) {
 return NULL;
 }
-post_class_load_event(class_load_start_time, k, class_loader);
+post_class_load_event(class_load_start_event, k, class_loader);
 #ifdef ASSERT
 {
 ClassLoaderData* loader_data = k->class_loader_data();
 MutexLocker mu(SystemDictionary_lock, THREAD);
 KlassHandle host_klass,
 GrowableArray<Handle>* cp_patches,
 TRAPS) {
 TempNewSymbol parsed_name = NULL;
-Ticks class_load_start_time = Ticks::now();
+EventClassLoad class_load_start_event;
 ClassLoaderData* loader_data;
 if (host_klass.not_null()) {
 // Create a new CLD for anonymous class, that uses the same class loader
 // as the host_klass
 if (JvmtiExport::should_post_class_load()) {
 assert(THREAD->is_Java_thread(), "thread->is_Java_thread()");
 JvmtiExport::post_class_load((JavaThread *) THREAD, k());
 }
-post_class_load_event(class_load_start_time, k, class_loader);
+post_class_load_event(class_load_start_event, k, class_loader);
 }
 assert(host_klass.not_null() || cp_patches == NULL,
 "cp_patches only found with host_klass");
 return k();
 // already be present in the SystemDictionary, otherwise we would not
 // throw potential ClassFormatErrors.
 //
 // Note: "name" is updated.
-instanceKlassHandle k = ClassFileParser(st).parseClassFile(class_name,
+ClassFileParser parser(st);
-loader_data,
+instanceKlassHandle k = parser.parseClassFile(class_name,
-protection_domain,
+loader_data,
-parsed_name,
+protection_domain,
-verify,
+parsed_name,
-THREAD);
+verify,
+THREAD);
 const char* pkg = "java/";
 size_t pkglen = strlen(pkg);
 if (!HAS_PENDING_EXCEPTION &&
 !class_loader.is_null() &&
 assert(class_name == NULL || class_name == parsed_name, "name mismatch");
 // Verification prevents us from creating names with dots in them, this
 // asserts that that's the case.
 assert(is_internal_format(parsed_name),
 "external class name format used internally");
+#if INCLUDE_JFR
+{
+InstanceKlass* ik = k();
+ON_KLASS_CREATION(ik, parser, THREAD);
+k = instanceKlassHandle(ik);
+}
+#endif
 // Add class just loaded
 // If a class loader supports parallel classloading handle parallel define requests
 // find_or_define_instance_class may return a different InstanceKlass
 if (is_parallelCapable(class_loader)) {
 // Class is not found or has the wrong name, return NULL
 return nh;
 }
 }
+static void post_class_define_event(InstanceKlass* k, const ClassLoaderData* def_cld) {
+EventClassDefine event;
+if (event.should_commit()) {
+event.set_definedClass(k);
+event.set_definingClassLoader(def_cld);
+event.commit();
+}
+}
 void SystemDictionary::define_instance_class(instanceKlassHandle k, TRAPS) {
 ClassLoaderData* loader_data = k->class_loader_data();
 Handle class_loader_h(THREAD, loader_data->class_loader());
 assert(THREAD->is_Java_thread(), "thread->is_Java_thread()");
 JvmtiExport::post_class_load((JavaThread *) THREAD, k());
 }
+post_class_define_event(k(), loader_data);
 }
 // Support parallel classloading
 // All parallel class loaders, including bootstrap classloader
 // lock a placeholder entry for this class/class_loader pair
 // Verify constraint table
 guarantee(constraints() != NULL, "Verify of loader constraints failed");
 constraints()->verify(dictionary(), placeholders());
 }
-// utility function for class load event
-void SystemDictionary::post_class_load_event(const Ticks& start_time,
-instanceKlassHandle k,
-Handle initiating_loader) {
-#if INCLUDE_TRACE
-EventClassLoad event(UNTIMED);
-if (event.should_commit()) {
-event.set_starttime(start_time);
-event.set_loadedClass(k());
-oop defining_class_loader = k->class_loader();
-event.set_definingClassLoader(defining_class_loader !=  NULL ?
-defining_class_loader->klass() : (Klass*)NULL);
-oop class_loader = initiating_loader.is_null() ? (oop)NULL : initiating_loader();
-event.set_initiatingClassLoader(class_loader != NULL ?
-class_loader->klass() : (Klass*)NULL);
-event.commit();
-}
-#endif // INCLUDE_TRACE
-}
 #ifndef PRODUCT
 // statistics code
 class ClassStatistics: AllStatic {
 private:

Mercurial > jdk8-mips64-public > hotspot / file comparison

comparison: src/share/vm/classfile/systemDictionary.cpp

src/share/vm/classfile/systemDictionary.cpp