/*

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

#include "classfile/systemDictionary.hpp"

#include "code/codeCache.hpp"

#include "code/debugInfoRec.hpp"

#include "gc/shared/collectedHeap.inline.hpp"

#include "interpreter/bytecodeStream.hpp"

#include "interpreter/bytecodeTracer.hpp"

#include "interpreter/bytecodes.hpp"

#include "interpreter/interpreter.hpp"

#include "interpreter/oopMapCache.hpp"

#include "memory/allocation.inline.hpp"

#include "memory/heapInspection.hpp"

#include "memory/metadataFactory.hpp"

#include "memory/metaspaceClosure.hpp"

#include "memory/metaspaceShared.hpp"

#include "memory/oopFactory.hpp"

#include "memory/resourceArea.hpp"

#include "memory/universe.hpp"

#include "oops/constMethod.hpp"

#include "oops/constantPool.hpp"

#include "oops/method.inline.hpp"

#include "oops/methodData.hpp"

#include "oops/objArrayKlass.hpp"

#include "oops/objArrayOop.inline.hpp"

#include "oops/oop.inline.hpp"

#include "oops/symbol.hpp"

#include "prims/jvmtiExport.hpp"

#include "prims/methodHandles.hpp"

#include "prims/nativeLookup.hpp"

#include "runtime/arguments.hpp"

#include "runtime/compilationPolicy.hpp"

#include "runtime/frame.inline.hpp"

#include "runtime/handles.inline.hpp"

#include "runtime/init.hpp"

#include "runtime/orderAccess.hpp"

#include "runtime/relocator.hpp"

#include "runtime/safepointVerifiers.hpp"

#include "runtime/sharedRuntime.hpp"

#include "runtime/signature.hpp"

#include "utilities/align.hpp"

#include "utilities/quickSort.hpp"

#include "utilities/vmError.hpp"

#include "utilities/xmlstream.hpp"

// Implementation of Method

Method* Method::allocate(ClassLoaderData* loader_data,

                         int byte_code_size,

                         AccessFlags access_flags,

                         InlineTableSizes* sizes,

                         ConstMethod::MethodType method_type,

                         TRAPS) {

  assert(!access_flags.is_native() || byte_code_size == 0,

         "native methods should not contain byte codes");

  ConstMethod* cm = ConstMethod::allocate(loader_data,

                                          byte_code_size,

                                          sizes,

                                          method_type,

                                          CHECK_NULL);

  int size = Method::size(access_flags.is_native());

  return new (loader_data, size, MetaspaceObj::MethodType, THREAD) Method(cm, access_flags);

}

Method::Method(ConstMethod* xconst, AccessFlags access_flags) {

  NoSafepointVerifier no_safepoint;

  set_constMethod(xconst);

  set_access_flags(access_flags);

  set_intrinsic_id(vmIntrinsics::_none);

  set_force_inline(false);

  set_hidden(false);

  set_dont_inline(false);

  set_has_injected_profile(false);

  set_method_data(NULL);

  clear_method_counters();

  set_vtable_index(Method::garbage_vtable_index);

  // Fix and bury in Method*

  set_interpreter_entry(NULL); // sets i2i entry and from_int

  set_adapter_entry(NULL);

  clear_code(false /* don't need a lock */); // from_c/from_i get set to c2i/i2i

  if (access_flags.is_native()) {

    clear_native_function();

    set_signature_handler(NULL);

  }

  NOT_PRODUCT(set_compiled_invocation_count(0);)

}

// Release Method*.  The nmethod will be gone when we get here because

// we've walked the code cache.

void Method::deallocate_contents(ClassLoaderData* loader_data) {

  MetadataFactory::free_metadata(loader_data, constMethod());

  set_constMethod(NULL);

#if INCLUDE_JVMCI

  if (method_data()) {

    FailedSpeculation::free_failed_speculations(method_data()->get_failed_speculations_address());

  }

#endif

  MetadataFactory::free_metadata(loader_data, method_data());

  set_method_data(NULL);

  MetadataFactory::free_metadata(loader_data, method_counters());

  clear_method_counters();

  // The nmethod will be gone when we get here.

  if (code() != NULL) _code = NULL;

}

address Method::get_i2c_entry() {

  assert(adapter() != NULL, "must have");

  return adapter()->get_i2c_entry();

}

address Method::get_c2i_entry() {

  assert(adapter() != NULL, "must have");

  return adapter()->get_c2i_entry();

}

address Method::get_c2i_unverified_entry() {

  assert(adapter() != NULL, "must have");

  return adapter()->get_c2i_unverified_entry();

}

char* Method::name_and_sig_as_C_string() const {

  return name_and_sig_as_C_string(constants()->pool_holder(), name(), signature());

}

char* Method::name_and_sig_as_C_string(char* buf, int size) const {

  return name_and_sig_as_C_string(constants()->pool_holder(), name(), signature(), buf, size);

}

char* Method::name_and_sig_as_C_string(Klass* klass, Symbol* method_name, Symbol* signature) {

  const char* klass_name = klass->external_name();

  int klass_name_len  = (int)strlen(klass_name);

  int method_name_len = method_name->utf8_length();

  int len             = klass_name_len + 1 + method_name_len + signature->utf8_length();

  char* dest          = NEW_RESOURCE_ARRAY(char, len + 1);

  strcpy(dest, klass_name);

  dest[klass_name_len] = '.';

  strcpy(&dest[klass_name_len + 1], method_name->as_C_string());

  strcpy(&dest[klass_name_len + 1 + method_name_len], signature->as_C_string());

  dest[len] = 0;

  return dest;

}

char* Method::name_and_sig_as_C_string(Klass* klass, Symbol* method_name, Symbol* signature, char* buf, int size) {

  Symbol* klass_name = klass->name();

  klass_name->as_klass_external_name(buf, size);

  int len = (int)strlen(buf);

  if (len < size - 1) {

    buf[len++] = '.';

    method_name->as_C_string(&(buf[len]), size - len);

    len = (int)strlen(buf);

    signature->as_C_string(&(buf[len]), size - len);

  }

  return buf;

}

const char* Method::external_name() const {

  return external_name(constants()->pool_holder(), name(), signature());

}

void Method::print_external_name(outputStream *os) const {

  print_external_name(os, constants()->pool_holder(), name(), signature());

}

const char* Method::external_name(Klass* klass, Symbol* method_name, Symbol* signature) {

  stringStream ss;

  print_external_name(&ss, klass, method_name, signature);

  return ss.as_string();

}

void Method::print_external_name(outputStream *os, Klass* klass, Symbol* method_name, Symbol* signature) {

  signature->print_as_signature_external_return_type(os);

  os->print(" %s.%s(", klass->external_name(), method_name->as_C_string());

  signature->print_as_signature_external_parameters(os);

  os->print(")");

}

int Method::fast_exception_handler_bci_for(const methodHandle& mh, Klass* ex_klass, int throw_bci, TRAPS) {

  // exception table holds quadruple entries of the form (beg_bci, end_bci, handler_bci, klass_index)

  // access exception table

  ExceptionTable table(mh());

  int length = table.length();

  // iterate through all entries sequentially

  constantPoolHandle pool(THREAD, mh->constants());

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

    //reacquire the table in case a GC happened

    ExceptionTable table(mh());

    int beg_bci = table.start_pc(i);

    int end_bci = table.end_pc(i);

    assert(beg_bci <= end_bci, "inconsistent exception table");

    if (beg_bci <= throw_bci && throw_bci < end_bci) {

      // exception handler bci range covers throw_bci => investigate further

      int handler_bci = table.handler_pc(i);

      int klass_index = table.catch_type_index(i);

      if (klass_index == 0) {

        return handler_bci;

      } else if (ex_klass == NULL) {

        return handler_bci;

      } else {

        // we know the exception class => get the constraint class

        // this may require loading of the constraint class; if verification

        // fails or some other exception occurs, return handler_bci

        Klass* k = pool->klass_at(klass_index, CHECK_(handler_bci));

        assert(k != NULL, "klass not loaded");

        if (ex_klass->is_subtype_of(k)) {

          return handler_bci;

        }

      }

    }

  }

  return -1;

}

void Method::mask_for(int bci, InterpreterOopMap* mask) {

  methodHandle h_this(Thread::current(), this);

  // Only GC uses the OopMapCache during thread stack root scanning

  // any other uses generate an oopmap but do not save it in the cache.

  if (Universe::heap()->is_gc_active()) {

    method_holder()->mask_for(h_this, bci, mask);

  } else {

    OopMapCache::compute_one_oop_map(h_this, bci, mask);

  }

  return;

}

int Method::bci_from(address bcp) const {

  if (is_native() && bcp == 0) {

    return 0;

  }

#ifdef ASSERT

  {

    ResourceMark rm;

    assert(is_native() && bcp == code_base() || contains(bcp) || VMError::is_error_reported(),

           "bcp doesn't belong to this method: bcp: " INTPTR_FORMAT ", method: %s",

           p2i(bcp), name_and_sig_as_C_string());

  }

#endif

  return bcp - code_base();

}

int Method::validate_bci(int bci) const {

  return (bci == 0 || bci < code_size()) ? bci : -1;

}

// Return bci if it appears to be a valid bcp

// Return -1 otherwise.

// Used by profiling code, when invalid data is a possibility.

// The caller is responsible for validating the Method* itself.

int Method::validate_bci_from_bcp(address bcp) const {

  // keep bci as -1 if not a valid bci

  int bci = -1;

  if (bcp == 0 || bcp == code_base()) {

    // code_size() may return 0 and we allow 0 here

    // the method may be native

    bci = 0;

  } else if (contains(bcp)) {

    bci = bcp - code_base();

  }

  // Assert that if we have dodged any asserts, bci is negative.

  assert(bci == -1 || bci == bci_from(bcp_from(bci)), "sane bci if >=0");

  return bci;

}

address Method::bcp_from(int bci) const {

  assert((is_native() && bci == 0) || (!is_native() && 0 <= bci && bci < code_size()),

         "illegal bci: %d for %s method", bci, is_native() ? "native" : "non-native");

  address bcp = code_base() + bci;

  assert(is_native() && bcp == code_base() || contains(bcp), "bcp doesn't belong to this method");

  return bcp;

}

address Method::bcp_from(address bcp) const {

  if (is_native() && bcp == NULL) {

    return code_base();

  } else {

    return bcp;

  }

}

int Method::size(bool is_native) {

  // If native, then include pointers for native_function and signature_handler

  int extra_bytes = (is_native) ? 2*sizeof(address*) : 0;

  int extra_words = align_up(extra_bytes, BytesPerWord) / BytesPerWord;

  return align_metadata_size(header_size() + extra_words);

}

Symbol* Method::klass_name() const {

  return method_holder()->name();

}

void Method::metaspace_pointers_do(MetaspaceClosure* it) {

  log_trace(cds)("Iter(Method): %p", this);

  it->push(&_constMethod);

  it->push(&_method_data);

  it->push(&_method_counters);

}

// Attempt to return method oop to original state.  Clear any pointers

// (to objects outside the shared spaces).  We won't be able to predict

// where they should point in a new JVM.  Further initialize some

// entries now in order allow them to be write protected later.

void Method::remove_unshareable_info() {

  unlink_method();

}

void Method::set_vtable_index(int index) {

  if (is_shared() && !MetaspaceShared::remapped_readwrite()) {

    // At runtime initialize_vtable is rerun as part of link_class_impl()

    // for a shared class loaded by the non-boot loader to obtain the loader

    // constraints based on the runtime classloaders' context.

    return; // don't write into the shared class

  } else {

    _vtable_index = index;

  }

}

void Method::set_itable_index(int index) {

  if (is_shared() && !MetaspaceShared::remapped_readwrite()) {

    // At runtime initialize_itable is rerun as part of link_class_impl()

    // for a shared class loaded by the non-boot loader to obtain the loader

    // constraints based on the runtime classloaders' context. The dumptime

    // itable index should be the same as the runtime index.

    assert(_vtable_index == itable_index_max - index,

           "archived itable index is different from runtime index");

    return; // don’t write into the shared class

  } else {

    _vtable_index = itable_index_max - index;

  }

  assert(valid_itable_index(), "");

}

bool Method::was_executed_more_than(int n) {

  // Invocation counter is reset when the Method* is compiled.

  // If the method has compiled code we therefore assume it has

  // be excuted more than n times.

  if (is_accessor() || is_empty_method() || (code() != NULL)) {

    // interpreter doesn't bump invocation counter of trivial methods

    // compiler does not bump invocation counter of compiled methods

    return true;

  }

  else if ((method_counters() != NULL &&

            method_counters()->invocation_counter()->carry()) ||

           (method_data() != NULL &&

            method_data()->invocation_counter()->carry())) {

    // The carry bit is set when the counter overflows and causes

    // a compilation to occur.  We don't know how many times

    // the counter has been reset, so we simply assume it has

    // been executed more than n times.

    return true;

  } else {

    return invocation_count() > n;

  }

}

void Method::print_invocation_count() {

  if (is_static()) tty->print("static ");

  if (is_final()) tty->print("final ");

  if (is_synchronized()) tty->print("synchronized ");

  if (is_native()) tty->print("native ");

  tty->print("%s::", method_holder()->external_name());

  name()->print_symbol_on(tty);

  signature()->print_symbol_on(tty);

  if (WizardMode) {

    // dump the size of the byte codes

    tty->print(" {%d}", code_size());

  }

  tty->cr();

  tty->print_cr ("  interpreter_invocation_count: %8d ", interpreter_invocation_count());

  tty->print_cr ("  invocation_counter:           %8d ", invocation_count());

  tty->print_cr ("  backedge_counter:             %8d ", backedge_count());

#ifndef PRODUCT

  if (CountCompiledCalls) {

    tty->print_cr ("  compiled_invocation_count: %8d ", compiled_invocation_count());

  }

#endif

}

// Build a MethodData* object to hold information about this method

// collected in the interpreter.

void Method::build_interpreter_method_data(const methodHandle& method, TRAPS) {

  // Do not profile the method if metaspace has hit an OOM previously

  // allocating profiling data. Callers clear pending exception so don't

  // add one here.

  if (ClassLoaderDataGraph::has_metaspace_oom()) {

    return;

  }

  // Grab a lock here to prevent multiple

  // MethodData*s from being created.

  MutexLocker ml(MethodData_lock, THREAD);

  if (method->method_data() == NULL) {

    ClassLoaderData* loader_data = method->method_holder()->class_loader_data();

    MethodData* method_data = MethodData::allocate(loader_data, method, THREAD);

    if (HAS_PENDING_EXCEPTION) {

      CompileBroker::log_metaspace_failure();

      ClassLoaderDataGraph::set_metaspace_oom(true);

      return;   // return the exception (which is cleared)

    }

    method->set_method_data(method_data);

    if (PrintMethodData && (Verbose || WizardMode)) {

      ResourceMark rm(THREAD);

      tty->print("build_interpreter_method_data for ");

      method->print_name(tty);

      tty->cr();

      // At the end of the run, the MDO, full of data, will be dumped.

    }

  }

}

MethodCounters* Method::build_method_counters(Method* m, TRAPS) {

  // Do not profile the method if metaspace has hit an OOM previously

  if (ClassLoaderDataGraph::has_metaspace_oom()) {

    return NULL;

  }

  methodHandle mh(m);

  MethodCounters* counters = MethodCounters::allocate(mh, THREAD);

  if (HAS_PENDING_EXCEPTION) {

    CompileBroker::log_metaspace_failure();

    ClassLoaderDataGraph::set_metaspace_oom(true);

    return NULL;   // return the exception (which is cleared)

  }

  if (!mh->init_method_counters(counters)) {

    MetadataFactory::free_metadata(mh->method_holder()->class_loader_data(), counters);

  }

  if (LogTouchedMethods) {

    mh->log_touched(CHECK_NULL);

  }

  return mh->method_counters();

}

bool Method::init_method_counters(MethodCounters* counters) {

  // Try to install a pointer to MethodCounters, return true on success.

  return Atomic::replace_if_null(counters, &_method_counters);

}

int Method::extra_stack_words() {

  // not an inline function, to avoid a header dependency on Interpreter

  return extra_stack_entries() * Interpreter::stackElementSize;

}

void Method::compute_size_of_parameters(Thread *thread) {

  ArgumentSizeComputer asc(signature());