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

static void post_events(bool exception_handler, Thread* thread) {
  if (exception_handler) {
    EventShutdown e;
    e.set_reason("VM Error");
    e.commit();
  } else {
    // OOM
    LeakProfiler::emit_events(max_jlong, false, false);
  }
  EventDumpReason event;
  event.set_reason(exception_handler ? "Crash" : "Out of Memory");
  event.set_recordingId(-1);
  event.commit();
}

void JfrEmergencyDump::on_vm_shutdown(bool exception_handler) {
  if (!guard_reentrancy()) {
    return;
  }
  Thread* thread = Thread::current_or_null_safe();
  if (thread == NULL) {

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 != NULL, "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 != NULL, "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/events/ActiveRecordingEvent.java:

@Name(Type.EVENT_NAME_PREFIX + "ActiveRecording")
@Label("Flight Recording")
@Category("Flight Recorder")
@StackTrace(false)
public final class ActiveRecordingEvent extends AbstractJDKEvent {

    public static final ThreadLocal<ActiveRecordingEvent> EVENT = new ThreadLocal<ActiveRecordingEvent>() {
        @Override
        protected ActiveRecordingEvent initialValue() {
            return new ActiveRecordingEvent();
        }
    };

    @Label("Id")
    public long id;

    @Label("Name")
    public String name;

    @Label("Destination")
    public String destination;

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

        ProcessStartEvent.class
    };

    private static final Class<?>[] eventClasses = {
        FileForceEvent.class,
        FileReadEvent.class,
        FileWriteEvent.class,
        SocketReadEvent.class,
        SocketWriteEvent.class,
        ExceptionThrownEvent.class,
        ExceptionStatisticsEvent.class,
        ErrorThrownEvent.class,
        ActiveSettingEvent.class,
        ActiveRecordingEvent.class,
        jdk.internal.event.SecurityPropertyModificationEvent.class,
        jdk.internal.event.TLSHandshakeEvent.class,
        jdk.internal.event.X509CertificateEvent.class,
        jdk.internal.event.X509ValidationEvent.class,
        jdk.internal.event.ProcessStartEvent.class,
        DirectBufferStatisticsEvent.class
    };

    // This is a list of the classes with instrumentation code that should be applied.
    private static final Class<?>[] instrumentationClasses = new Class<?>[] {
        FileInputStreamInstrumentor.class,

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

    private RepositoryChunk currentChunk;
    private boolean inShutdown;

    public PlatformRecorder() throws Exception {
        repository = Repository.getRepository();
        Logger.log(JFR_SYSTEM, INFO, "Initialized disk repository");
        repository.ensureRepository();
        jvm.createNativeJFR();
        Logger.log(JFR_SYSTEM, INFO, "Created native");
        JDKEvents.initialize();
        Logger.log(JFR_SYSTEM, INFO, "Registered JDK events");
        JDKEvents.addInstrumentation();
        startDiskMonitor();
        activeRecordingEvent = EventType.getEventType(ActiveRecordingEvent.class);
        activeSettingEvent = EventType.getEventType(ActiveSettingEvent.class);
        shutdownHook = SecuritySupport.createThreadWitNoPermissions("JFR Shutdown Hook", new ShutdownHook(this));
        SecuritySupport.setUncaughtExceptionHandler(shutdownHook, new ShutdownHook.ExceptionHandler());
        SecuritySupport.registerShutdownHook(shutdownHook);

    }


    private static Timer createTimer() {
        try {
            List<Timer> result = new CopyOnWriteArrayList<>();

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

    private void finishChunk(RepositoryChunk chunk, Instant time, PlatformRecording ignoreMe) {
        chunk.finish(time);
        for (PlatformRecording r : getRecordings()) {
            if (r != ignoreMe && r.getState() == RecordingState.RUNNING) {
                r.appendChunk(chunk);
            }
        }
        FilePurger.purge();
    }

    private void writeMetaEvents() {
        if (activeRecordingEvent.isEnabled()) {
            ActiveRecordingEvent event = ActiveRecordingEvent.EVENT.get();
            for (PlatformRecording r : getRecordings()) {
                if (r.getState() == RecordingState.RUNNING && r.shouldWriteMetadataEvent()) {
                    event.id = r.getId();
                    event.name = r.getName();
                    WriteableUserPath p = r.getDestination();
                    event.destination = p == null ? null : p.getRealPathText();
                    Duration d = r.getDuration();
                    event.recordingDuration = d == null ? Long.MAX_VALUE : d.toMillis();
                    Duration age = r.getMaxAge();
                    event.maxAge = age == null ? Long.MAX_VALUE : age.toMillis();
                    Long size = r.getMaxSize();

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.StackTrace;
import jdk.jfr.internal.Type;

@Name(Type.EVENT_NAME_PREFIX + "ActiveSetting")
@Label("Recording Setting")
@Category("Flight Recorder")
@StackTrace(false)
public final class ActiveSettingEvent extends AbstractJDKEvent {

    public static final ThreadLocal<ActiveSettingEvent> EVENT = new ThreadLocal<ActiveSettingEvent>() {
        @Override
        protected ActiveSettingEvent initialValue() {
            return new ActiveSettingEvent();
        }
    };

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

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

    @Label("Setting Value")
    public String value;

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

        X509ValidationEvent.class,
        ProcessStartEvent.class
    };

    private static final Class<?>[] eventClasses = {
        FileForceEvent.class,
        FileReadEvent.class,
        FileWriteEvent.class,
        SocketReadEvent.class,
        SocketWriteEvent.class,
        ExceptionThrownEvent.class,
        ExceptionStatisticsEvent.class,
        ErrorThrownEvent.class,
        ActiveSettingEvent.class,
        ActiveRecordingEvent.class,
        jdk.internal.event.SecurityPropertyModificationEvent.class,
        jdk.internal.event.TLSHandshakeEvent.class,
        jdk.internal.event.X509CertificateEvent.class,
        jdk.internal.event.X509ValidationEvent.class,
        jdk.internal.event.ProcessStartEvent.class,
        DirectBufferStatisticsEvent.class
    };

    // This is a list of the classes with instrumentation code that should be applied.
    private static final Class<?>[] instrumentationClasses = new Class<?>[] {

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

    void disable() {
        for (NamedControl nc : namedControls) {
            if (nc.control.isType(EnabledSetting.class)) {
                nc.control.setValue("false");
                return;
            }
        }
    }

    void writeActiveSettingEvent() {
        if (!type.isRegistered()) {
            return;
        }
        ActiveSettingEvent event = ActiveSettingEvent.EVENT.get();
        for (NamedControl nc : namedControls) {
            if (Utils.isSettingVisible(nc.control, type.hasEventHook())) {
                String value = nc.control.getLastValue();
                if (value == null) {
                    value = nc.control.getDefaultValue();
                }
                event.id = type.getId();
                event.name = nc.name;
                event.value = value;
                event.commit();
            }

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

    private boolean inShutdown;

    public PlatformRecorder() throws Exception {
        repository = Repository.getRepository();
        Logger.log(JFR_SYSTEM, INFO, "Initialized disk repository");
        repository.ensureRepository();
        jvm.createNativeJFR();
        Logger.log(JFR_SYSTEM, INFO, "Created native");
        JDKEvents.initialize();
        Logger.log(JFR_SYSTEM, INFO, "Registered JDK events");
        JDKEvents.addInstrumentation();
        startDiskMonitor();
        activeRecordingEvent = EventType.getEventType(ActiveRecordingEvent.class);
        activeSettingEvent = EventType.getEventType(ActiveSettingEvent.class);
        shutdownHook = SecuritySupport.createThreadWitNoPermissions("JFR Shutdown Hook", new ShutdownHook(this));
        SecuritySupport.setUncaughtExceptionHandler(shutdownHook, new ShutdownHook.ExceptionHandler());
        SecuritySupport.registerShutdownHook(shutdownHook);

    }


    private static Timer createTimer() {
        try {
            List<Timer> result = new CopyOnWriteArrayList<>();
            Thread t = SecuritySupport.createThreadWitNoPermissions("Permissionless thread", ()-> {

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

#if INCLUDE_SHENANDOAHGC
#include "gc/shenandoah/shenandoahJfrSupport.hpp"
#endif
/**
 *  JfrPeriodic class
 *  Implementation of declarations in
 *  xsl generated traceRequestables.hpp
 */
#define TRACE_REQUEST_FUNC(id)    void JfrPeriodicEventSet::request##id(void)

TRACE_REQUEST_FUNC(JVMInformation) {
  ResourceMark rm;
  EventJVMInformation event;
  event.set_jvmName(VM_Version::vm_name());
  event.set_jvmVersion(VM_Version::internal_vm_info_string());
  event.set_javaArguments(Arguments::java_command());
  event.set_jvmArguments(Arguments::jvm_args());
  event.set_jvmFlags(Arguments::jvm_flags());
  event.set_jvmStartTime(Management::vm_init_done_time());
  event.set_pid(os::current_process_id());
  event.commit();
 }

TRACE_REQUEST_FUNC(OSInformation) {

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

  jlong max_size = conf.has_max_size_default_value() ? jmc_undefined_long : conf.max_size();
  EventYoungGenerationConfiguration event;
  event.set_maxSize((u8)max_size);
  event.set_minSize(conf.min_size());
  event.set_newRatio(conf.new_ratio());
  event.commit();
}

TRACE_REQUEST_FUNC(InitialSystemProperty) {
  SystemProperty* p = Arguments::system_properties();
  JfrTicks time_stamp = JfrTicks::now();
  while (p !=  NULL) {
    if (!p->internal()) {
      EventInitialSystemProperty event(UNTIMED);
      event.set_key(p->key());
      event.set_value(p->value());
      event.set_endtime(time_stamp);
      event.commit();
    }
    p = p->next();
  }
}

TRACE_REQUEST_FUNC(ThreadAllocationStatistics) {
  ResourceMark rm;

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

class BootstrapInfo;
class ClassFileStream;
class ClassLoadInfo;
class Dictionary;
class PlaceholderTable;
class LoaderConstraintTable;
template <MEMFLAGS F> class HashtableBucket;
class ResolutionErrorTable;
class SymbolPropertyTable;
class PackageEntry;
class ProtectionDomainCacheTable;
class ProtectionDomainCacheEntry;
class GCTimer;
class EventClassLoad;
class Symbol;
class TableStatistics;

#define WK_KLASS_ENUM_NAME(kname)    kname##_knum

// Certain classes, such as java.lang.Object and java.lang.String,
// are "well-known", in the sense that no class loader is allowed
// to provide a different definition.
//
// Each well-known class has a short klass name (like object_klass),
// and a vmSymbol name (like java_lang_Object).

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

  static ProtectionDomainCacheTable*   _pd_cache_table;

protected:
  static void validate_protection_domain(InstanceKlass* klass,
                                         Handle class_loader,
                                         Handle protection_domain, TRAPS);

  friend class VM_PopulateDumpSharedSpace;
  friend class TraversePlaceholdersClosure;
  static PlaceholderTable*   placeholders() { return _placeholders; }
  static LoaderConstraintTable* constraints() { return _loader_constraints; }
  static ResolutionErrorTable* resolution_errors() { return _resolution_errors; }
  static SymbolPropertyTable* invoke_method_table() { return _invoke_method_table; }
  static void post_class_load_event(EventClassLoad* event, const InstanceKlass* k, const ClassLoaderData* init_cld);

  // Basic loading operations
  static InstanceKlass* resolve_instance_class_or_null_helper(Symbol* name,
                                                              Handle class_loader,
                                                              Handle protection_domain,
                                                              TRAPS);
  static InstanceKlass* resolve_instance_class_or_null(Symbol* class_name, Handle class_loader, Handle protection_domain, TRAPS);
  static Klass* resolve_array_class_or_null(Symbol* class_name, Handle class_loader, Handle protection_domain, TRAPS);
  static InstanceKlass* handle_parallel_super_load(Symbol* class_name, Symbol* supername, Handle class_loader, Handle protection_domain, Handle lockObject, TRAPS);
  // Wait on SystemDictionary_lock; unlocks lockObject before
  // waiting; relocks lockObject with correct recursion count

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

  InstanceKlass* loaded_lambda =
    SystemDictionary::load_shared_lambda_proxy_class(lambda_ik, class_loader, protection_domain, pkg_entry, CHECK_NULL);

  if (loaded_lambda == NULL) {
    return NULL;
  }

  // Ensures the nest host is the same as the lambda proxy's
  // nest host recorded at dump time.
  InstanceKlass* nest_host = caller_ik->nest_host(THREAD);
  assert(nest_host == shared_nest_host, "mismatched nest host");

  EventClassLoad class_load_start_event;
  {
    MutexLocker mu_r(THREAD, Compile_lock);

    // Add to class hierarchy, initialize vtables, and do possible
    // deoptimizations.
    SystemDictionary::add_to_hierarchy(loaded_lambda, CHECK_NULL); // No exception, but can block
    // But, do not add to dictionary.
  }
  loaded_lambda->link_class(CHECK_NULL);
  // notify jvmti
  if (JvmtiExport::should_post_class_load()) {

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

          SystemDictionary_lock->wait();
        } else {
          double_lock_wait(lockObject, THREAD);
        }
      } else {
        // If not in SD and not in PH, other thread's load must have failed
        super_load_in_progress = false;
      }
    }
  }
  return NULL;
}

void SystemDictionary::post_class_load_event(EventClassLoad* event, const InstanceKlass* k, const ClassLoaderData* init_cld) {
  assert(event != NULL, "invariant");
  assert(k != NULL, "invariant");
  assert(event->should_commit(), "invariant");
  event->set_loadedClass(k);
  event->set_definingClassLoader(k->class_loader_data());
  event->set_initiatingClassLoader(init_cld);
  event->commit();
}


// Be careful when modifying this code: once you have run
// placeholders()->find_and_add(PlaceholderTable::LOAD_INSTANCE),
// you need to find_and_remove it before returning.
// So be careful to not exit with a CHECK_ macro betweeen these calls.
//
// name must be in the form of "java/lang/Object" -- cannot be "Ljava/lang/Object;"
InstanceKlass* SystemDictionary::resolve_instance_class_or_null(Symbol* name,
                                                                Handle class_loader,
                                                                Handle protection_domain,
                                                                TRAPS) {
  assert(name != NULL && !Signature::is_array(name) &&
         !Signature::has_envelope(name), "invalid class name");

  EventClassLoad class_load_start_event;

  HandleMark hm(THREAD);

  // 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);
  Dictionary* dictionary = loader_data->dictionary();
  unsigned int d_hash = dictionary->compute_hash(name);

  // Do lookup to see if class already exist and the protection domain
  // has the right access

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

// Note: this method is much like resolve_from_stream, but
// does not publish the classes via the SystemDictionary.
// Handles Lookup.defineClass hidden, unsafe_DefineAnonymousClass
// and redefineclasses. RedefinedClasses do not add to the class hierarchy.
InstanceKlass* SystemDictionary::parse_stream(Symbol* class_name,
                                              Handle class_loader,
                                              ClassFileStream* st,
                                              const ClassLoadInfo& cl_info,
                                              TRAPS) {

  EventClassLoad class_load_start_event;
  ClassLoaderData* loader_data;
  bool is_unsafe_anon_class = cl_info.unsafe_anonymous_host() != NULL;

  // - for unsafe anonymous class: create a new CLD whith a class holder that uses
  //                               the same class loader as the unsafe_anonymous_host.
  // - 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.
  if (is_unsafe_anon_class || cl_info.is_hidden()) {
    guarantee(!is_unsafe_anon_class || cl_info.unsafe_anonymous_host()->class_loader() == class_loader(),
              "should be NULL or the same");

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

      // For user defined Java class loaders, check that the name returned is
      // the same as that requested.  This check is done for the bootstrap
      // loader when parsing the class file.
      if (class_name == k->name()) {
        return k;
      }
    }
    // Class is not found or has the wrong name, return NULL
    return NULL;
  }
}

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, TRAPS) {

  HandleMark hm(THREAD);
  ClassLoaderData* loader_data = k->class_loader_data();

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() != NULL) {
    // 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((InstanceKlass *)the_class, THREAD);

  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(THREAD);
    // increment the classRedefinedCount field in the_class and in any
    // direct and indirect subclasses of the_class
    log_info(redefine, class, load)

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 (Arguments::is_dumping_archive()) {
    SystemDictionaryShared::remove_dumptime_info(ik);
  }

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

  Events::log_class_unloading(Thread::current(), ik);

#if INCLUDE_JFR
  assert(ik != NULL, "invariant");
  EventClassUnload event;
  event.set_unloadedClass(ik);
  event.set_definingClassLoader(ik->class_loader_data());
  event.commit();
#endif
}

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

void InstanceKlass::release_C_heap_structures() {

src/hotspot/share/code/codeCache.cpp:

      ttyLocker ttyl;
      tty->print("%s", s.as_string());
    }

    if (heap->full_count() == 0) {
      if (PrintCodeHeapAnalytics) {
        CompileBroker::print_heapinfo(tty, "all", 4096); // details, may be a lot!
      }
    }
  }

  heap->report_full();

  EventCodeCacheFull event;
  if (event.should_commit()) {
    event.set_codeBlobType((u1)code_blob_type);
    event.set_startAddress((u8)heap->low_boundary());
    event.set_commitedTopAddress((u8)heap->high());
    event.set_reservedTopAddress((u8)heap->high_boundary());
    event.set_entryCount(heap->blob_count());
    event.set_methodCount(heap->nmethod_count());
    event.set_adaptorCount(heap->adapter_count());
    event.set_unallocatedCapacity(heap->unallocated_capacity());
    event.set_fullCount(heap->full_count());
    event.commit();

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

TRACE_REQUEST_FUNC(CompilerConfiguration) {
  EventCompilerConfiguration event;
  event.set_threadCount(CICompilerCount);
  event.set_tieredCompilation(TieredCompilation);
  event.commit();
}

TRACE_REQUEST_FUNC(CodeCacheStatistics) {
  // Emit stats for all available code heaps
  for (int bt = 0; bt < CodeBlobType::NumTypes; ++bt) {
    if (CodeCache::heap_available(bt)) {
      EventCodeCacheStatistics event;
      event.set_codeBlobType((u1)bt);
      event.set_startAddress((u8)CodeCache::low_bound(bt));
      event.set_reservedTopAddress((u8)CodeCache::high_bound(bt));
      event.set_entryCount(CodeCache::blob_count(bt));
      event.set_methodCount(CodeCache::nmethod_count(bt));
      event.set_adaptorCount(CodeCache::adapter_count(bt));
      event.set_unallocatedCapacity(CodeCache::unallocated_capacity(bt));
      event.set_fullCount(CodeCache::get_codemem_full_count(bt));
      event.commit();
    }
  }

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

      event.set_startAddress((u8)CodeCache::low_bound(bt));
      event.set_reservedTopAddress((u8)CodeCache::high_bound(bt));
      event.set_entryCount(CodeCache::blob_count(bt));
      event.set_methodCount(CodeCache::nmethod_count(bt));
      event.set_adaptorCount(CodeCache::adapter_count(bt));
      event.set_unallocatedCapacity(CodeCache::unallocated_capacity(bt));
      event.set_fullCount(CodeCache::get_codemem_full_count(bt));
      event.commit();
    }
  }
}

TRACE_REQUEST_FUNC(CodeCacheConfiguration) {
  EventCodeCacheConfiguration event;
  event.set_initialSize(InitialCodeCacheSize);
  event.set_reservedSize(ReservedCodeCacheSize);
  event.set_nonNMethodSize(NonNMethodCodeHeapSize);
  event.set_profiledSize(ProfiledCodeHeapSize);
  event.set_nonProfiledSize(NonProfiledCodeHeapSize);
  event.set_expansionSize(CodeCacheExpansionSize);
  event.set_minBlockLength(CodeCacheMinBlockLength);
  event.set_startAddress((u8)CodeCache::low_bound());
  event.set_reservedTopAddress((u8)CodeCache::high_bound());
  event.commit();
}

src/hotspot/share/runtime/sweeper.cpp:

  sweep_code_cache();

  // We are done with sweeping the code cache once.
  _total_nof_code_cache_sweeps++;

  if (_force_sweep) {
    // Notify requester that forced sweep finished
    MutexLocker mu(CodeSweeper_lock, Mutex::_no_safepoint_check_flag);
    _force_sweep = false;
    CodeSweeper_lock->notify();
  }
}

static void post_sweep_event(EventSweepCodeCache* event,
                             const Ticks& start,
                             const Ticks& end,
                             s4 traversals,
                             int swept,
                             int flushed,
                             int zombified) {
  assert(event != NULL, "invariant");
  assert(event->should_commit(), "invariant");
  event->set_starttime(start);
  event->set_endtime(end);
  event->set_sweepId(traversals);

src/hotspot/share/runtime/sweeper.cpp:

  const Ticks sweep_end_counter = Ticks::now();
  const Tickspan sweep_time = sweep_end_counter - sweep_start_counter;
  {
    MutexLocker mu(NMethodSweeperStats_lock, Mutex::_no_safepoint_check_flag);
    _total_time_sweeping  += sweep_time;
    _total_time_this_sweep += sweep_time;
    _peak_sweep_fraction_time = MAX2(sweep_time, _peak_sweep_fraction_time);
    _total_flushed_size += freed_memory;
    _total_nof_methods_reclaimed += flushed_count;
    _total_nof_c2_methods_reclaimed += flushed_c2_count;
    _peak_sweep_time = MAX2(_peak_sweep_time, _total_time_this_sweep);
  }

  EventSweepCodeCache event(UNTIMED);
  if (event.should_commit()) {
    post_sweep_event(&event, sweep_start_counter, sweep_end_counter, (s4)_traversals, swept_count, flushed_count, zombified_count);
  }

#ifdef ASSERT
  if(PrintMethodFlushing) {
    tty->print_cr("### sweeper:      sweep time(" JLONG_FORMAT "): ", sweep_time.value());
  }
#endif

  Log(codecache, sweep) log;

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

  event.set_initialSize(InitialCodeCacheSize);
  event.set_reservedSize(ReservedCodeCacheSize);
  event.set_nonNMethodSize(NonNMethodCodeHeapSize);
  event.set_profiledSize(ProfiledCodeHeapSize);
  event.set_nonProfiledSize(NonProfiledCodeHeapSize);
  event.set_expansionSize(CodeCacheExpansionSize);
  event.set_minBlockLength(CodeCacheMinBlockLength);
  event.set_startAddress((u8)CodeCache::low_bound());
  event.set_reservedTopAddress((u8)CodeCache::high_bound());
  event.commit();
}

TRACE_REQUEST_FUNC(CodeSweeperStatistics) {
  EventCodeSweeperStatistics event;
  event.set_sweepCount(NMethodSweeper::traversal_count());
  event.set_methodReclaimedCount(NMethodSweeper::total_nof_methods_reclaimed());
  event.set_totalSweepTime(NMethodSweeper::total_time_sweeping());
  event.set_peakFractionTime(NMethodSweeper::peak_sweep_fraction_time());
  event.set_peakSweepTime(NMethodSweeper::peak_sweep_time());
  event.commit();
}

TRACE_REQUEST_FUNC(CodeSweeperConfiguration) {
  EventCodeSweeperConfiguration event;
  event.set_sweeperEnabled(MethodFlushing);

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

TRACE_REQUEST_FUNC(CodeSweeperStatistics) {
  EventCodeSweeperStatistics event;
  event.set_sweepCount(NMethodSweeper::traversal_count());
  event.set_methodReclaimedCount(NMethodSweeper::total_nof_methods_reclaimed());
  event.set_totalSweepTime(NMethodSweeper::total_time_sweeping());
  event.set_peakFractionTime(NMethodSweeper::peak_sweep_fraction_time());
  event.set_peakSweepTime(NMethodSweeper::peak_sweep_time());
  event.commit();
}

TRACE_REQUEST_FUNC(CodeSweeperConfiguration) {
  EventCodeSweeperConfiguration event;
  event.set_sweeperEnabled(MethodFlushing);
  event.set_flushingEnabled(UseCodeCacheFlushing);
  event.set_sweepThreshold(NMethodSweeper::sweep_threshold_bytes());
  event.commit();
}


TRACE_REQUEST_FUNC(ShenandoahHeapRegionInformation) {
#if INCLUDE_SHENANDOAHGC
  if (UseShenandoahGC) {
    VM_ShenandoahSendHeapRegionInfoEvents op;

src/hotspot/share/compiler/compilerEvent.hpp:

#if INCLUDE_JFR
#include "jfr/utilities/jfrTime.hpp"
#endif

class ciMethod;
template <typename>
class GrowableArray;
class Method;
class EventCompilation;
class EventCompilationFailure;
class EventCompilerInlining;
class EventCompilerPhase;
struct JfrStructCalleeMethod;

class CompilerEvent : AllStatic {
 public:
  static jlong ticksNow() {
    // Using Ticks for consistent usage outside JFR folder.
    JFR_ONLY(return JfrTime::is_ft_enabled() ? Ticks::now().ft_value() : Ticks::now().value();) NOT_JFR_RETURN_(0L);
  }

  class CompilationEvent : AllStatic {
   public:
    static void post(EventCompilation& event, int compile_id, CompilerType type, Method* method, int compile_level, bool success, bool is_osr, int code_size, int inlined_bytecodes) NOT_JFR_RETURN();
  };

  class CompilationFailureEvent : AllStatic {
   public:
    static void post(EventCompilationFailure& event, int compile_id, const char* reason) NOT_JFR_RETURN();
  };

  class PhaseEvent : AllStatic {
    friend class CompilerPhaseTypeConstant;
   public:

src/hotspot/share/compiler/compileBroker.cpp:

  } else if (AbortVMOnCompilationFailure) {
    if (compilable == ciEnv::MethodCompilable_not_at_tier) {
      fatal("Not compilable at tier %d: %s", task->comp_level(), failure_reason);
    }
    if (compilable == ciEnv::MethodCompilable_never) {
      fatal("Never compilable: %s", failure_reason);
    }
  }
  // simulate crash during compilation
  assert(task->compile_id() != CICrashAt, "just as planned");
}

static void post_compilation_event(EventCompilation& event, CompileTask* task) {
  assert(task != NULL, "invariant");
  CompilerEvent::CompilationEvent::post(event,
                                        task->compile_id(),
                                        task->compiler()->type(),
                                        task->method(),
                                        task->comp_level(),
                                        task->is_success(),
                                        task->osr_bci() != CompileBroker::standard_entry_bci,
                                        (task->code() == NULL) ? 0 : task->code()->total_size(),
                                        task->num_inlined_bytecodes());
}

int DirectivesStack::_depth = 0;

src/hotspot/share/compiler/compileBroker.cpp:

  // Allocate a new set of JNI handles.
  push_jni_handle_block();
  Method* target_handle = task->method();
  int compilable = ciEnv::MethodCompilable;
  const char* failure_reason = NULL;
  bool failure_reason_on_C_heap = false;
  const char* retry_message = NULL;

#if INCLUDE_JVMCI
  if (UseJVMCICompiler && comp != NULL && comp->is_jvmci()) {
    JVMCICompiler* jvmci = (JVMCICompiler*) comp;

    TraceTime t1("compilation", &time);
    EventCompilation event;
    JVMCICompileState compile_state(task, jvmci);
    JVMCIRuntime *runtime = NULL;

    if (JVMCI::in_shutdown()) {
      failure_reason = "in JVMCI shutdown";
      retry_message = "not retryable";
      compilable = ciEnv::MethodCompilable_never;
    } else if (compile_state.target_method_is_old()) {
      // Skip redefined methods
      failure_reason = "redefined method";
      retry_message = "not retryable";

src/hotspot/share/compiler/compileBroker.cpp:

    bool method_is_old = ci_env.cache_jvmti_state();

    // Skip redefined methods
    if (method_is_old) {
      ci_env.record_method_not_compilable("redefined method", true);
    }

    // Cache DTrace flags
    ci_env.cache_dtrace_flags();

    ciMethod* target = ci_env.get_method_from_handle(target_handle);

    TraceTime t1("compilation", &time);
    EventCompilation event;

    if (comp == NULL) {
      ci_env.record_method_not_compilable("no compiler", !TieredCompilation);
    } else if (!ci_env.failing()) {
      if (WhiteBoxAPI && WhiteBox::compilation_locked) {
        MonitorLocker locker(Compilation_lock, Mutex::_no_safepoint_check_flag);
        while (WhiteBox::compilation_locked) {
          locker.wait();
        }
      }
      comp->compile_method(&ci_env, target, osr_bci, true, directive);

src/hotspot/share/compiler/compilerEvent.cpp:

  if (register_jfr_serializer) {
    JfrSerializer::register_serializer(TYPE_COMPILERPHASETYPE, false, new CompilerPhaseTypeConstant());
  } else if (Jfr::is_recording()) {
    // serialize new phase.
    JfrCheckpointWriter writer;
    writer.write_type(TYPE_COMPILERPHASETYPE);
    writer.write_count(1);
    writer.write_key(index);
    writer.write(phase_name);
  }
  return index;
}

void CompilerEvent::CompilationEvent::post(EventCompilation& event, int compile_id, CompilerType compiler_type, Method* method, int compile_level, bool success, bool is_osr, int code_size, int inlined_bytecodes) {
  event.set_compileId(compile_id);
  event.set_compiler(compiler_type);
  event.set_method(method);
  event.set_compileLevel((short)compile_level);
  event.set_succeded(success);
  event.set_isOsr(is_osr);
  event.set_codeSize(code_size);
  event.set_inlinedBytes(inlined_bytecodes);
  event.commit();
}

src/jdk.internal.vm.ci/share/classes/jdk.vm.ci.hotspot/src/jdk/vm/ci/hotspot/EventProvider.java:

     * Creates and returns an empty implementation for {@link EventProvider}. This implementation
     * can be used when no logging is requested.
     */
    static EventProvider createEmptyEventProvider() {
        return new EmptyEventProvider();
    }

    /**
     * Creates and returns an empty implementation for {@link CompilationEvent}.
     */
    static CompilationEvent createEmptyCompilationEvent() {
        return new EmptyCompilationEvent();
    }

    /**
     * Creates and returns an empty implementation for {@link CompilationEvent}.
     */
    static CompilerFailureEvent createEmptyCompilerFailureEvent() {
        return new EmptyCompilerFailureEvent();
    }

    /**
     * An instant event is an event that is not considered to have taken any time.

src/jdk.internal.vm.ci/share/classes/jdk.vm.ci.hotspot/src/jdk/vm/ci/hotspot/EventProvider.java:

        /**
         * Ends the timing period for this event.
         */
        void end();
    }

    /**
     * Creates a new {@link CompilationEvent}.
     *
     * @return a compilation event
     */
    CompilationEvent newCompilationEvent();

    /**
     * A compilation event.
     */
    public interface CompilationEvent extends TimedEvent {
        void setMethod(String method);

        void setCompileId(int compileId);

        void setCompileLevel(int compileLevel);

        void setSucceeded(boolean succeeded);

src/jdk.internal.vm.ci/share/classes/jdk.vm.ci.hotspot/src/jdk/vm/ci/hotspot/EmptyEventProvider.java:

package jdk.vm.ci.hotspot;

/**
 * An empty implementation for {@link EventProvider}. This implementation is used when no logging is
 * requested.
 */
final class EmptyEventProvider implements EventProvider {

    static InternalError shouldNotReachHere() {
        throw new InternalError("should not reach here");
    }

    @Override
    public CompilationEvent newCompilationEvent() {
        return new EmptyCompilationEvent();
    }

    static class EmptyCompilationEvent implements CompilationEvent {
        @Override
        public void commit() {
            throw shouldNotReachHere();
        }

        @Override
        public boolean shouldWrite() {
            // Events of this class should never been written.
            return false;
        }

src/hotspot/share/jvmci/jvmciCompilerToVM.cpp:

C2V_VMENTRY_0(jint, registerCompilerPhase, (JNIEnv* env, jobject, jstring jphase_name))
#if INCLUDE_JFR
  JVMCIObject phase_name = JVMCIENV->wrap(jphase_name);
  const char *name = JVMCIENV->as_utf8_string(phase_name);
  return CompilerEvent::PhaseEvent::get_phase_id(name, true, true, true);
#else
  return -1;
#endif // !INCLUDE_JFR
}

C2V_VMENTRY(void, notifyCompilerPhaseEvent, (JNIEnv* env, jobject, jlong startTime, jint phase, jint compileId, jint level))
  EventCompilerPhase event;
  if (event.should_commit()) {
    CompilerEvent::PhaseEvent::post(event, startTime, phase, compileId, level);
  }
}

C2V_VMENTRY(void, notifyCompilerInliningEvent, (JNIEnv* env, jobject, jint compileId, jobject caller, jobject callee, jboolean succeeded, jstring jmessage, jint bci))
  EventCompilerInlining event;
  if (event.should_commit()) {
    Method* caller_method = JVMCIENV->asMethod(caller);
    Method* callee_method = JVMCIENV->asMethod(callee);
    JVMCIObject message = JVMCIENV->wrap(jmessage);

src/hotspot/share/opto/compile.cpp:

    Node* n = macro_node(i);
    if (n->is_Allocate()) {
      if (i != allocates) {
        Node* tmp = macro_node(allocates);
        _macro_nodes.at_put(allocates, n);
        _macro_nodes.at_put(i, tmp);
      }
      allocates++;
    }
  }
}

void Compile::print_method(CompilerPhaseType cpt, const char *name, int level, int idx) {
  EventCompilerPhase event;
  if (event.should_commit()) {
    CompilerEvent::PhaseEvent::post(event, C->_latest_stage_start_counter, cpt, C->_compile_id, level);
  }
#ifndef PRODUCT
  if (should_print(level)) {
    _printer->print_method(name, level);
  }
#endif
  C->_latest_stage_start_counter.stamp();
}

src/hotspot/share/opto/compile.cpp:

void Compile::print_method(CompilerPhaseType cpt, Node* n, int level) {
  ResourceMark rm;
  stringStream ss;
  ss.print_raw(CompilerPhaseTypeHelper::to_string(cpt));
  if (n != NULL) {
    ss.print(": %d %s ", n->_idx, NodeClassNames[n->Opcode()]);
  } else {
    ss.print_raw(": NULL");
  }
  C->print_method(cpt, ss.as_string(), level);
}

void Compile::end_method(int level) {
  EventCompilerPhase event;
  if (event.should_commit()) {
    CompilerEvent::PhaseEvent::post(event, C->_latest_stage_start_counter, PHASE_END, C->_compile_id, level);
  }

#ifndef PRODUCT
  if (_method != NULL && should_print(level)) {
    _printer->end_method();
  }
#endif
}

src/hotspot/share/compiler/compilerEvent.hpp:

#if INCLUDE_JFR
#include "jfr/utilities/jfrTime.hpp"
#endif

class ciMethod;
template <typename>
class GrowableArray;
class Method;
class EventCompilation;
class EventCompilationFailure;
class EventCompilerInlining;
class EventCompilerPhase;
struct JfrStructCalleeMethod;

class CompilerEvent : AllStatic {
 public:
  static jlong ticksNow() {
    // Using Ticks for consistent usage outside JFR folder.
    JFR_ONLY(return JfrTime::is_ft_enabled() ? Ticks::now().ft_value() : Ticks::now().value();) NOT_JFR_RETURN_(0L);
  }

  class CompilationEvent : AllStatic {
   public:

src/hotspot/share/compiler/compilerEvent.hpp:

  class PhaseEvent : AllStatic {
    friend class CompilerPhaseTypeConstant;
   public:

    // Gets a unique identifier for `phase_name`, computing and registering it first if necessary.
    // If `may_exist` is true, then current registrations are searched first. If false, then
    // there must not be an existing registration for `phase_name`.
    // If `use_strdup` is true, then `phase_name` is strdup'ed before registration.
    // If `sync` is true, then access to the registration table is synchronized.
    static int get_phase_id(const char* phase_name, bool may_exist, bool use_strdup, bool sync) NOT_JFR_RETURN_(-1);

    static void post(EventCompilerPhase& event, const Ticks& start_time, int phase, int compile_id, int level) NOT_JFR_RETURN();
    static void post(EventCompilerPhase& event, jlong start_time, int phase, int compile_id, int level) {
      JFR_ONLY(post(event, Ticks(start_time), phase, compile_id, level);)
    }
  };

  class InlineEvent : AllStatic {
    static void post(EventCompilerInlining& event, int compile_id, Method* caller, const JfrStructCalleeMethod& callee, bool success, const char* msg, int bci) NOT_JFR_RETURN();
   public:
    static void post(EventCompilerInlining& event, int compile_id, Method* caller, Method* callee, bool success, const char* msg, int bci) NOT_JFR_RETURN();
    static void post(EventCompilerInlining& event, int compile_id, Method* caller, ciMethod* callee, bool success, const char* msg, int bci) NOT_JFR_RETURN();
  };
};

src/hotspot/share/compiler/compilerEvent.cpp:

  event.set_succeded(success);
  event.set_isOsr(is_osr);
  event.set_codeSize(code_size);
  event.set_inlinedBytes(inlined_bytecodes);
  event.commit();
}

void CompilerEvent::CompilationFailureEvent::post(EventCompilationFailure& event, int compile_id, const char* reason) {
  event.set_compileId(compile_id);
  event.set_failureMessage(reason);
  event.commit();
}

void CompilerEvent::PhaseEvent::post(EventCompilerPhase& event, const Ticks& start_time, int phase, int compile_id, int level) {
  event.set_starttime(start_time);
  event.set_phase((u1) phase);
  event.set_compileId(compile_id);
  event.set_phaseLevel((short)level);
  event.commit();
}

void CompilerEvent::InlineEvent::post(EventCompilerInlining& event, int compile_id, Method* caller, const JfrStructCalleeMethod& callee, bool success, const char* msg, int bci) {
  event.set_compileId(compile_id);
  event.set_caller(caller);
  event.set_callee(callee);

src/jdk.internal.vm.ci/share/classes/jdk.vm.ci.hotspot/src/jdk/vm/ci/hotspot/JFR.java:

        /**
         * @return current JFR time stamp
         */
        public static long now() {
            return compilerToVM().ticksNow();
        }
    }

    /**
     * Helper methods for managing JFR CompilerPhase events.
     * The events are defined in {see @code src/share/jfr/metadata/metadata.xml}.
     */
    public static final class CompilerPhaseEvent {

        private static final ConcurrentHashMap<String, Integer> phaseToId = new ConcurrentHashMap<>();

        private static int getPhaseToId(String phaseName) {
            return phaseToId.computeIfAbsent(phaseName, k -> compilerToVM().registerCompilerPhase(phaseName));
        }

        /**
         * Commits a CompilerPhase event.
         *
         * @param startTime time captured at the start of compiler phase

src/hotspot/share/compiler/compilerEvent.hpp:

#if INCLUDE_JFR
#include "jfr/utilities/jfrTime.hpp"
#endif

class ciMethod;
template <typename>
class GrowableArray;
class Method;
class EventCompilation;
class EventCompilationFailure;
class EventCompilerInlining;
class EventCompilerPhase;
struct JfrStructCalleeMethod;

class CompilerEvent : AllStatic {
 public:
  static jlong ticksNow() {
    // Using Ticks for consistent usage outside JFR folder.
    JFR_ONLY(return JfrTime::is_ft_enabled() ? Ticks::now().ft_value() : Ticks::now().value();) NOT_JFR_RETURN_(0L);
  }

  class CompilationEvent : AllStatic {
   public:
    static void post(EventCompilation& event, int compile_id, CompilerType type, Method* method, int compile_level, bool success, bool is_osr, int code_size, int inlined_bytecodes) NOT_JFR_RETURN();
  };

  class CompilationFailureEvent : AllStatic {
   public:
    static void post(EventCompilationFailure& event, int compile_id, const char* reason) NOT_JFR_RETURN();
  };

  class PhaseEvent : AllStatic {
    friend class CompilerPhaseTypeConstant;
   public:

    // Gets a unique identifier for `phase_name`, computing and registering it first if necessary.
    // If `may_exist` is true, then current registrations are searched first. If false, then
    // there must not be an existing registration for `phase_name`.
    // If `use_strdup` is true, then `phase_name` is strdup'ed before registration.
    // If `sync` is true, then access to the registration table is synchronized.

src/hotspot/share/compiler/compilerEvent.cpp:

void CompilerEvent::CompilationEvent::post(EventCompilation& event, int compile_id, CompilerType compiler_type, Method* method, int compile_level, bool success, bool is_osr, int code_size, int inlined_bytecodes) {
  event.set_compileId(compile_id);
  event.set_compiler(compiler_type);
  event.set_method(method);
  event.set_compileLevel((short)compile_level);
  event.set_succeded(success);
  event.set_isOsr(is_osr);
  event.set_codeSize(code_size);
  event.set_inlinedBytes(inlined_bytecodes);
  event.commit();
}

void CompilerEvent::CompilationFailureEvent::post(EventCompilationFailure& event, int compile_id, const char* reason) {
  event.set_compileId(compile_id);
  event.set_failureMessage(reason);
  event.commit();
}

void CompilerEvent::PhaseEvent::post(EventCompilerPhase& event, const Ticks& start_time, int phase, int compile_id, int level) {
  event.set_starttime(start_time);
  event.set_phase((u1) phase);
  event.set_compileId(compile_id);
  event.set_phaseLevel((short)level);
  event.commit();

src/hotspot/share/ci/ciEnv.cpp:

// ------------------------------------------------------------------
// ciEnv::record_failure()
void ciEnv::record_failure(const char* reason) {
  if (_failure_reason == NULL) {
    // Record the first failure reason.
    _failure_reason = reason;
  }
}

void ciEnv::report_failure(const char* reason) {
  EventCompilationFailure event;
  if (event.should_commit()) {
    CompilerEvent::CompilationFailureEvent::post(event, compile_id(), reason);
  }
}

// ------------------------------------------------------------------
// ciEnv::record_method_not_compilable()
void ciEnv::record_method_not_compilable(const char* reason, bool all_tiers) {
  int new_compilable =
    all_tiers ? MethodCompilable_never : MethodCompilable_not_at_tier ;

  // Only note transitions to a worse state
  if (new_compilable > _compilable) {

src/hotspot/share/jvmci/jvmciCompilerToVM.cpp:

#else
  return -1;
#endif // !INCLUDE_JFR
}

C2V_VMENTRY(void, notifyCompilerPhaseEvent, (JNIEnv* env, jobject, jlong startTime, jint phase, jint compileId, jint level))
  EventCompilerPhase event;
  if (event.should_commit()) {
    CompilerEvent::PhaseEvent::post(event, startTime, phase, compileId, level);
  }
}

C2V_VMENTRY(void, notifyCompilerInliningEvent, (JNIEnv* env, jobject, jint compileId, jobject caller, jobject callee, jboolean succeeded, jstring jmessage, jint bci))
  EventCompilerInlining event;
  if (event.should_commit()) {
    Method* caller_method = JVMCIENV->asMethod(caller);
    Method* callee_method = JVMCIENV->asMethod(callee);
    JVMCIObject message = JVMCIENV->wrap(jmessage);
    CompilerEvent::InlineEvent::post(event, compileId, caller_method, callee_method, succeeded, JVMCIENV->as_utf8_string(message), bci);
  }
}

#define CC (char*)  /*cast a literal from (const char*)*/
#define FN_PTR(f) CAST_FROM_FN_PTR(void*, &(c2v_ ## f))

src/hotspot/share/opto/bytecodeInfo.cpp:

  CompileTask::print_inlining_ul(callee_method, inline_level(),
                                               caller_bci, inline_msg);
  if (C->print_inlining()) {
    C->print_inlining(callee_method, inline_level(), caller_bci, inline_msg);
    guarantee(callee_method != NULL, "would crash in CompilerEvent::InlineEvent::post");
    if (Verbose) {
      const InlineTree *top = this;
      while (top->caller_tree() != NULL) { top = top->caller_tree(); }
      //tty->print("  bcs: %d+%d  invoked: %d", top->count_inline_bcs(), callee_method->code_size(), callee_method->interpreter_invocation_count());
    }
  }
  EventCompilerInlining event;
  if (event.should_commit()) {
    CompilerEvent::InlineEvent::post(event, C->compile_id(), caller_method->get_Method(), callee_method, success, inline_msg, caller_bci);
  }
}

//------------------------------ok_to_inline-----------------------------------
WarmCallInfo* InlineTree::ok_to_inline(ciMethod* callee_method, JVMState* jvms, ciCallProfile& profile, WarmCallInfo* initial_wci, bool& should_delay) {
  assert(callee_method != NULL, "caller checks for optimized virtual!");
  assert(!should_delay, "should be initialized to false");
#ifdef ASSERT
  // Make sure the incoming jvms has the same information content as me.

src/hotspot/share/compiler/compilerEvent.hpp:

#if INCLUDE_JFR
#include "jfr/utilities/jfrTime.hpp"
#endif

class ciMethod;
template <typename>
class GrowableArray;
class Method;
class EventCompilation;
class EventCompilationFailure;
class EventCompilerInlining;
class EventCompilerPhase;
struct JfrStructCalleeMethod;

class CompilerEvent : AllStatic {
 public:
  static jlong ticksNow() {
    // Using Ticks for consistent usage outside JFR folder.
    JFR_ONLY(return JfrTime::is_ft_enabled() ? Ticks::now().ft_value() : Ticks::now().value();) NOT_JFR_RETURN_(0L);
  }

src/hotspot/share/compiler/compilerEvent.hpp:

    // there must not be an existing registration for `phase_name`.
    // If `use_strdup` is true, then `phase_name` is strdup'ed before registration.
    // If `sync` is true, then access to the registration table is synchronized.
    static int get_phase_id(const char* phase_name, bool may_exist, bool use_strdup, bool sync) NOT_JFR_RETURN_(-1);

    static void post(EventCompilerPhase& event, const Ticks& start_time, int phase, int compile_id, int level) NOT_JFR_RETURN();
    static void post(EventCompilerPhase& event, jlong start_time, int phase, int compile_id, int level) {
      JFR_ONLY(post(event, Ticks(start_time), phase, compile_id, level);)
    }
  };

  class InlineEvent : AllStatic {
    static void post(EventCompilerInlining& event, int compile_id, Method* caller, const JfrStructCalleeMethod& callee, bool success, const char* msg, int bci) NOT_JFR_RETURN();
   public:
    static void post(EventCompilerInlining& event, int compile_id, Method* caller, Method* callee, bool success, const char* msg, int bci) NOT_JFR_RETURN();
    static void post(EventCompilerInlining& event, int compile_id, Method* caller, ciMethod* callee, bool success, const char* msg, int bci) NOT_JFR_RETURN();
  };
};
#endif // SHARE_COMPILER_COMPILEREVENT_HPP

src/hotspot/share/compiler/compilerEvent.cpp:

  event.set_compileId(compile_id);
  event.set_failureMessage(reason);
  event.commit();
}

void CompilerEvent::PhaseEvent::post(EventCompilerPhase& event, const Ticks& start_time, int phase, int compile_id, int level) {
  event.set_starttime(start_time);
  event.set_phase((u1) phase);
  event.set_compileId(compile_id);
  event.set_phaseLevel((short)level);
  event.commit();
}

void CompilerEvent::InlineEvent::post(EventCompilerInlining& event, int compile_id, Method* caller, const JfrStructCalleeMethod& callee, bool success, const char* msg, int bci) {
  event.set_compileId(compile_id);
  event.set_caller(caller);
  event.set_callee(callee);
  event.set_succeeded(success);
  event.set_message(msg);
  event.set_bci(bci);
  event.commit();
}

void CompilerEvent::InlineEvent::post(EventCompilerInlining& event, int compile_id, Method* caller, Method* callee, bool success, const char* msg, int bci) {
  JfrStructCalleeMethod callee_struct;
  callee_struct.set_type(callee->klass_name()->as_utf8());
  callee_struct.set_name(callee->name()->as_utf8());
  callee_struct.set_descriptor(callee->signature()->as_utf8());
  post(event, compile_id, caller, callee_struct, success, msg, bci);
}

void CompilerEvent::InlineEvent::post(EventCompilerInlining& event, int compile_id, Method* caller, ciMethod* callee, bool success, const char* msg, int bci) {
  JfrStructCalleeMethod callee_struct;
  callee_struct.set_type(callee->holder()->name()->as_utf8());
  callee_struct.set_name(callee->name()->as_utf8());
  callee_struct.set_descriptor(callee->signature()->as_symbol()->as_utf8());
  post(event, compile_id, caller, callee_struct, success, msg, bci);
}

src/hotspot/share/c1/c1_GraphBuilder.cpp:

void GraphBuilder::print_inlining(ciMethod* callee, const char* msg, bool success) {
  CompileLog* log = compilation()->log();
  if (log != NULL) {
    assert(msg != NULL, "inlining msg should not be null!");
    if (success) {
      log->inline_success(msg);
    } else {
      log->inline_fail(msg);
    }
  }
  EventCompilerInlining event;
  if (event.should_commit()) {
    CompilerEvent::InlineEvent::post(event, compilation()->env()->task()->compile_id(), method()->get_Method(), callee, success, msg, bci());
  }

  CompileTask::print_inlining_ul(callee, scope()->level(), bci(), msg);

  if (!compilation()->directive()->PrintInliningOption) {
    return;
  }
  CompileTask::print_inlining_tty(callee, scope()->level(), bci(), msg);
  if (success && CIPrintMethodCodes) {

src/jdk.internal.vm.ci/share/classes/jdk.vm.ci.hotspot/src/jdk/vm/ci/hotspot/JFR.java:

         * @param phaseName compiler phase name
         * @param compileId current compilation unit id
         * @param phaseLevel compiler phase nesting level
         */
        public static void write(long startTime, String phaseName, int compileId, int phaseLevel) {
            compilerToVM().notifyCompilerPhaseEvent(startTime, getPhaseToId(phaseName), compileId, phaseLevel);
        }
    }

    /**
     * Helper methods for managing JFR CompilerInlining events. The events are defined in {see @code
     * src/share/jfr/metadata/metadata.xml}.
     */
    public static final class CompilerInliningEvent {

        /**
         * Commits a CompilerInlining event.
         *
         * @param compileId current compilation unit id
         * @param caller caller method
         * @param callee callee method
         * @param succeeded inlining succeeded or not
         * @param message extra information on inlining
         * @param bci invocation byte code index
         */