/*

 * Copyright (c) 2017, 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 "jfr/recorder/checkpoint/types/jfrTypeSetUtils.hpp"

#include "oops/instanceKlass.hpp"

#include "oops/oop.inline.hpp"

#include "oops/symbol.hpp"

JfrSymbolId::JfrSymbolId() :

  _sym_table(new SymbolTable(this)),

  _cstring_table(new CStringTable(this)),

  _sym_list(NULL),

  _cstring_list(NULL),

  _symbol_id_counter(0),

  _class_unload(false) {

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

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

}

JfrSymbolId::~JfrSymbolId() {

  clear();

  delete _sym_table;

  delete _cstring_table;

}

void JfrSymbolId::clear() {

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

  if (_sym_table->has_entries()) {

    _sym_table->clear_entries();

  }

  assert(!_sym_table->has_entries(), "invariant");

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

  if (_cstring_table->has_entries()) {

    _cstring_table->clear_entries();

  }

  assert(!_cstring_table->has_entries(), "invariant");

  _sym_list = NULL;

  _cstring_list = NULL;

  _symbol_id_counter = 0;

}

void JfrSymbolId::set_class_unload(bool class_unload) {

  _class_unload = class_unload;

}

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

  const_cast<Symbol*>(entry->literal())->increment_refcount();

  assert(entry->id() == 0, "invariant");

  entry->set_id(++_symbol_id_counter);

  entry->set_list_next(_sym_list);

  _sym_list = entry;

}

  // query might be NULL

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

  assert(entry->hash() == hash, "invariant");

  return true;

}

void JfrSymbolId::unlink(const SymbolEntry* entry) {

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

  const_cast<Symbol*>(entry->literal())->decrement_refcount();

}

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

  assert(entry->id() == 0, "invariant");

  entry->set_id(++_symbol_id_counter);

  entry->set_list_next(_cstring_list);

  _cstring_list = entry;

}

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

  assert(entry->hash() == hash, "invariant");

  return true;

}

void JfrSymbolId::unlink(const CStringEntry* entry) {

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

  if (entry->id() != 1) {

  }

}

}

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

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

  if (_class_unload) {

    entry.set_unloading();

  }

}

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

  if (_class_unload) {

    entry.set_unloading();

  }

}

/*

* jsr292 anonymous classes symbol is the external name +

* the identity_hashcode slash appended:

*   java.lang.invoke.LambdaForm$BMH/22626602

*

* caller needs ResourceMark

*/

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

  assert(ik->is_unsafe_anonymous(), "invariant");

  const oop mirror = ik->java_mirror_no_keepalive();

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

  return (uintptr_t)mirror->identity_hash();

}

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

  assert(ik->is_unsafe_anonymous(), "invariant");

  char* anonymous_symbol = NULL;

  const oop mirror = ik->java_mirror_no_keepalive();

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

  char hash_buf[40];

  const size_t hash_len = strlen(hash_buf);

  const size_t result_len = ik->name()->utf8_length();

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

  ik->name()->as_klass_external_name(anonymous_symbol, (int)result_len + 1);

  assert(strlen(anonymous_symbol) == result_len, "invariant");

  strcpy(anonymous_symbol + result_len, hash_buf);

  assert(strlen(anonymous_symbol) == result_len + hash_len, "invariant");

  return anonymous_symbol;

}

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

}

static void preload_bootstrap_loader_name(JfrSymbolId* symbol_id) {

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

  assert(!symbol_id->has_entries(), "invariant");

}

JfrArtifactSet::JfrArtifactSet(bool class_unload) : _symbol_id(new JfrSymbolId()),

                                                     _klass_list(NULL),

                                                     _total_count(0) {

  preload_bootstrap_loader_name(_symbol_id);

  initialize(class_unload);

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

}

static const size_t initial_class_list_size = 200;

void JfrArtifactSet::initialize(bool class_unload) {

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

  _symbol_id->set_class_unload(class_unload);

  _total_count = 0;

  // resource allocation

  _klass_list = new GrowableArray<const Klass*>(initial_class_list_size, false, mtTracing);

}

JfrArtifactSet::~JfrArtifactSet() {

  clear();

  delete _symbol_id;

}

void JfrArtifactSet::clear() {

  _symbol_id->clear();

  preload_bootstrap_loader_name(_symbol_id);

  // _klass_list will be cleared by a ResourceMark

}

}

}

}

}

}

bool JfrArtifactSet::has_klass_entries() const {

  return _klass_list->is_nonempty();

}

int JfrArtifactSet::entries() const {

  return _klass_list->length();

}

void JfrArtifactSet::register_klass(const Klass* k) {

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

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

  assert(_klass_list->find(k) == -1, "invariant");

  _klass_list->append(k);

}

size_t JfrArtifactSet::total_count() const {

  return _total_count;

}