/*

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

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

}

}

}

template <typename T>

static traceid artifact_id(const T* ptr) {

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

  return TRACE_ID(ptr);

}

static traceid package_id(KlassPtr klass) {

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

  PkgPtr pkg_entry = klass->package();

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

}

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

  ModPtr module_entry = pkg->module();

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

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

}

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

  if (cld->is_unsafe_anonymous()) {

    return 0;

  }

  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.

 */

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

  assert(_artifacts != 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);

  } else {

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

  }

  writer->write(artifact_id(klass));

  writer->write(pkg_id);

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

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

}

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

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

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

  PkgPtr pkg = (PkgPtr)p;

  set_serialized(pkg);

}

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;

static void write_packages() {

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

  PackageWriter pw(_writer, _class_unload);

  KlassPackageWriter kpw(&pw);

    ClearArtifact<PkgPtr> clear;

    PackageWriterWithClear pwwc(&pw, &clear);

    PackageCallback callback(&pwwc);

    _subsystem_callback = &callback;

    do_packages();

  }

  _artifacts->tally(pw);

}

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

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

  ModPtr mod = (ModPtr)m;

  set_serialized(mod);

}

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;

static void write_modules() {

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

  ModuleWriter mw(_writer, _class_unload);

  KlassModuleWriter kmw(&mw);