/*

 * Copyright (c) 2000, 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/systemDictionary.hpp"

#include "compiler/compilerOracle.hpp"

#include "interpreter/bytecode.hpp"

#include "interpreter/bytecodeStream.hpp"

#include "interpreter/linkResolver.hpp"

#include "memory/heapInspection.hpp"

#include "memory/metaspaceClosure.hpp"

#include "memory/resourceArea.hpp"

#include "oops/methodData.inline.hpp"

#include "prims/jvmtiRedefineClasses.hpp"

#include "runtime/arguments.hpp"

#include "runtime/compilationPolicy.hpp"

#include "runtime/deoptimization.hpp"

#include "runtime/handles.inline.hpp"

#include "runtime/orderAccess.hpp"

#include "runtime/safepointVerifiers.hpp"

#include "utilities/align.hpp"

#include "utilities/copy.hpp"

// ==================================================================

// DataLayout

//

// Overlay for generic profiling data.

// Some types of data layouts need a length field.

bool DataLayout::needs_array_len(u1 tag) {

  return (tag == multi_branch_data_tag) || (tag == arg_info_data_tag) || (tag == parameters_type_data_tag);

}

// Perform generic initialization of the data.  More specific

// initialization occurs in overrides of ProfileData::post_initialize.

void DataLayout::initialize(u1 tag, u2 bci, int cell_count) {

  _header._bits = (intptr_t)0;

  _header._struct._tag = tag;

  _header._struct._bci = bci;

  for (int i = 0; i < cell_count; i++) {

    set_cell_at(i, (intptr_t)0);

  }

  if (needs_array_len(tag)) {

    set_cell_at(ArrayData::array_len_off_set, cell_count - 1); // -1 for header.

  }

  if (tag == call_type_data_tag) {

    CallTypeData::initialize(this, cell_count);

  } else if (tag == virtual_call_type_data_tag) {

    VirtualCallTypeData::initialize(this, cell_count);

  }

}

void DataLayout::clean_weak_klass_links(bool always_clean) {

  ResourceMark m;

  data_in()->clean_weak_klass_links(always_clean);

}

// ==================================================================

// ProfileData

//

// A ProfileData object is created to refer to a section of profiling

// data in a structured way.

// Constructor for invalid ProfileData.

ProfileData::ProfileData() {

  _data = NULL;

}

char* ProfileData::print_data_on_helper(const MethodData* md) const {

  DataLayout* dp  = md->extra_data_base();

  DataLayout* end = md->args_data_limit();

  stringStream ss;

  for (;; dp = MethodData::next_extra(dp)) {

    assert(dp < end, "moved past end of extra data");

    switch(dp->tag()) {

    case DataLayout::speculative_trap_data_tag:

      if (dp->bci() == bci()) {

        SpeculativeTrapData* data = new SpeculativeTrapData(dp);

        int trap = data->trap_state();

        char buf[100];

        ss.print("trap/");

        data->method()->print_short_name(&ss);

        ss.print("(%s) ", Deoptimization::format_trap_state(buf, sizeof(buf), trap));

      }

      break;

    case DataLayout::bit_data_tag:

      break;

    case DataLayout::no_tag:

    case DataLayout::arg_info_data_tag:

      return ss.as_string();

      break;

    default:

      fatal("unexpected tag %d", dp->tag());

    }

  }

  return NULL;

}

void ProfileData::print_data_on(outputStream* st, const MethodData* md) const {

  print_data_on(st, print_data_on_helper(md));

}

void ProfileData::print_shared(outputStream* st, const char* name, const char* extra) const {

  st->print("bci: %d", bci());

  st->fill_to(tab_width_one);

  st->print("%s", name);

  tab(st);

  int trap = trap_state();

  if (trap != 0) {

    char buf[100];

    st->print("trap(%s) ", Deoptimization::format_trap_state(buf, sizeof(buf), trap));

  }

  if (extra != NULL) {

    st->print("%s", extra);

  }

  int flags = data()->flags();

  if (flags != 0) {

    st->print("flags(%d) ", flags);

  }

}

void ProfileData::tab(outputStream* st, bool first) const {

  st->fill_to(first ? tab_width_one : tab_width_two);

}

// ==================================================================

// BitData

//

// A BitData corresponds to a one-bit flag.  This is used to indicate

// whether a checkcast bytecode has seen a null value.

void BitData::print_data_on(outputStream* st, const char* extra) const {

  print_shared(st, "BitData", extra);

  st->cr();

}

// ==================================================================

// CounterData

//

// A CounterData corresponds to a simple counter.

void CounterData::print_data_on(outputStream* st, const char* extra) const {

  print_shared(st, "CounterData", extra);

  st->print_cr("count(%u)", count());

}

// ==================================================================

// JumpData

//

// A JumpData is used to access profiling information for a direct

// branch.  It is a counter, used for counting the number of branches,

// plus a data displacement, used for realigning the data pointer to

// the corresponding target bci.

void JumpData::post_initialize(BytecodeStream* stream, MethodData* mdo) {

  assert(stream->bci() == bci(), "wrong pos");

  int target;

  Bytecodes::Code c = stream->code();

  if (c == Bytecodes::_goto_w || c == Bytecodes::_jsr_w) {

    target = stream->dest_w();

  } else {

    target = stream->dest();

  }

  int my_di = mdo->dp_to_di(dp());

  int target_di = mdo->bci_to_di(target);

  int offset = target_di - my_di;

  set_displacement(offset);

}

void JumpData::print_data_on(outputStream* st, const char* extra) const {

  print_shared(st, "JumpData", extra);

  st->print_cr("taken(%u) displacement(%d)", taken(), displacement());

}

int TypeStackSlotEntries::compute_cell_count(Symbol* signature, bool include_receiver, int max) {

  // Parameter profiling include the receiver

  int args_count = include_receiver ? 1 : 0;

  ResourceMark rm;

  SignatureStream ss(signature);

  args_count += ss.reference_parameter_count();

  args_count = MIN2(args_count, max);

  return args_count * per_arg_cell_count;

}

int TypeEntriesAtCall::compute_cell_count(BytecodeStream* stream) {

  assert(Bytecodes::is_invoke(stream->code()), "should be invoke");

  assert(TypeStackSlotEntries::per_arg_count() > ReturnTypeEntry::static_cell_count(), "code to test for arguments/results broken");

  const methodHandle m = stream->method();

  int bci = stream->bci();

  Bytecode_invoke inv(m, bci);

  int args_cell = 0;

  if (MethodData::profile_arguments_for_invoke(m, bci)) {

    args_cell = TypeStackSlotEntries::compute_cell_count(inv.signature(), false, TypeProfileArgsLimit);

  }

  int ret_cell = 0;

  if (MethodData::profile_return_for_invoke(m, bci) && (inv.result_type() == T_OBJECT || inv.result_type() == T_ARRAY)) {

    ret_cell = ReturnTypeEntry::static_cell_count();

  }

  int header_cell = 0;

  if (args_cell + ret_cell > 0) {

    header_cell = header_cell_count();

  }

  return header_cell + args_cell + ret_cell;

}

class ArgumentOffsetComputer : public SignatureInfo {

private:

  int _max;

  GrowableArray<int> _offsets;

  void set(int size, BasicType type) { _size += size; }

  void do_object(int begin, int end) {

    if (_offsets.length() < _max) {

      _offsets.push(_size);

    }

    SignatureInfo::do_object(begin, end);

  }

  void do_array (int begin, int end) {

    if (_offsets.length() < _max) {

      _offsets.push(_size);

    }

    SignatureInfo::do_array(begin, end);

  }

public:

  ArgumentOffsetComputer(Symbol* signature, int max)

    : SignatureInfo(signature), _max(max), _offsets(Thread::current(), max) {

  }

  int total() { lazy_iterate_parameters(); return _size; }

  int off_at(int i) const { return _offsets.at(i); }

};

void TypeStackSlotEntries::post_initialize(Symbol* signature, bool has_receiver, bool include_receiver) {

  ResourceMark rm;

  int start = 0;

  // Parameter profiling include the receiver

  if (include_receiver && has_receiver) {

    set_stack_slot(0, 0);

    set_type(0, type_none());

    start += 1;

  }

  ArgumentOffsetComputer aos(signature, _number_of_entries-start);

  aos.total();

  for (int i = start; i < _number_of_entries; i++) {

    set_stack_slot(i, aos.off_at(i-start) + (has_receiver ? 1 : 0));

    set_type(i, type_none());

  }

}

void CallTypeData::post_initialize(BytecodeStream* stream, MethodData* mdo) {

  assert(Bytecodes::is_invoke(stream->code()), "should be invoke");

  Bytecode_invoke inv(stream->method(), stream->bci());

  SignatureStream ss(inv.signature());

  if (has_arguments()) {

#ifdef ASSERT

    ResourceMark rm;

    int count = MIN2(ss.reference_parameter_count(), (int)TypeProfileArgsLimit);

    assert(count > 0, "room for args type but none found?");

    check_number_of_arguments(count);

#endif

    _args.post_initialize(inv.signature(), inv.has_receiver(), false);

  }

  if (has_return()) {

    assert(inv.result_type() == T_OBJECT || inv.result_type() == T_ARRAY, "room for a ret type but doesn't return obj?");

    _ret.post_initialize();

  }

}

void VirtualCallTypeData::post_initialize(BytecodeStream* stream, MethodData* mdo) {

  assert(Bytecodes::is_invoke(stream->code()), "should be invoke");

  Bytecode_invoke inv(stream->method(), stream->bci());

  if (has_arguments()) {

#ifdef ASSERT

    ResourceMark rm;

    SignatureStream ss(inv.signature());

    int count = MIN2(ss.reference_parameter_count(), (int)TypeProfileArgsLimit);

    assert(count > 0, "room for args type but none found?");

    check_number_of_arguments(count);

#endif

    _args.post_initialize(inv.signature(), inv.has_receiver(), false);

  }

  if (has_return()) {

    assert(inv.result_type() == T_OBJECT || inv.result_type() == T_ARRAY, "room for a ret type but doesn't return obj?");

    _ret.post_initialize();

  }

}

void TypeStackSlotEntries::clean_weak_klass_links(bool always_clean) {

  for (int i = 0; i < _number_of_entries; i++) {

    intptr_t p = type(i);

    Klass* k = (Klass*)klass_part(p);

    if (k != NULL && (always_clean || !k->is_loader_alive())) {

      set_type(i, with_status((Klass*)NULL, p));

    }

  }

}

void ReturnTypeEntry::clean_weak_klass_links(bool always_clean) {

  intptr_t p = type();

  Klass* k = (Klass*)klass_part(p);

  if (k != NULL && (always_clean || !k->is_loader_alive())) {

    set_type(with_status((Klass*)NULL, p));

  }

}

bool TypeEntriesAtCall::return_profiling_enabled() {

  return MethodData::profile_return();

}

bool TypeEntriesAtCall::arguments_profiling_enabled() {

  return MethodData::profile_arguments();

}

void TypeEntries::print_klass(outputStream* st, intptr_t k) {

  if (is_type_none(k)) {

    st->print("none");

  } else if (is_type_unknown(k)) {

    st->print("unknown");

  } else {

    valid_klass(k)->print_value_on(st);

  }

  if (was_null_seen(k)) {

    st->print(" (null seen)");

  }

}

void TypeStackSlotEntries::print_data_on(outputStream* st) const {

  for (int i = 0; i < _number_of_entries; i++) {

    _pd->tab(st);

    st->print("%d: stack(%u) ", i, stack_slot(i));

    print_klass(st, type(i));

    st->cr();

  }

}

void ReturnTypeEntry::print_data_on(outputStream* st) const {

  _pd->tab(st);

  print_klass(st, type());

  st->cr();

}

void CallTypeData::print_data_on(outputStream* st, const char* extra) const {

  CounterData::print_data_on(st, extra);

  if (has_arguments()) {

    tab(st, true);

    st->print("argument types");

    _args.print_data_on(st);

  }

  if (has_return()) {

    tab(st, true);

    st->print("return type");

    _ret.print_data_on(st);

  }

}

void VirtualCallTypeData::print_data_on(outputStream* st, const char* extra) const {

  VirtualCallData::print_data_on(st, extra);

  if (has_arguments()) {

    tab(st, true);

    st->print("argument types");

    _args.print_data_on(st);

  }

  if (has_return()) {

    tab(st, true);

    st->print("return type");

    _ret.print_data_on(st);

  }

}

// ==================================================================

// ReceiverTypeData

//

// A ReceiverTypeData is used to access profiling information about a

// dynamic type check.  It consists of a counter which counts the total times

// that the check is reached, and a series of (Klass*, count) pairs

// which are used to store a type profile for the receiver of the check.

void ReceiverTypeData::clean_weak_klass_links(bool always_clean) {

    for (uint row = 0; row < row_limit(); row++) {

    Klass* p = receiver(row);

    if (p != NULL && (always_clean || !p->is_loader_alive())) {

      clear_row(row);

    }

  }

}

#if INCLUDE_JVMCI

void VirtualCallData::clean_weak_klass_links(bool always_clean) {

  ReceiverTypeData::clean_weak_klass_links(always_clean);

  for (uint row = 0; row < method_row_limit(); row++) {

    Method* p = method(row);

    if (p != NULL && (always_clean || !p->method_holder()->is_loader_alive())) {

      clear_method_row(row);

    }

  }

}

void VirtualCallData::clean_weak_method_links() {

  ReceiverTypeData::clean_weak_method_links();

  for (uint row = 0; row < method_row_limit(); row++) {

    Method* p = method(row);

    if (p != NULL && p->is_old()) {

      clear_method_row(row);

    }

  }

}

#endif // INCLUDE_JVMCI

void ReceiverTypeData::print_receiver_data_on(outputStream* st) const {

  uint row;

  int entries = 0;

  for (row = 0; row < row_limit(); row++) {

    if (receiver(row) != NULL)  entries++;

  }

#if INCLUDE_JVMCI

  st->print_cr("count(%u) nonprofiled_count(%u) entries(%u)", count(), nonprofiled_count(), entries);

#else

  st->print_cr("count(%u) entries(%u)", count(), entries);

#endif

  int total = count();

  for (row = 0; row < row_limit(); row++) {

    if (receiver(row) != NULL) {

      total += receiver_count(row);

    }

  }

  for (row = 0; row < row_limit(); row++) {

    if (receiver(row) != NULL) {

      tab(st);

      receiver(row)->print_value_on(st);

      st->print_cr("(%u %4.2f)", receiver_count(row), (float) receiver_count(row) / (float) total);

    }

  }

}

void ReceiverTypeData::print_data_on(outputStream* st, const char* extra) const {

  print_shared(st, "ReceiverTypeData", extra);

  print_receiver_data_on(st);

}

#if INCLUDE_JVMCI

void VirtualCallData::print_method_data_on(outputStream* st) const {

  uint row;

  int entries = 0;

  for (row = 0; row < method_row_limit(); row++) {

    if (method(row) != NULL) entries++;

  }

  tab(st);

  st->print_cr("method_entries(%u)", entries);

  int total = count();

  for (row = 0; row < method_row_limit(); row++) {

    if (method(row) != NULL) {

      total += method_count(row);

    }

  }

  for (row = 0; row < method_row_limit(); row++) {

    if (method(row) != NULL) {

      tab(st);

      method(row)->print_value_on(st);

      st->print_cr("(%u %4.2f)", method_count(row), (float) method_count(row) / (float) total);

    }

  }

}

#endif // INCLUDE_JVMCI

void VirtualCallData::print_data_on(outputStream* st, const char* extra) const {

  print_shared(st, "VirtualCallData", extra);