8365400: Enhance JFR to emit file and module metadata for class loading

Reviewed-by: coleenp, egahlin

Author: Markus Grönlund

src/hotspot/share/cds/lambdaProxyClassDictionary.cpp

@@ -357,7 +357,7 @@ InstanceKlass* LambdaProxyClassDictionary::load_and_init_lambda_proxy_class(Inst
   InstanceKlass* nest_host = caller_ik->nest_host(THREAD);
   assert(nest_host == shared_nest_host, "mismatched nest host");
 
-  EventClassLoad class_load_start_event;
+  EventClassLoad class_load_event;
 
   // Add to class hierarchy, and do possible deoptimizations.
   lambda_ik->add_to_hierarchy(THREAD);
@@ -368,8 +368,8 @@ InstanceKlass* LambdaProxyClassDictionary::load_and_init_lambda_proxy_class(Inst
   if (JvmtiExport::should_post_class_load()) {
     JvmtiExport::post_class_load(THREAD, lambda_ik);
   }
-  if (class_load_start_event.should_commit()) {
-    SystemDictionary::post_class_load_event(&class_load_start_event, lambda_ik, ClassLoaderData::class_loader_data(class_loader()));
+  if (class_load_event.should_commit()) {
+    JFR_ONLY(SystemDictionary::post_class_load_event(&class_load_event, lambda_ik, ClassLoaderData::class_loader_data(class_loader()));)
   }
 
   lambda_ik->initialize(CHECK_NULL);

src/hotspot/share/classfile/classFileParser.cpp

@@ -89,9 +89,6 @@
 #if INCLUDE_CDS
 #include "classfile/systemDictionaryShared.hpp"
 #endif
-#if INCLUDE_JFR
-#include "jfr/support/jfrTraceIdExtension.hpp"
-#endif
 
 // We generally try to create the oops directly when parsing, rather than
 // allocating temporary data structures and copying the bytes twice. A
@@ -5272,8 +5269,6 @@ void ClassFileParser::fill_instance_klass(InstanceKlass* ik,
     }
   }
 
-  JFR_ONLY(INIT_ID(ik);)
-
   // If we reach here, all is well.
   // Now remove the InstanceKlass* from the _klass_to_deallocate field
   // in order for it to not be destroyed in the ClassFileParser destructor.

src/hotspot/share/classfile/classFileParser.hpp

@@ -500,6 +500,8 @@ class ClassFileParser {
 
   InstanceKlass* create_instance_klass(bool cf_changed_in_CFLH, const ClassInstanceInfo& cl_inst_info, TRAPS);
 
+  const ClassFileStream& stream() const { return *_stream; }
+
   const ClassFileStream* clone_stream() const;
 
   void set_klass_to_deallocate(InstanceKlass* klass);

src/hotspot/share/classfile/klassFactory.cpp

@@ -37,7 +37,7 @@
 #include "runtime/handles.inline.hpp"
 #include "utilities/macros.hpp"
 #if INCLUDE_JFR
-#include "jfr/support/jfrKlassExtension.hpp"
+#include "jfr/jfr.hpp"
 #endif
 
 
@@ -99,6 +99,9 @@ InstanceKlass* KlassFactory::check_shared_class_file_load_hook(
         new_ik->set_classpath_index(path_index);
       }
 
+
+      JFR_ONLY(Jfr::on_klass_creation(new_ik, parser, THREAD);)
+
       return new_ik;
     }
   }
@@ -213,7 +216,7 @@ InstanceKlass* KlassFactory::create_from_stream(ClassFileStream* stream,
     result->set_cached_class_file(cached_class_file);
   }
 
-  JFR_ONLY(ON_KLASS_CREATION(result, parser, THREAD);)
+  JFR_ONLY(Jfr::on_klass_creation(result, parser, THREAD);)
 
 #if INCLUDE_CDS
   if (CDSConfig::is_dumping_archive()) {

src/hotspot/share/classfile/systemDictionary.cpp

@@ -560,15 +560,6 @@ static InstanceKlass* handle_parallel_loading(JavaThread* current,
   return nullptr;
 }
 
-void SystemDictionary::post_class_load_event(EventClassLoad* event, const InstanceKlass* k, const ClassLoaderData* init_cld) {
-  assert(event != nullptr, "invariant");
-  assert(k != nullptr, "invariant");
-  event->set_loadedClass(k);
-  event->set_definingClassLoader(k->class_loader_data());
-  event->set_initiatingClassLoader(init_cld);
-  event->commit();
-}
-
 // SystemDictionary::resolve_instance_class_or_null is the main function for class name resolution.
 // After checking if the InstanceKlass already exists, it checks for ClassCircularityError and
 // whether the thread must wait for loading in parallel.  It eventually calls load_instance_class,
@@ -582,7 +573,7 @@ InstanceKlass* SystemDictionary::resolve_instance_class_or_null(Symbol* name,
   assert(name != nullptr && !Signature::is_array(name) &&
          !Signature::has_envelope(name), "invalid class name: %s", name == nullptr ? "nullptr" : name->as_C_string());
 
-  EventClassLoad class_load_start_event;
+  EventClassLoad class_load_event;
 
   HandleMark hm(THREAD);
 
@@ -713,8 +704,8 @@ InstanceKlass* SystemDictionary::resolve_instance_class_or_null(Symbol* name,
     return nullptr;
   }
 
-  if (class_load_start_event.should_commit()) {
-    post_class_load_event(&class_load_start_event, loaded_class, loader_data);
+  if (class_load_event.should_commit()) {
+    JFR_ONLY(post_class_load_event(&class_load_event, loaded_class, loader_data);)
   }
 
   // Make sure we have the right class in the dictionary
@@ -789,7 +780,7 @@ InstanceKlass* SystemDictionary::resolve_hidden_class_from_stream(
                                                      const ClassLoadInfo& cl_info,
                                                      TRAPS) {
 
-  EventClassLoad class_load_start_event;
+  EventClassLoad class_load_event;
   ClassLoaderData* loader_data;
 
   // - for hidden classes that are not strong: create a new CLD that has a class holder and
@@ -819,15 +810,16 @@ InstanceKlass* SystemDictionary::resolve_hidden_class_from_stream(
   k->add_to_hierarchy(THREAD);
   // But, do not add to dictionary.
 
+  if (class_load_event.should_commit()) {
+    JFR_ONLY(post_class_load_event(&class_load_event, k, loader_data);)
+  }
+
   k->link_class(CHECK_NULL);
 
   // notify jvmti
   if (JvmtiExport::should_post_class_load()) {
     JvmtiExport::post_class_load(THREAD, k);
   }
-  if (class_load_start_event.should_commit()) {
-    post_class_load_event(&class_load_start_event, k, loader_data);
-  }
 
   return k;
 }
@@ -1154,6 +1146,17 @@ void SystemDictionary::load_shared_class_misc(InstanceKlass* ik, ClassLoaderData
   }
 }
 
+#if INCLUDE_JFR
+void SystemDictionary::post_class_load_event(EventClassLoad* event, const InstanceKlass* k, const ClassLoaderData* init_cld) {
+  assert(event != nullptr, "invariant");
+  assert(k != nullptr, "invariant");
+  event->set_loadedClass(k);
+  event->set_definingClassLoader(k->class_loader_data());
+  event->set_initiatingClassLoader(init_cld);
+  event->commit();
+}
+#endif // INCLUDE_JFR
+
 // This is much more lightweight than SystemDictionary::resolve_or_null
 // - There's only a single Java thread at this point. No need for placeholder.
 // - All supertypes of ik have been loaded
@@ -1182,6 +1185,8 @@ void SystemDictionary::preload_class(Handle class_loader, InstanceKlass* ik, TRA
   }
 #endif
 
+  EventClassLoad class_load_event;
+
   ClassLoaderData* loader_data = ClassLoaderData::class_loader_data(class_loader());
   oop java_mirror = ik->archived_java_mirror();
   precond(java_mirror != nullptr);
@@ -1203,6 +1208,10 @@ void SystemDictionary::preload_class(Handle class_loader, InstanceKlass* ik, TRA
     update_dictionary(THREAD, ik, loader_data);
   }
 
+  if (class_load_event.should_commit()) {
+    JFR_ONLY(post_class_load_event(&class_load_event, ik, loader_data);)
+  }
+
   assert(ik->is_loaded(), "Must be in at least loaded state");
 }
 
@@ -1380,15 +1389,6 @@ InstanceKlass* SystemDictionary::load_instance_class(Symbol* name,
   return loaded_class;
 }
 
-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(InstanceKlass* k, Handle class_loader, TRAPS) {
 
   ClassLoaderData* loader_data = k->class_loader_data();
@@ -1440,7 +1440,6 @@ void SystemDictionary::define_instance_class(InstanceKlass* k, Handle class_load
   if (JvmtiExport::should_post_class_load()) {
     JvmtiExport::post_class_load(THREAD, k);
   }
-  post_class_define_event(k, loader_data);
 }
 
 // Support parallel classloading

src/hotspot/share/classfile/systemDictionary.hpp

@@ -326,11 +326,10 @@ class SystemDictionary : AllStatic {
   static void restore_archived_method_handle_intrinsics_impl(TRAPS) NOT_CDS_RETURN;
 
 protected:
-  // Used by AOTLinkedClassBulkLoader, LambdaProxyClassDictionary, and SystemDictionaryShared
+  // Used by AOTLinkedClassBulkLoader, LambdaProxyClassDictionary, VMClasses and SystemDictionaryShared
 
   static bool add_loader_constraint(Symbol* name, Klass* klass_being_linked,  Handle loader1,
                                     Handle loader2);
-  static void post_class_load_event(EventClassLoad* event, const InstanceKlass* k, const ClassLoaderData* init_cld);
   static InstanceKlass* load_shared_class(InstanceKlass* ik,
                                           Handle class_loader,
                                           Handle protection_domain,
@@ -342,6 +341,9 @@ class SystemDictionary : AllStatic {
   static InstanceKlass* find_or_define_instance_class(Symbol* class_name,
                                                       Handle class_loader,
                                                       InstanceKlass* k, TRAPS);
+  JFR_ONLY(static void post_class_load_event(EventClassLoad* event,
+                                             const InstanceKlass* k,
+                                             const ClassLoaderData* init_cld);)
 
 public:
   static bool is_system_class_loader(oop class_loader);

src/hotspot/share/classfile/vmClasses.cpp

@@ -35,6 +35,7 @@
 #include "classfile/vmClasses.hpp"
 #include "classfile/vmSymbols.hpp"
 #include "gc/shared/collectedHeap.hpp"
+#include "jfr/jfrEvents.hpp"
 #include "memory/metaspaceClosure.hpp"
 #include "memory/universe.hpp"
 #include "oops/instanceKlass.hpp"
@@ -240,6 +241,8 @@ void vmClasses::resolve_shared_class(InstanceKlass* klass, ClassLoaderData* load
     return;
   }
 
+  EventClassLoad class_load_event;
+
   // add super and interfaces first
   InstanceKlass* super = klass->super();
   if (super != nullptr && super->class_loader_data() == nullptr) {
@@ -261,6 +264,10 @@ void vmClasses::resolve_shared_class(InstanceKlass* klass, ClassLoaderData* load
   dictionary->add_klass(THREAD, klass->name(), klass);
   klass->add_to_hierarchy(THREAD);
   assert(klass->is_loaded(), "Must be in at least loaded state");
+
+  if (class_load_event.should_commit()) {
+    JFR_ONLY(SystemDictionary::post_class_load_event(&class_load_event, klass, loader_data);)
+  }
 }
 
 #endif // INCLUDE_CDS

src/hotspot/share/jfr/instrumentation/jfrEventClassTransformer.cpp

@@ -1427,10 +1427,10 @@ static void transform(InstanceKlass*& ik, ClassFileParser& parser, JavaThread* t
   } else {
     JfrClassTransformer::cache_class_file_data(new_ik, stream, thread);
   }
+  JfrClassTransformer::copy_traceid(ik, new_ik);
   if (is_instrumented && JdkJfrEvent::is_subklass(new_ik)) {
     bless_commit_method(new_ik);
   }
-  JfrClassTransformer::copy_traceid(ik, new_ik);
   JfrClassTransformer::rewrite_klass_pointer(ik, new_ik, parser, thread);
 }
 

src/hotspot/share/jfr/jfr.cpp

@@ -22,6 +22,7 @@
  *
  */
 
+#include "classfile/classFileParser.hpp"
 #include "jfr/instrumentation/jfrEventClassTransformer.hpp"
 #include "jfr/jfr.hpp"
 #include "jfr/jni/jfrJavaSupport.hpp"
@@ -31,6 +32,7 @@
 #include "jfr/recorder/repository/jfrEmergencyDump.hpp"
 #include "jfr/recorder/repository/jfrRepository.hpp"
 #include "jfr/recorder/service/jfrOptionSet.hpp"
+#include "jfr/support/jfrClassDefineEvent.hpp"
 #include "jfr/support/jfrKlassExtension.hpp"
 #include "jfr/support/jfrResolution.hpp"
 #include "jfr/support/jfrThreadLocal.hpp"
@@ -78,13 +80,15 @@ void Jfr::on_unloading_classes() {
 }
 
 void Jfr::on_klass_creation(InstanceKlass*& ik, ClassFileParser& parser, TRAPS) {
+  JfrTraceId::assign(ik);
   if (IS_EVENT_OR_HOST_KLASS(ik)) {
     JfrEventClassTransformer::on_klass_creation(ik, parser, THREAD);
-    return;
-  }
-  if (JfrMethodTracer::in_use()) {
+  } else if (JfrMethodTracer::in_use()) {
     JfrMethodTracer::on_klass_creation(ik, parser, THREAD);
   }
+  if (!parser.is_internal()) {
+    JfrClassDefineEvent::on_creation(ik, parser, THREAD);
+  }
 }
 
 void Jfr::on_klass_redefinition(const InstanceKlass* ik, const InstanceKlass* scratch_klass) {
@@ -168,3 +172,11 @@ bool Jfr::on_flight_recorder_option(const JavaVMOption** option, char* delimiter
 bool Jfr::on_start_flight_recording_option(const JavaVMOption** option, char* delimiter) {
   return JfrOptionSet::parse_start_flight_recording_option(option, delimiter);
 }
+
+void Jfr::on_restoration(const Klass* k, JavaThread* jt) {
+  assert(k != nullptr, "invariant");
+  JfrTraceId::restore(k);
+  if (k->is_instance_klass()) {
+    JfrClassDefineEvent::on_restoration(InstanceKlass::cast(k), jt);
+  }
+}

src/hotspot/share/jfr/jfr.hpp

@@ -25,6 +25,7 @@
 #ifndef SHARE_JFR_JFR_HPP
 #define SHARE_JFR_JFR_HPP
 
+#include "jfr/utilities/jfrTypes.hpp"
 #include "memory/allStatic.hpp"
 #include "oops/oopsHierarchy.hpp"
 #include "utilities/exceptions.hpp"
@@ -78,6 +79,7 @@ class Jfr : AllStatic {
   static void initialize_main_thread(JavaThread* jt);
   static bool has_sample_request(JavaThread* jt);
   static void check_and_process_sample_request(JavaThread* jt);
+  static void on_restoration(const Klass* k, JavaThread* jt);
 };
 
 #endif // SHARE_JFR_JFR_HPP