--- old/src/share/vm/classfile/systemDictionary.cpp	2019-02-15 19:02:22.799344898 +0300
+++ new/src/share/vm/classfile/systemDictionary.cpp	2019-02-15 19:02:22.703348258 +0300
@@ -38,6 +38,7 @@
 #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"
@@ -64,9 +65,6 @@
 #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;
@@ -598,6 +596,22 @@
   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,
@@ -606,7 +620,7 @@
   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
@@ -848,7 +862,7 @@
     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
   {
@@ -973,7 +987,7 @@
                                       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()) {
@@ -1034,7 +1048,7 @@
         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");
@@ -1076,12 +1090,13 @@
   //
   // Note: "name" is updated.
 
-  instanceKlassHandle k = ClassFileParser(st).parseClassFile(class_name,
-                                                             loader_data,
-                                                             protection_domain,
-                                                             parsed_name,
-                                                             verify,
-                                                             THREAD);
+  ClassFileParser parser(st);
+  instanceKlassHandle k = parser.parseClassFile(class_name,
+                                                loader_data,
+                                                protection_domain,
+                                                parsed_name,
+                                                verify,
+                                                THREAD);
 
   const char* pkg = "java/";
   size_t pkglen = strlen(pkg);
@@ -1116,6 +1131,14 @@
     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
@@ -1376,6 +1399,15 @@
   }
 }
 
+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();
@@ -1446,6 +1478,7 @@
 
   }
 
+  post_class_define_event(k(), loader_data);
 }
 
 // Support parallel classloading
@@ -2678,26 +2711,6 @@
   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