/*

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

#include "classfile/systemDictionary.hpp"

#include "code/codeCache.hpp"

#include "code/debugInfoRec.hpp"

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

#include "gc/shared/gcLocker.hpp"

#include "gc/shared/generation.hpp"

#include "gc/shared/referencePendingListLocker.hpp"

#include "interpreter/bytecodeStream.hpp"

#include "interpreter/bytecodeTracer.hpp"

#include "interpreter/bytecodes.hpp"

#include "interpreter/interpreter.hpp"

#include "interpreter/oopMapCache.hpp"

#include "memory/heapInspection.hpp"

#include "memory/metadataFactory.hpp"

#include "memory/oopFactory.hpp"

#include "memory/resourceArea.hpp"

#include "oops/constMethod.hpp"

#include "oops/method.hpp"

#include "oops/methodData.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/orderAccess.inline.hpp"

#include "runtime/relocator.hpp"

#include "runtime/sharedRuntime.hpp"

#include "runtime/signature.hpp"

#include "utilities/quickSort.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, false, 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);

#ifdef CC_INTERP

  set_result_index(T_VOID);

#endif

  set_intrinsic_id(vmIntrinsics::_none);

  set_jfr_towrite(false);

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

  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() {

}

address Method::get_c2i_entry() {

}

address Method::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;

}

int Method::fast_exception_handler_bci_for(methodHandle mh, KlassHandle 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.is_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));

        KlassHandle klass = KlassHandle(THREAD, k);

        assert(klass.not_null(), "klass not loaded");

        if (ex_klass->is_subtype_of(klass())) {

          return handler_bci;

        }

      }

    }

  }

  return -1;

}

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

  Thread* myThread    = Thread::current();

  methodHandle h_this(myThread, this);

#if defined(ASSERT) && !INCLUDE_JVMCI

  bool has_capability = myThread->is_VM_thread() ||

                        myThread->is_ConcurrentGC_thread() ||

                        myThread->is_GC_task_thread();

  if (!has_capability) {

    if (!VerifyStack && !VerifyLastFrame) {

      // verify stack calls this outside VM thread

      warning("oopmap should only be accessed by the "

              "VM, GC task or CMS threads (or during debugging)");

      InterpreterOopMap local_mask;

      method_holder()->mask_for(h_this, bci, &local_mask);

      local_mask.print();

    }

  }

#endif

  method_holder()->mask_for(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) || 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", bci);

  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_size_up(extra_bytes, BytesPerWord) / BytesPerWord;

  return align_metadata_size(header_size() + extra_words);

}

Symbol* Method::klass_name() const {

  return method_holder()->name();

}

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

}

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;

  }

  // Do not profile method if current thread holds the pending list lock,

  // which avoids deadlock for acquiring the MethodData_lock.

  if (ReferencePendingListLocker::is_locked_by_self()) {

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

}

void Method::cleanup_inline_caches() {

  // The current system doesn't use inline caches in the interpreter

  // => nothing to do (keep this method around for future use)

}

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

  set_size_of_parameters(asc.size() + (is_static() ? 0 : 1));

}

#ifdef CC_INTERP

void Method::set_result_index(BasicType type)          {

  _result_index = Interpreter::BasicType_as_index(type);

}

#endif

BasicType Method::result_type() const {

  ResultTypeFinder rtf(signature());

  return rtf.type();

}

bool Method::is_empty_method() const {

  return  code_size() == 1

      && *code_base() == Bytecodes::_return;

}

bool Method::is_vanilla_constructor() const {

  // Returns true if this method is a vanilla constructor, i.e. an "<init>" "()V" method

  // which only calls the superclass vanilla constructor and possibly does stores of

  // zero constants to local fields:

  //

  //   aload_0

  //   invokespecial

  //   indexbyte1

  //   indexbyte2

  //

  // followed by an (optional) sequence of:

  //

  //   aload_0

  //   aconst_null / iconst_0 / fconst_0 / dconst_0

  //   putfield

  //   indexbyte1

  //   indexbyte2

  //

  // followed by:

  //

  //   return

  assert(name() == vmSymbols::object_initializer_name(),    "Should only be called for default constructors");

  assert(signature() == vmSymbols::void_method_signature(), "Should only be called for default constructors");

  int size = code_size();

  // Check if size match

  if (size == 0 || size % 5 != 0) return false;

  address cb = code_base();

  int last = size - 1;

  if (cb[0] != Bytecodes::_aload_0 || cb[1] != Bytecodes::_invokespecial || cb[last] != Bytecodes::_return) {

    // Does not call superclass default constructor

    return false;

  }

  // Check optional sequence

  for (int i = 4; i < last; i += 5) {