/*

 * Copyright (c) 2016, 2019, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 *

 */

#include "precompiled.hpp"

#include "classfile/classLoaderDataGraph.hpp"

#include "classfile/javaClasses.inline.hpp"

#include "classfile/moduleEntry.hpp"

#include "classfile/packageEntry.hpp"

#include "classfile/symbolTable.hpp"

#include "jfr/jfr.hpp"

#include "jfr/jni/jfrGetAllEventClasses.hpp"

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

#include "jfr/recorder/checkpoint/types/jfrTypeSet.hpp"

#include "jfr/recorder/checkpoint/types/jfrTypeSetUtils.hpp"

#include "jfr/recorder/checkpoint/types/traceid/jfrTraceId.inline.hpp"

#include "jfr/utilities/jfrHashtable.hpp"

#include "jfr/utilities/jfrTypes.hpp"

#include "jfr/writers/jfrTypeWriterHost.hpp"

#include "memory/iterator.hpp"

#include "memory/resourceArea.hpp"

#include "oops/instanceKlass.hpp"

#include "oops/objArrayKlass.hpp"

#include "oops/oop.inline.hpp"

#include "utilities/accessFlags.hpp"

typedef const Klass* KlassPtr;

typedef const PackageEntry* PkgPtr;

typedef const ModuleEntry* ModPtr;

typedef const ClassLoaderData* CldPtr;

typedef const Method* MethodPtr;

typedef const Symbol* SymbolPtr;

typedef const JfrSymbolId::SymbolEntry* SymbolEntryPtr;

typedef const JfrSymbolId::CStringEntry* CStringEntryPtr;

static JfrCheckpointWriter* _writer = NULL;

static JfrCheckpointWriter* _leakp_writer = NULL;

static JfrArtifactSet* _artifacts = NULL;

static JfrArtifactClosure* _subsystem_callback = NULL;

static bool _class_unload = false;

static bool _flushpoint = false;

// 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 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, bool leakp) {

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

}

static traceid mark_symbol(Symbol* symbol, bool leakp) {

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

}

static traceid get_bootstrap_name(bool leakp) {

  return create_symbol_id(_artifacts->bootstrap_name(leakp));

}

template <typename T>

static traceid artifact_id(const T* ptr) {

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

  return TRACE_ID(ptr);

}

static traceid package_id(KlassPtr klass, bool leakp) {

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

  PkgPtr pkg_entry = klass->package();

  if (pkg_entry == NULL) {

    return 0;

  }

  if (leakp) {

    SET_LEAKP(pkg_entry);

  }

  // package implicitly tagged already

  return artifact_id(pkg_entry);

}

static traceid module_id(PkgPtr pkg, bool leakp) {

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

  ModPtr module_entry = pkg->module();

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

    return 0;

  }

  if (leakp) {

    SET_LEAKP(module_entry);

  } else {

    SET_TRANSIENT(module_entry);

  }

  return artifact_id(module_entry);

}

static traceid method_id(KlassPtr klass, MethodPtr method) {

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

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

  return METHOD_ID(klass, method);

}

static traceid cld_id(CldPtr cld, bool leakp) {

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

  if (cld->is_unsafe_anonymous()) {

    return 0;

  }

  if (leakp) {

    SET_LEAKP(cld);

  } else {

    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");

}

/*

 * In C++03, functions used as template parameters must have external linkage;

 * this restriction was removed in C++11. Change back to "static" and

 * rename functions when C++11 becomes available.

 *

 * The weird naming is an effort to decrease the risk of name clashes.

 */

static int write_klass(JfrCheckpointWriter* writer, KlassPtr klass, bool leakp) {

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

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

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

  traceid pkg_id = 0;

  KlassPtr theklass = klass;

  if (theklass->is_objArray_klass()) {

    const ObjArrayKlass* obj_arr_klass = ObjArrayKlass::cast(klass);

    theklass = obj_arr_klass->bottom_klass();

  }

  if (theklass->is_instance_klass()) {

    pkg_id = package_id(theklass, leakp);

  } else {

    assert(theklass->is_typeArray_klass(), "invariant");

  }

  writer->write(artifact_id(klass));

  writer->write(cld_id(klass->class_loader_data(), leakp));

  writer->write(mark_symbol(klass, leakp));

  writer->write(pkg_id);

  writer->write(get_flags(klass));

  return 1;

}

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

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

  KlassPtr klass = (KlassPtr)k;

  set_serialized(klass);

  return write_klass(writer, klass, false);

}

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

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

  KlassPtr klass = (KlassPtr)k;

  return write_klass(writer, klass, true);

}

static bool is_implied(const Klass* klass) {

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

  return klass->is_subclass_of(SystemDictionary::ClassLoader_klass()) || klass == SystemDictionary::Object_klass();

}

static void do_implied(Klass* klass) {

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

  if (is_implied(klass)) {

    if (_leakp_writer != NULL) {

      SET_LEAKP(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;

template <>

class LeakPredicate<const Klass*> {

public:

  LeakPredicate(bool class_unload) {}

  bool operator()(const Klass* klass) {

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

    return IS_LEAKP(klass) || is_implied(klass);

  }

};

typedef LeakPredicate<KlassPtr> LeakKlassPredicate;

typedef JfrPredicatedTypeWriterImplHost<KlassPtr, LeakKlassPredicate, write__klass__leakp> LeakKlassWriterImpl;

typedef JfrTypeWriterHost<LeakKlassWriterImpl, TYPE_CLASS> LeakKlassWriter;

typedef CompositeFunctor<KlassPtr, LeakKlassWriter, KlassWriter> CompositeKlassWriter;

typedef CompositeFunctor<KlassPtr, CompositeKlassWriter, KlassArtifactRegistrator> CompositeKlassWriterRegistration;

typedef JfrArtifactCallbackHost<KlassPtr, CompositeKlassWriterRegistration> CompositeKlassCallback;

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);

  if (_leakp_writer == NULL) {

    KlassCallback callback(&kwr);

    _subsystem_callback = &callback;

    do_klasses();

  } else {

    LeakKlassWriter lkw(_leakp_writer, _artifacts, _class_unload);

    CompositeKlassWriter ckw(&lkw, &kw);

    CompositeKlassWriterRegistration ckwr(&ckw, &reg);

    CompositeKlassCallback callback(&ckwr);

    _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");

    return;

  }

  if (IS_SERIALIZED(value)) {

    CLEAR_SERIALIZED(value);

  }

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

}

static int write_package(JfrCheckpointWriter* writer, PkgPtr pkg, bool leakp) {

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

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

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

  writer->write(artifact_id(pkg));

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

  writer->write(module_id(pkg, leakp));

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

  return 1;

}

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

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

  PkgPtr pkg = (PkgPtr)p;

  set_serialized(pkg);

  return write_package(writer, pkg, false);

}

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

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

  PkgPtr pkg = (PkgPtr)p;

  CLEAR_LEAKP(pkg);

  return write_package(writer, pkg, true);

}

static void do_package(PackageEntry* entry) {

  do_previous_epoch_artifact(_subsystem_callback, entry);

}

static void do_packages() {

  ClassLoaderDataGraph::packages_do(&do_package);

}

class PackageFieldSelector {

 public:

  typedef PkgPtr TypePtr;

  static TypePtr select(KlassPtr klass) {

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

    return ((InstanceKlass*)klass)->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;

typedef KlassToFieldEnvelope<PackageFieldSelector, PackageWriter> KlassPackageWriter;

typedef JfrArtifactCallbackHost<PkgPtr, PackageWriterWithClear> PackageCallback;

typedef LeakPredicate<PkgPtr> LeakPackagePredicate;

typedef JfrPredicatedTypeWriterImplHost<PkgPtr, LeakPackagePredicate, write__package__leakp> LeakPackageWriterImpl;

typedef JfrTypeWriterHost<LeakPackageWriterImpl, TYPE_PACKAGE> LeakPackageWriter;

typedef CompositeFunctor<PkgPtr, LeakPackageWriter, PackageWriter> CompositePackageWriter;

typedef KlassToFieldEnvelope<PackageFieldSelector, CompositePackageWriter> KlassCompositePackageWriter;

typedef KlassToFieldEnvelope<PackageFieldSelector, PackageWriterWithClear> KlassPackageWriterWithClear;

typedef CompositeFunctor<PkgPtr, CompositePackageWriter, ClearArtifact<PkgPtr> > CompositePackageWriterWithClear;

typedef JfrArtifactCallbackHost<PkgPtr, CompositePackageWriterWithClear> CompositePackageCallback;

static void write_packages() {

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

  PackageWriter pw(_writer, _class_unload);

  KlassPackageWriter kpw(&pw);

  if (current_epoch()) {

    _artifacts->iterate_klasses(kpw);

    _artifacts->tally(pw);

    return;

  }

  assert(previous_epoch(), "invariant");

  if (_leakp_writer == NULL) {

    _artifacts->iterate_klasses(kpw);

    ClearArtifact<PkgPtr> clear;

    PackageWriterWithClear pwwc(&pw, &clear);

    PackageCallback callback(&pwwc);

    _subsystem_callback = &callback;

    do_packages();

  } else {

    LeakPackageWriter lpw(_leakp_writer, _class_unload);

    CompositePackageWriter cpw(&lpw, &pw);

    KlassCompositePackageWriter kcpw(&cpw);

    _artifacts->iterate_klasses(kcpw);

    ClearArtifact<PkgPtr> clear;

    CompositePackageWriterWithClear cpwwc(&cpw, &clear);

    CompositePackageCallback callback(&cpwwc);

    _subsystem_callback = &callback;

    do_packages();

  }

  _artifacts->tally(pw);

}

static int write_module(JfrCheckpointWriter* writer, ModPtr mod, bool leakp) {

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

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

  writer->write(artifact_id(mod));

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

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

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

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

  return 1;

}

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

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

  ModPtr mod = (ModPtr)m;

  set_serialized(mod);

  return write_module(writer, mod, false);

}

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

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

  ModPtr mod = (ModPtr)m;

  CLEAR_LEAKP(mod);

  return write_module(writer, mod, true);

}

static void do_module(ModuleEntry* entry) {

  do_previous_epoch_artifact(_subsystem_callback, entry);

}

static void do_modules() {

  ClassLoaderDataGraph::modules_do(&do_module);

}

class ModuleFieldSelector {

 public:

  typedef ModPtr TypePtr;

  static TypePtr select(KlassPtr klass) {

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

    PkgPtr pkg = klass->package();

    return pkg != NULL ? pkg->module() : NULL;

  }

};

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;

typedef KlassToFieldEnvelope<ModuleFieldSelector, ModuleWriter> KlassModuleWriter;

typedef LeakPredicate<ModPtr> LeakModulePredicate;

typedef JfrPredicatedTypeWriterImplHost<ModPtr, LeakModulePredicate, write__module__leakp> LeakModuleWriterImpl;

typedef JfrTypeWriterHost<LeakModuleWriterImpl, TYPE_MODULE> LeakModuleWriter;

typedef CompositeFunctor<ModPtr, LeakModuleWriter, ModuleWriter> CompositeModuleWriter;

typedef KlassToFieldEnvelope<ModuleFieldSelector, CompositeModuleWriter> KlassCompositeModuleWriter;

typedef CompositeFunctor<ModPtr, CompositeModuleWriter, ClearArtifact<ModPtr> > CompositeModuleWriterWithClear;

typedef JfrArtifactCallbackHost<ModPtr, CompositeModuleWriterWithClear> CompositeModuleCallback;

static void write_modules() {

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

  ModuleWriter mw(_writer, _class_unload);

  KlassModuleWriter kmw(&mw);

  if (current_epoch()) {

    _artifacts->iterate_klasses(kmw);

    _artifacts->tally(mw);

    return;

  }

  assert(previous_epoch(), "invariant");

  if (_leakp_writer == NULL) {

    _artifacts->iterate_klasses(kmw);

    ClearArtifact<ModPtr> clear;

    ModuleWriterWithClear mwwc(&mw, &clear);

    ModuleCallback callback(&mwwc);

    _subsystem_callback = &callback;

    do_modules();

  } else {

    LeakModuleWriter lmw(_leakp_writer, _class_unload);

    CompositeModuleWriter cmw(&lmw, &mw);

    KlassCompositeModuleWriter kcpw(&cmw);

    _artifacts->iterate_klasses(kcpw);

    ClearArtifact<ModPtr> clear;

    CompositeModuleWriterWithClear cmwwc(&cmw, &clear);

    CompositeModuleCallback callback(&cmwwc);

    _subsystem_callback = &callback;