src/hotspot/share/jfr/recorder/repository/jfrEmergencyDump.cpp:

    if (_jt != nullptr) {
      assert(_jt->thread_state() == _thread_in_vm, "invariant");
      _jt->set_thread_state(_thread_in_native);
    }
  }
};

static void post_events(bool exception_handler, bool oom, Thread * thread) {
  if (exception_handler) {
    EventShutdown e;
    e.set_reason(oom ? "CrashOnOutOfMemoryError" : "VM Error");
    e.commit();
  }
  EventDumpReason event;
  event.set_reason(exception_handler && oom ? "CrashOnOutOfMemoryError" : exception_handler ? "Crash" : "Out of Memory");
  event.set_recordingId(-1);
  event.commit();
}

static volatile traceid _jfr_shutdown_tid = 0;

static bool guard_reentrancy() {
  const traceid shutdown_tid = AtomicAccess::load(&_jfr_shutdown_tid);
  if (shutdown_tid == max_julong) {
    // Someone tried but did not have a proper thread for the purpose.

src/hotspot/share/jfr/jni/jfrJniMethod.cpp:

JVM_ENTRY_NO_ENV(jlong, jfr_host_memory_usage(JNIEnv* env, jclass jvm))
  physical_memory_size_type memory_usage = 0;
  if (!os::Machine::used_memory(memory_usage)) {
    // Return -1 to signal failure to get memory usage.
    return static_cast<jlong>(-1);
  }
  return static_cast<jlong>(memory_usage);
JVM_END

JVM_ENTRY_NO_ENV(void, jfr_emit_data_loss(JNIEnv* env, jclass jvm, jlong bytes))
  EventDataLoss::commit(bytes, min_jlong);
JVM_END

JVM_ENTRY_NO_ENV(jlong, jfr_register_stack_filter(JNIEnv* env,  jclass jvm, jobjectArray classes, jobjectArray methods))
  return JfrStackFilterRegistry::add(classes, methods, thread);
JVM_END

JVM_ENTRY_NO_ENV(void, jfr_unregister_stack_filter(JNIEnv* env,  jclass jvm, jlong id))
  JfrStackFilterRegistry::remove(id);
JVM_END

NO_TRANSITION(jlong, jfr_nanos_now(JNIEnv* env, jclass jvm))

src/hotspot/share/jfr/recorder/storage/jfrStorage.cpp:

      assert(!buffer->transient(), "invariant");
      assert(buffer->lease(), "invariant");
      storage_instance.control().increment_leased();
      return buffer;
    }
  }
  return acquire_transient(size, thread);
}

static void write_data_loss_event(JfrBuffer* buffer, u8 unflushed_size, Thread* thread) {
  assert(buffer != nullptr, "invariant");
  assert(buffer->empty(), "invariant");
  const u8 total_data_loss = thread->jfr_thread_local()->add_data_lost(unflushed_size);
  if (EventDataLoss::is_enabled()) {
    JfrNativeEventWriter writer(buffer, thread);
    writer.begin_event_write(false);
    writer.write<u8>(EventDataLoss::eventId);
    writer.write(JfrTicks::now());
    writer.write(unflushed_size);
    writer.write(total_data_loss);
    writer.end_event_write(false);
  }
}

static void write_data_loss(BufferPtr buffer, Thread* thread) {
  assert(buffer != nullptr, "invariant");
  const size_t unflushed_size = buffer->unflushed_size();
  buffer->reinitialize();

src/hotspot/share/jfr/recorder/service/jfrRecorderService.cpp:

template <typename Functor>
static u4 invoke(Functor& f) {
  f.process();
  return f.elements();
}

template <typename Functor>
static u4 invoke_with_flush_event(Functor& f) {
  const u4 elements = invoke(f);
  EventFlush e(UNTIMED);
  e.set_starttime(f.start_time());
  e.set_endtime(f.end_time());
  e.set_flushId(flushpoint_id);
  e.set_elements(f.elements());
  e.set_size(f.size());
  e.commit();
  return elements;
}

class StackTraceRepository : public StackObj {
 private:

src/jdk.jfr/share/classes/jdk/jfr/internal/JDKEvents.java:

public final class JDKEvents {

    private static final Class<?>[] eventClasses = {
        ActiveSettingEvent.class,
        ActiveRecordingEvent.class,
        // jdk.internal.event.* classes need their mirror
        // event class to be listed in the MirrorEvents class.
        jdk.internal.event.DeserializationEvent.class,
        jdk.internal.event.ErrorThrownEvent.class,
        jdk.internal.event.ExceptionStatisticsEvent.class,
        jdk.internal.event.ExceptionThrownEvent.class,
        jdk.internal.event.FileForceEvent.class,
        jdk.internal.event.FileReadEvent.class,
        jdk.internal.event.FileWriteEvent.class,
        jdk.internal.event.ProcessStartEvent.class,

src/jdk.jfr/share/classes/jdk/jfr/events/ActiveSettingEvent.java:

package jdk.jfr.events;

import jdk.jfr.Category;
import jdk.jfr.Label;
import jdk.jfr.Name;
import jdk.jfr.internal.RemoveFields;
import jdk.jfr.internal.Type;

@Name(Type.EVENT_NAME_PREFIX + "ActiveSetting")
@Label("Recording Setting")
@Category("Flight Recorder")
@RemoveFields({"duration", "eventThread", "stackTrace"})
public final class ActiveSettingEvent extends AbstractJDKEvent {

    // The order of these fields must be the same as the parameters in
    // commit(... , long, String, String)

    @Label("Event Id")
    public long id;

    @Label("Setting Name")
    public String name;

    @Label("Setting Value")

src/jdk.jfr/share/classes/jdk/jfr/internal/PlatformRecorder.java:

                        r.getId(),
                        r.getName(),
                        path == null ? null : path.getRealPathText(),
                        r.isToDisk(),
                        age == null ? Long.MAX_VALUE : age.toMillis(),
                        flush == null ? Long.MAX_VALUE : flush.toMillis(),
                        size == null ? Long.MAX_VALUE : size,
                        rStart == null ? Long.MAX_VALUE : rStart.toEpochMilli(),
                        rDuration == null ? Long.MAX_VALUE : rDuration.toMillis()
                    );
                }
            }
        }
        if (ActiveSettingEvent.enabled()) {
            for (EventControl ec : MetadataRepository.getInstance().getEventControls()) {
                ec.writeActiveSettingEvent(timestamp);
            }
        }
    }

    private void periodicTask() {
        if (!JVMSupport.hasJFR()) {
            return;
        }
        while (true) {

src/jdk.jfr/share/classes/jdk/jfr/internal/EventControl.java:

    void writeActiveSettingEvent(long timestamp) {
        if (!type.isRegistered()) {
            return;
        }
        for (NamedControl nc : namedControls) {
            if (nc.control.isVisible(type.hasEventHook()) && type.isVisible()) {
                String value = nc.control.getLastValue();
                if (value == null) {
                    value = nc.control.getDefaultValue();
                }
                if (ActiveSettingEvent.enabled()) {
                    ActiveSettingEvent.commit(timestamp, type.getId(), nc.name(), value);
                }
            }
        }
    }

    public ArrayList<NamedControl> getNamedControls() {
        return namedControls;
    }

    public PlatformEventType getEventType() {
        return type;

src/jdk.jfr/share/classes/jdk/jfr/internal/JDKEvents.java:

public final class JDKEvents {

    private static final Class<?>[] eventClasses = {
        ActiveSettingEvent.class,
        ActiveRecordingEvent.class,
        // jdk.internal.event.* classes need their mirror
        // event class to be listed in the MirrorEvents class.
        jdk.internal.event.DeserializationEvent.class,
        jdk.internal.event.ErrorThrownEvent.class,
        jdk.internal.event.ExceptionStatisticsEvent.class,
        jdk.internal.event.ExceptionThrownEvent.class,
        jdk.internal.event.FileForceEvent.class,
        jdk.internal.event.FileReadEvent.class,
        jdk.internal.event.FileWriteEvent.class,
        jdk.internal.event.ProcessStartEvent.class,
        jdk.internal.event.SecurityPropertyModificationEvent.class,

src/jdk.jfr/share/classes/jdk/jfr/events/ActiveRecordingEvent.java:

@Name(Type.EVENT_NAME_PREFIX + "ActiveRecording")
@Label("Flight Recording")
@Category("Flight Recorder")
@RemoveFields({"duration", "eventThread", "stackTrace"})
public final class ActiveRecordingEvent extends AbstractJDKEvent {

    // The order of these fields must be the same as the parameters in
    // commit(... , long, String, String, long, long, long, long, long)

    @Label("Id")
    public long id;

    @Label("Name")
    public String name;

    @Label("Destination")

src/jdk.jfr/share/classes/jdk/jfr/internal/PlatformRecorder.java:

                // and check for missing files. This will emit more error logs that can be seen in subsequent recordings.
                for (PlatformRecording r : getRecordings()) {
                    r.removeNonExistantPaths();
                }
            }
        }
        // Decrease initial reference count
        chunk.release();
        FilePurger.purge();
    }

    private void writeMetaEvents() {
        long timestamp = JVM.counterTime();
        if (ActiveRecordingEvent.enabled()) {
            for (PlatformRecording r : getRecordings()) {
                if (r.getState() == RecordingState.RUNNING && r.shouldWriteMetadataEvent()) {
                    WriteablePath path = r.getDestination();
                    Duration age = r.getMaxAge();
                    Duration flush = r.getFlushInterval();
                    Long size = r.getMaxSize();
                    Instant rStart = r.getStartTime();
                    Duration rDuration = r.getDuration();
                    ActiveRecordingEvent.commit(
                        timestamp,
                        r.getId(),
                        r.getName(),
                        path == null ? null : path.getRealPathText(),
                        r.isToDisk(),
                        age == null ? Long.MAX_VALUE : age.toMillis(),
                        flush == null ? Long.MAX_VALUE : flush.toMillis(),
                        size == null ? Long.MAX_VALUE : size,
                        rStart == null ? Long.MAX_VALUE : rStart.toEpochMilli(),
                        rDuration == null ? Long.MAX_VALUE : rDuration.toMillis()
                    );

src/hotspot/share/jfr/periodic/jfrRedactedEvents.cpp:

    event.commit();
  }
}

void JfrRedactedEvents::log_jvm_information_redaction(const char* type, const String* redacted) {
  const char* text = String::c_str(redacted);
  if (text != nullptr && strstr(text, REDACTED) != nullptr) {
    log_debug(jfr, redact)("Redacted %s '%s'", type, text);
  }
}

void JfrRedactedEvents::emit_jvm_information(bool log) {
  ensure_initialized();
  EventJVMInformation event;
  event.set_jvmName(VM_Version::vm_name());
  event.set_jvmVersion(VM_Version::internal_vm_info_string());
  event.set_javaArguments(String::c_str(_redacted_java_command_line));
  event.set_jvmArguments(String::c_str(_redacted_jvm_command_line));
  event.set_jvmFlags(String::c_str(_redacted_flags_command_line));
  event.set_jvmStartTime(Management::vm_init_done_time());
  event.set_pid(os::current_process_id());
  event.commit();
  if (log) {
    log_jvm_information_redaction("Java Arguments", _redacted_java_command_line);
    log_jvm_information_redaction("JVM Arguments", _redacted_jvm_command_line);

src/hotspot/share/jfr/periodic/jfrRedactedEvents.cpp:

           value = REDACTED;
        }
        if (log && value != nullptr && strstr(value, REDACTED) != nullptr) {
          log_debug(jfr, redact)("Redacted initial system property named '%s'", p->key());
        }
        _initial_system_properties->append(new StringKeyValue(p->key(), value));
      }
    }
  }

  JfrTicks time_stamp = JfrTicks::now();
  for (int i = 0; i < _initial_system_properties->length(); i++) {
    StringKeyValue* pair = _initial_system_properties->at(i);
    EventInitialSystemProperty event(UNTIMED);
    event.set_key(pair->key());
    event.set_value(pair->value());
    event.set_starttime(time_stamp);
    event.set_endtime(time_stamp);
    event.commit();
  }
}

bool JfrRedactedEvents::match_flag(const char* flag_name, const char* arg) {
  if (flag_name == nullptr || arg == nullptr) {
    return false;

src/hotspot/share/classfile/systemDictionary.cpp:

// 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,
// which will load the class via the bootstrap loader or call ClassLoader.loadClass().
// This can return null, an exception or an InstanceKlass.
InstanceKlass* SystemDictionary::resolve_instance_class_or_null(Symbol* name,
                                                                Handle class_loader,
                                                                TRAPS) {
  // name must be in the form of "java/lang/Object" -- cannot be "Ljava/lang/Object;"
  DEBUG_ONLY(ResourceMark rm(THREAD));
  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_event;

  HandleMark hm(THREAD);

  ClassLoaderData* loader_data = register_loader(class_loader);
  Dictionary* dictionary = loader_data->dictionary();

  // Do lookup to see if class already exists.
  InstanceKlass* probe = dictionary->find_class(THREAD, name);
  if (probe != nullptr) return probe;

  // Non-bootstrap class loaders will call out to class loader and

src/hotspot/share/classfile/systemDictionary.cpp:

// Note: this method is much like resolve_class_from_stream, but
// does not publish the classes in the SystemDictionary.
// Handles Lookup.defineClass hidden.
InstanceKlass* SystemDictionary::resolve_hidden_class_from_stream(
                                                     ClassFileStream* st,
                                                     Symbol* class_name,
                                                     Handle class_loader,
                                                     const ClassLoadInfo& cl_info,
                                                     TRAPS) {

  EventClassLoad class_load_event;
  ClassLoaderData* loader_data;

  // - for hidden classes that are not strong: create a new CLD that has a class holder and
  //                                           whose loader is the Lookup class's loader.
  // - for hidden class: add the class to the Lookup class's loader's CLD.
  assert (cl_info.is_hidden(), "only used for hidden classes");
  bool create_mirror_cld = !cl_info.is_strong_hidden();
  loader_data = register_loader(class_loader, create_mirror_cld);

  assert(st != nullptr, "invariant");

src/hotspot/share/classfile/systemDictionary.cpp:

  // preload_class() must be called in the correct order -- all super types must have
  // already been loaded.
  if (ik->java_super() != nullptr) {
    assert(ik->java_super()->is_loaded(), "must be");
  }

  Array<InstanceKlass*>* interfaces = ik->local_interfaces();
  int num_interfaces = interfaces->length();
  for (int index = 0; index < num_interfaces; index++) {
    assert(interfaces->at(index)->is_loaded(), "must be");
  }
#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);
  assert(java_lang_Class::module(java_mirror) != nullptr, "must have been archived");

  Handle pd(THREAD, java_lang_Class::protection_domain(java_mirror));
  PackageEntry* pkg_entry = ik->package();
  assert(pkg_entry != nullptr || ClassLoader::package_from_class_name(ik->name()) == nullptr,
         "non-empty packages must have been archived");

src/hotspot/share/classfile/systemDictionary.cpp:

  if (!ik->is_hidden()) {
    update_dictionary(THREAD, ik, loader_data);
  }

  if (class_load_event.should_commit()) {
    JFR_ONLY(post_class_load_event(&class_load_event, ik, loader_data);)
  }
}

#endif // INCLUDE_CDS

#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

InstanceKlass* SystemDictionary::load_instance_class_impl(Symbol* class_name, Handle class_loader, TRAPS) {

src/hotspot/share/classfile/systemDictionary.hpp:

//         readers (we must ensure write ordering)
//
// Note that placeholders are deleted at any time, as they are removed
// when a class is completely loaded. Therefore, readers as well as writers
// of placeholders must hold the SystemDictionary_lock.
//

class BootstrapInfo;
class ClassFileStream;
class ClassLoadInfo;
class Dictionary;
class PackageEntry;
class GCTimer;
class EventClassLoad;
class Symbol;

template <class E> class GrowableArray;

class SystemDictionary : AllStatic {
  friend class AOTLinkedClassBulkLoader;
  friend class BootstrapInfo;
  friend class LambdaProxyClassDictionary;
  friend class vmClasses;

 public:

src/hotspot/share/classfile/systemDictionary.hpp:

  static InstanceKlass* find_or_define_instance_class(Symbol* class_name,
                                                      Handle class_loader,
                                                      InstanceKlass* k, TRAPS);
public:
  static bool is_system_class_loader(oop class_loader);
  static bool is_platform_class_loader(oop class_loader);
  static bool is_boot_class_loader(oop class_loader) { return class_loader == nullptr; }
  static bool is_builtin_class_loader(oop class_loader) {
    return is_boot_class_loader(class_loader)      ||
           is_platform_class_loader(class_loader)  ||
           is_system_class_loader(class_loader);
  }
  // Returns TRUE if the method is a non-public member of class java.lang.Object.
  static bool is_nonpublic_Object_method(Method* m);

  // Return Symbol or throw exception if name given is can not be a valid Symbol.
  static Symbol* class_name_symbol(const char* name, Symbol* exception, TRAPS);

  JFR_ONLY(static void post_class_load_event(EventClassLoad* event,
                                             const InstanceKlass* k,
                                             const ClassLoaderData* init_cld);)
};

#endif // SHARE_CLASSFILE_SYSTEMDICTIONARY_HPP

src/hotspot/share/classfile/vmClasses.cpp:

  InstanceStackChunkKlass::init_offset_of_stack();
}

#if INCLUDE_CDS

void vmClasses::resolve_shared_class(InstanceKlass* klass, ClassLoaderData* loader_data, Handle domain, TRAPS) {
  assert(!Universe::is_fully_initialized(), "We can make short cuts only during VM initialization");
  assert(klass->in_aot_cache(), "Must be shared class");
  if (klass->class_loader_data() != nullptr) {
    return;
  }

  EventClassLoad class_load_event;

  // add super and interfaces first
  InstanceKlass* super = klass->super();
  if (super != nullptr && super->class_loader_data() == nullptr) {
    assert(super->is_instance_klass(), "Super should be instance klass");
    resolve_shared_class(super, loader_data, domain, CHECK);
  }

  Array<InstanceKlass*>* ifs = klass->local_interfaces();
  for (int i = 0; i < ifs->length(); i++) {
    InstanceKlass* ik = ifs->at(i);

src/hotspot/share/cds/lambdaProxyClassDictionary.cpp:

      proxy_klass->clear_lambda_proxy_is_available();
      if (log_is_enabled(Debug, aot)) {
        ResourceMark rm;
        log_debug(aot)("Loaded lambda proxy: %s ", proxy_klass->external_name());
      }
    }
  }
  return proxy_klass;
}

InstanceKlass* LambdaProxyClassDictionary::load_and_init_lambda_proxy_class(InstanceKlass* lambda_ik,
                                                                            InstanceKlass* caller_ik, TRAPS) {

  EventClassLoad class_load_event;

  Handle class_loader(THREAD, caller_ik->class_loader());
  Handle protection_domain;
  PackageEntry* pkg_entry = caller_ik->package();
  if (caller_ik->class_loader() != nullptr) {
    protection_domain = CDSProtectionDomain::init_security_info(class_loader, caller_ik, pkg_entry, CHECK_NULL);
  }

  InstanceKlass* shared_nest_host = get_shared_nest_host(lambda_ik);
  assert(shared_nest_host != nullptr, "unexpected nullptr _nest_host");
  assert(shared_nest_host->in_aot_cache(), "nest host must be in aot metaspace");

src/hotspot/share/jfr/support/jfrClassDefineEvent.cpp:

    const int index = ik->shared_classpath_index();
    assert(index >= 0, "invariant");
    const AOTClassLocation* const cl = AOTClassLocationConfig::runtime()->class_location_at(index);
    assert(cl != nullptr, "invariant");
    if (cl->is_modules_image()) {
      JfrTraceId::set_preload_bootloader_bit(ik);
    }
  }
}
#endif

static inline void commit_event(const InstanceKlass* ik, const char* s) {
  assert(ik != nullptr, "invariant");
  EventClassDefine event;
  event.set_definedClass(ik);
  event.set_definingClassLoader(ik->class_loader_data());
  event.set_source(s != nullptr ? JfrSymbolTable::add(s) : 0);
  event.commit();
}

void JfrClassDefineEvent::send_event(const InstanceKlass* ik, bool from_boot_loader_modules_image, JavaThread* jt) {
  assert(ik != nullptr, "invariant");
  assert(!ik->is_loaded(), "invariant");
  assert(is_not_retransforming(ik, jt), "invariant");
  DEBUG_ONLY(JfrJavaSupport::check_java_thread_in_vm(jt);)
  if (EventClassDefine::is_enabled()) {
    ResourceMark rm(jt);
    commit_event(ik, source(ik, from_boot_loader_modules_image, jt));
  }
}

src/hotspot/share/prims/jvmtiRedefineClasses.cpp:

  _timer_rsc_phase1.stop();
  if (log_is_enabled(Info, redefine, class, timer)) {
    _timer_rsc_phase2.start();
  }

  if (the_class->oop_map_cache() != nullptr) {
    // Flush references to any obsolete methods from the oop map cache
    // so that obsolete methods are not pinned.
    the_class->oop_map_cache()->flush_obsolete_entries();
  }

  increment_class_counter(the_class);

  if (EventClassRedefinition::is_enabled()) {
    EventClassRedefinition event;
    event.set_classModificationCount(java_lang_Class::classRedefinedCount(the_class->java_mirror()));
    event.set_redefinedClass(the_class);
    event.set_redefinitionId(_id);
    event.commit();
  }

  {
    ResourceMark rm(current);
    // increment the classRedefinedCount field in the_class and in any
    // direct and indirect subclasses of the_class
    physical_memory_size_type avail_mem = 0;

src/hotspot/share/prims/jvmtiEnv.cpp:

    event.set_classCount(class_count);
    event.set_redefinitionId(op.id());
    event.commit();
  }
  return error;
} /* end RetransformClasses */


// class_count - pre-checked to be greater than or equal to 0
// class_definitions - pre-checked for null
jvmtiError
JvmtiEnv::RedefineClasses(jint class_count, const jvmtiClassDefinition* class_definitions) {
//TODO: add locking
  EventRedefineClasses event;
  VM_RedefineClasses op(class_count, class_definitions, jvmti_class_load_kind_redefine);
  VMThread::execute(&op);
  jvmtiError error = op.check_error();
  if (error == JVMTI_ERROR_NONE) {
    event.set_classCount(class_count);
    event.set_redefinitionId(op.id());
    event.commit();
  }
  return error;
} /* end RedefineClasses */

src/hotspot/share/prims/jvmtiEnv.cpp:

      class_definitions[index].class_byte_count = (jint)reconstituter.class_file_size();
      class_definitions[index].class_bytes      = (unsigned char*)
                                                       reconstituter.class_file_bytes();
    } else {
      // it is cached, get it from the cache
      class_definitions[index].class_byte_count = ik->get_cached_class_file_len();
      class_definitions[index].class_bytes      = ik->get_cached_class_file_bytes();
    }
    class_definitions[index].klass              = jcls;
  }
  EventRetransformClasses event;
  VM_RedefineClasses op(class_count, class_definitions, jvmti_class_load_kind_retransform);
  VMThread::execute(&op);
  jvmtiError error = op.check_error();
  if (error == JVMTI_ERROR_NONE) {
    event.set_classCount(class_count);
    event.set_redefinitionId(op.id());
    event.commit();
  }
  return error;
} /* end RetransformClasses */

src/hotspot/share/oops/instanceKlass.cpp:

  if (log_is_enabled(Info, class, unload)) {
    ResourceMark rm;
    log_info(class, unload)("unloading class %s " PTR_FORMAT, ik->external_name(), p2i(ik));
  }

  Thread* const current = Thread::current();
  Events::log_class_unloading(current, ik);

#if INCLUDE_JFR
  assert(ik != nullptr, "invariant");
  // For concurrent unloading, we need the ik, the cld, and the event
  // to end up in the correct JFR epoch, hence the acquisition of the
  // epoch shift lock before the event.commit().
  if (EventClassUnload::is_enabled()) {
    EventClassUnload event;
    event.set_unloadedClass(ik);
    event.set_definingClassLoader(ik->class_loader_data());
    ConditionalMutexLocker ml(JfrEpochShift_lock, UseShenandoahGC || UseZGC, Mutex::_no_safepoint_check_flag);
    event.commit();
  }
#endif
}

static void method_release_C_heap_structures(Method* m) {
  m->release_C_heap_structures();
}