#include "jfr/leakprofiler/checkpoint/objectSampleCheckpoint.hpp"

#include "jfr/writers/jfrTypeWriterHost.hpp"

// incremented on each rotation

static u8 checkpoint_id = 1;

// creates a unique id by combining a checkpoint relative symbol id (2^24)

// with the current checkpoint id (2^40)

#define CREATE_SYMBOL_ID(sym_id) (((u8)((checkpoint_id << 24) | sym_id)))

static traceid create_symbol_id(traceid artifact_id) {

  return artifact_id != 0 ? CREATE_SYMBOL_ID(artifact_id) : 0;

}

static JfrCheckpointWriter* _writer = NULL;

static bool _class_unload = false;

static bool _flushpoint = false;

static JfrArtifactSet* _artifacts = NULL;

static JfrArtifactClosure* _subsystem_callback = NULL;

static bool current_epoch() {

  return _class_unload || _flushpoint;

}

static bool previous_epoch() {

  return !current_epoch();

}

static bool is_complete() {

  return !_artifacts->has_klass_entries() && current_epoch();

}

static traceid mark_symbol(KlassPtr klass) {

  return klass != NULL ? create_symbol_id(_artifacts->mark(klass)) : 0;

}

static traceid mark_symbol(Symbol* symbol) {

  return symbol != NULL ? create_symbol_id(_artifacts->mark(symbol)) : 0;

}

template <typename T>

static traceid artifact_id(const T* ptr) {

  assert(ptr != NULL, "invariant");

  return TRACE_ID(ptr);

  return pkg_entry != NULL ? artifact_id(pkg_entry) : 0;

}

static traceid module_id(PkgPtr pkg) {

  assert(pkg != NULL, "invariant");

  ModPtr module_entry = pkg->module();

  if (module_entry != NULL && module_entry->is_named()) {

    SET_TRANSIENT(module_entry);

    return artifact_id(module_entry);

  }

  return 0;

}

static traceid method_id(KlassPtr klass, MethodPtr method) {

  assert(klass != NULL, "invariant");

  assert(method != NULL, "invariant");

  return METHOD_ID(klass, method);

  if (cld->is_unsafe_anonymous()) {

    return 0;

  }

  SET_TRANSIENT(cld);

  return artifact_id(cld);

template <typename T>

static s4 get_flags(const T* ptr) {

  assert(ptr != NULL, "invariant");

  return ptr->access_flags().get_flags();

template <typename T>

static void set_serialized(const T* ptr) {

  assert(ptr != NULL, "invariant");

  SET_SERIALIZED(ptr);

  assert(IS_SERIALIZED(ptr), "invariant");

}

int write__klass(JfrCheckpointWriter* writer, const void* k) {

  assert(_artifacts != NULL, "invariant");

  assert(k != NULL, "invariant");

  KlassPtr klass = (KlassPtr)k;

  writer->write(artifact_id(klass));

  writer->write(mark_symbol(klass));

  writer->write(get_flags(klass));

  set_serialized(klass);

static void do_implied(Klass* klass) {

  assert(klass != NULL, "invariant");

  if (klass->is_subclass_of(SystemDictionary::ClassLoader_klass()) || klass == SystemDictionary::Object_klass()) {

    _subsystem_callback->do_artifact(klass);

  }

static void do_unloaded_klass(Klass* klass) {

  assert(klass != NULL, "invariant");

  assert(_subsystem_callback != NULL, "invariant");

  if (IS_JDK_JFR_EVENT_SUBKLASS(klass)) {

    JfrEventClasses::increment_unloaded_event_class();

  if (USED_THIS_EPOCH(klass)) {

    ObjectSampleCheckpoint::on_klass_unload(klass);

    _subsystem_callback->do_artifact(klass);

    return;

  }

  do_implied(klass);

static void do_klass(Klass* klass) {

  assert(klass != NULL, "invariant");

  assert(_subsystem_callback != NULL, "invariant");

  if (_flushpoint) {

    if (USED_THIS_EPOCH(klass)) {

      _subsystem_callback->do_artifact(klass);

      return;

  } else {

    if (USED_PREV_EPOCH(klass)) {

      _subsystem_callback->do_artifact(klass);

      return;

    }

  do_implied(klass);

static void do_klasses() {

  if (_class_unload) {

    ClassLoaderDataGraph::classes_unloading_do(&do_unloaded_klass);

    return;

  ClassLoaderDataGraph::classes_do(&do_klass);

typedef SerializePredicate<KlassPtr> KlassPredicate;

typedef JfrPredicatedTypeWriterImplHost<KlassPtr, KlassPredicate, write__klass> KlassWriterImpl;

typedef JfrTypeWriterHost<KlassWriterImpl, TYPE_CLASS> KlassWriter;

typedef CompositeFunctor<KlassPtr, KlassWriter, KlassArtifactRegistrator> KlassWriterRegistration;

typedef JfrArtifactCallbackHost<KlassPtr, KlassWriterRegistration> KlassCallback;

static bool write_klasses() {

  assert(!_artifacts->has_klass_entries(), "invariant");

  assert(_writer != NULL, "invariant");

  KlassArtifactRegistrator reg(_artifacts);

  KlassWriter kw(_writer, _class_unload);

  KlassWriterRegistration kwr(&kw, &reg);

  KlassCallback callback(&kwr);

  _subsystem_callback = &callback;

  do_klasses();

  if (is_complete()) {

    return false;

  _artifacts->tally(kw);

  return true;

template <typename T>

static void do_previous_epoch_artifact(JfrArtifactClosure* callback, T* value) {

  assert(callback != NULL, "invariant");

  assert(value != NULL, "invariant");

  if (USED_PREV_EPOCH(value)) {

    callback->do_artifact(value);

    assert(IS_NOT_SERIALIZED(value), "invariant");

  if (IS_SERIALIZED(value)) {

    CLEAR_SERIALIZED(value);

  }

  assert(IS_NOT_SERIALIZED(value), "invariant");

int write__package(JfrCheckpointWriter* writer, const void* p) {

  assert(writer != NULL, "invariant");

  assert(_artifacts != NULL, "invariant");

  assert(p != NULL, "invariant");

  PkgPtr pkg = (PkgPtr)p;

  writer->write(artifact_id(pkg));

  writer->write(mark_symbol(pkg->name()));

  writer->write(module_id(pkg));

  writer->write((bool)pkg->is_exported());

  set_serialized(pkg);

  return 1;

}

static void do_package(PackageEntry* entry) {

  do_previous_epoch_artifact(_subsystem_callback, entry);

}

static void do_packages() {

  ClassLoaderDataGraph::packages_do(&do_package);

}

typedef SerializePredicate<PkgPtr> PackagePredicate;

typedef JfrPredicatedTypeWriterImplHost<PkgPtr, PackagePredicate, write__package> PackageWriterImpl;

typedef JfrTypeWriterHost<PackageWriterImpl, TYPE_PACKAGE> PackageWriter;

typedef CompositeFunctor<PkgPtr, PackageWriter, ClearArtifact<PkgPtr> > PackageWriterWithClear;

static void write_packages() {

  assert(_writer != NULL, "invariant");

  PackageWriter pw(_writer, _class_unload);

  KlassPackageWriter kpw(&pw);

  _artifacts->iterate_klasses(kpw);

  if (previous_epoch()) {

    ClearArtifact<PkgPtr> clear;

  _artifacts->tally(pw);

int write__module(JfrCheckpointWriter* writer, const void* m) {

  assert(m != NULL, "invariant");

  assert(_artifacts != NULL, "invariant");

  ModPtr mod = (ModPtr)m;

  writer->write(artifact_id(mod));

  writer->write(mark_symbol(mod->name()));

  writer->write(mark_symbol(mod->version()));

  writer->write(mark_symbol(mod->location()));

  writer->write(cld_id(mod->loader_data()));

  set_serialized(mod);

  return 1;

}

static void do_module(ModuleEntry* entry) {

  do_previous_epoch_artifact(_subsystem_callback, entry);

}

static void do_modules() {

  ClassLoaderDataGraph::modules_do(&do_module);

}

typedef SerializePredicate<ModPtr> ModulePredicate;

typedef JfrPredicatedTypeWriterImplHost<ModPtr, ModulePredicate, write__module> ModuleWriterImpl;

typedef JfrTypeWriterHost<ModuleWriterImpl, TYPE_MODULE> ModuleWriter;

typedef CompositeFunctor<ModPtr, ModuleWriter, ClearArtifact<ModPtr> > ModuleWriterWithClear;

typedef JfrArtifactCallbackHost<ModPtr, ModuleWriterWithClear> ModuleCallback;

static void write_modules() {

  assert(_writer != NULL, "invariant");

  ModuleWriter mw(_writer, _class_unload);

  KlassModuleWriter kmw(&mw);

  _artifacts->iterate_klasses(kmw);

  if (previous_epoch()) {

    ClearArtifact<ModPtr> clear;

  _artifacts->tally(mw);

int write__classloader(JfrCheckpointWriter* writer, const void* c) {

  assert(c != NULL, "invariant");

  CldPtr cld = (CldPtr)c;

  assert(!cld->is_unsafe_anonymous(), "invariant");

  // class loader type

  const Klass* class_loader_klass = cld->class_loader_klass();

  if (class_loader_klass == NULL) {

    // (primordial) boot class loader

    writer->write(artifact_id(cld)); // class loader instance id

    writer->write((traceid)0);  // class loader type id (absence of)

    writer->write(create_symbol_id(1)); // 1 maps to synthetic name -> "bootstrap"

  } else {

    writer->write(artifact_id(cld)); // class loader instance id

    writer->write(artifact_id(class_loader_klass)); // class loader type id

    writer->write(mark_symbol(cld->name())); // class loader instance name

  }

  set_serialized(cld);

  return 1;

}

static void do_class_loader_data(ClassLoaderData* cld) {

  do_previous_epoch_artifact(_subsystem_callback, cld);

}

class CLDCallback : public CLDClosure {

 public:

  CLDCallback() {}

  void do_cld(ClassLoaderData* cld) {

    assert(cld != NULL, "invariant");

    if (cld->is_unsafe_anonymous()) {

      return;

    }

    do_class_loader_data(cld);

  }

};

static void do_class_loaders() {

  CLDCallback cld_cb;

  ClassLoaderDataGraph::loaded_cld_do(&cld_cb);

typedef SerializePredicate<CldPtr> CldPredicate;

typedef JfrPredicatedTypeWriterImplHost<CldPtr, CldPredicate, write__classloader> CldWriterImpl;

typedef JfrTypeWriterHost<CldWriterImpl, TYPE_CLASSLOADER> CldWriter;

typedef CompositeFunctor<CldPtr, CldWriter, ClearArtifact<CldPtr> > CldWriterWithClear;

typedef JfrArtifactCallbackHost<CldPtr, CldWriterWithClear> CldCallback;

typedef KlassToFieldEnvelope<CldFieldSelector, CldWriter> KlassCldWriter;

static void write_classloaders() {

  assert(_writer != NULL, "invariant");

  CldWriter cldw(_writer, _class_unload);

  KlassCldWriter kcw(&cldw);

  _artifacts->iterate_klasses(kcw);

  if (previous_epoch()) {

    ClearArtifact<CldPtr> clear;

  _artifacts->tally(cldw);

}

static u1 get_visibility(MethodPtr method) {

  assert(method != NULL, "invariant");

  return const_cast<Method*>(method)->is_hidden() ? (u1)1 : (u1)0;

}

template <>

void set_serialized<Method>(MethodPtr method) {

  assert(method != NULL, "invariant");

  SET_METHOD_SERIALIZED(method);

  assert(IS_METHOD_SERIALIZED(method), "invariant");

int write__method(JfrCheckpointWriter* writer, const void* m) {

  assert(writer != NULL, "invariant");

  assert(_artifacts != NULL, "invariant");

  assert(m != NULL, "invariant");

  MethodPtr method = (MethodPtr)m;

  KlassPtr klass = method->method_holder();

  assert(klass != NULL, "invariant");

  assert(METHOD_USED_ANY_EPOCH(klass), "invariant");

  writer->write(method_id(klass, method));

  writer->write(artifact_id(klass));

  writer->write(mark_symbol(method->name()));

  writer->write(mark_symbol(method->signature()));

  writer->write((u2)get_flags(method));

  writer->write(get_visibility(method));

  set_serialized(method);

  return 1;

}

template <typename MethodCallback, typename KlassCallback>

  MethodCallback _method_cb;

  KlassCallback _klass_cb;

  MethodUsedPredicate _method_used_predicate;

                     bool current_epoch = false,

                     bool class_unload = false,

    _method_cb(writer, class_unload, skip_header),

    _klass_cb(writer, class_unload, skip_header),

      const InstanceKlass* const ik = InstanceKlass::cast(klass);

          _method_cb(method);

    return _klass_cb(klass);

  int count() const { return _method_cb.count(); }

  void add(int count) { _method_cb.add(count); }