/*

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

#include "gc_interface/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/gcLocker.hpp"

#include "memory/generation.hpp"

#include "memory/heapInspection.hpp"

#include "memory/metadataFactory.hpp"

#include "memory/oopFactory.hpp"

#include "oops/constMethod.hpp"

#include "oops/methodData.hpp"

#include "oops/method.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"

PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC

// 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, size);

}

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

  No_Safepoint_Verifier no_safepoint;

  set_constMethod(xconst);

  set_access_flags(access_flags);

  set_method_size(size);

#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_method_data(NULL);

  set_method_counters(NULL);

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

  set_method_counters(NULL);

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

}

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

#ifdef ASSERT

  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 {

#ifdef ASSERT

  { ResourceMark rm;

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

         err_msg("bcp doesn't belong to this method: bcp: " INTPTR_FORMAT ", method: %s", bcp, name_and_sig_as_C_string()));

  }

#endif

  return bcp - code_base();

}

// Return (int)bcx if it appears to be a valid BCI.

// Return bci_from((address)bcx) 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_bcx(intptr_t bcx) const {

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

  int bci = -1;

  if (bcx == 0 || (address)bcx == code_base()) {

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

    // the method may be native

    bci = 0;

  } else if (frame::is_bci(bcx)) {

    if (bcx < code_size()) {

      bci = (int)bcx;

    }

  } else if (contains((address)bcx)) {

    bci = (address)bcx - 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()), err_msg("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;

}

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_object_size(header_size() + extra_words);

}

Symbol* Method::klass_name() const {

  Klass* k = method_holder();

  assert(k->is_klass(), "must be klass");

  InstanceKlass* ik = (InstanceKlass*) k;

  return ik->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(methodHandle method, TRAPS) {

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

  // which avoids deadlock for acquiring the MethodData_lock.

  if (InstanceRefKlass::owns_pending_list_lock((JavaThread*)THREAD)) {

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

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

  methodHandle mh(m);

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

  MethodCounters* counters = MethodCounters::allocate(loader_data, CHECK_NULL);

  if (mh->method_counters() == NULL) {

    mh->set_method_counters(counters);

  } else {

    MetadataFactory::free_metadata(loader_data, counters);

  }

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

    if (cb[i] != Bytecodes::_aload_0) return false;

    if (!Bytecodes::is_zero_const(Bytecodes::cast(cb[i+1]))) return false;

    if (cb[i+2] != Bytecodes::_putfield) return false;

  }

  return true;

}

bool Method::compute_has_loops_flag() {

  BytecodeStream bcs(this);

  Bytecodes::Code bc;

  while ((bc = bcs.next()) >= 0) {

    switch( bc ) {

      case Bytecodes::_ifeq:

      case Bytecodes::_ifnull:

      case Bytecodes::_iflt:

      case Bytecodes::_ifle:

      case Bytecodes::_ifne:

      case Bytecodes::_ifnonnull:

      case Bytecodes::_ifgt:

      case Bytecodes::_ifge:

      case Bytecodes::_if_icmpeq:

      case Bytecodes::_if_icmpne:

      case Bytecodes::_if_icmplt:

      case Bytecodes::_if_icmpgt:

      case Bytecodes::_if_icmple:

      case Bytecodes::_if_icmpge:

      case Bytecodes::_if_acmpeq:

      case Bytecodes::_if_acmpne:

      case Bytecodes::_goto:

      case Bytecodes::_jsr:

        if( bcs.dest() < bcs.next_bci() ) _access_flags.set_has_loops();

        break;

      case Bytecodes::_goto_w:

      case Bytecodes::_jsr_w:

        if( bcs.dest_w() < bcs.next_bci() ) _access_flags.set_has_loops();

        break;

    }