src/share/vm/classfile/systemDictionary.cpp

@@ -36,12 +36,14 @@
 #endif
 #include "classfile/vmSymbols.hpp"
 #include "compiler/compileBroker.hpp"
 #include "interpreter/bytecodeStream.hpp"
 #include "interpreter/interpreter.hpp"
+#if INCLUDE_JFR
 #include "jfr/jfrEvents.hpp"
 #include "jfr/jni/jfrUpcalls.hpp"
+#endif
 #include "memory/filemap.hpp"
 #include "memory/gcLocker.hpp"
 #include "memory/oopFactory.hpp"
 #include "oops/instanceKlass.hpp"
 #include "oops/instanceRefKlass.hpp"

@@ -601,35 +603,37 @@
     }
   }
   return (nh);
 }
 
+#if INCLUDE_JFR
 // 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
 }
+#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");
 
+#if INCLUDE_JFR
   EventClassLoad class_load_start_event;
+#endif
 
   // 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);

@@ -876,11 +880,13 @@
 
   if (HAS_PENDING_EXCEPTION || k.is_null()) {
     return NULL;
   }
 
+#if INCLUDE_JFR
   post_class_load_event(class_load_start_event, k, class_loader);
+#endif
 
 #ifdef ASSERT
   {
     ClassLoaderData* loader_data = k->class_loader_data();
     MutexLocker mu(SystemDictionary_lock, THREAD);

@@ -1001,11 +1007,13 @@
                                       KlassHandle host_klass,
                                       GrowableArray<Handle>* cp_patches,
                                       TRAPS) {
   TempNewSymbol parsed_name = NULL;
 
+#if INCLUDE_JFR
   EventClassLoad class_load_start_event;
+#endif
 
   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

@@ -1062,11 +1070,13 @@
     if (JvmtiExport::should_post_class_load()) {
         assert(THREAD->is_Java_thread(), "thread->is_Java_thread()");
         JvmtiExport::post_class_load((JavaThread *) THREAD, k());
     }
 
+#if INCLUDE_JFR
     post_class_load_event(class_load_start_event, k, class_loader);
+#endif
   }
   assert(host_klass.not_null() || cp_patches == NULL,
          "cp_patches only found with host_klass");
 
   return k();

@@ -1432,18 +1442,20 @@
     // Class is not found or has the wrong name, return NULL
     return nh;
   }
 }
 
+#if INCLUDE_JFR
 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();
   }
 }
+#endif
 
 void SystemDictionary::define_instance_class(instanceKlassHandle k, TRAPS) {
 
   ClassLoaderData* loader_data = k->class_loader_data();
   Handle class_loader_h(THREAD, loader_data->class_loader());

@@ -1511,11 +1523,13 @@
       assert(THREAD->is_Java_thread(), "thread->is_Java_thread()");
       JvmtiExport::post_class_load((JavaThread *) THREAD, k());
 
   }
 
+#if INCLUDE_JFR
   post_class_define_event(k(), loader_data);
+#endif
 }
 
 // Support parallel classloading
 // All parallel class loaders, including bootstrap classloader
 // lock a placeholder entry for this class/class_loader pair