/*

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

#include "oops/klassOop.hpp"

#include "oops/methodDataOop.hpp"

#include "oops/methodOop.hpp"

#include "oops/oop.inline.hpp"

#include "oops/symbol.hpp"

#include "prims/jvmtiExport.hpp"

#include "prims/methodHandleWalk.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/relocator.hpp"

#include "runtime/sharedRuntime.hpp"

#include "runtime/signature.hpp"

#include "utilities/quickSort.hpp"

#include "utilities/xmlstream.hpp"

// Implementation of methodOopDesc

address methodOopDesc::get_i2c_entry() {

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

  return _adapter->get_i2c_entry();

}

address methodOopDesc::get_c2i_entry() {

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

  return _adapter->get_c2i_entry();

}

address methodOopDesc::get_c2i_unverified_entry() {

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

  return _adapter->get_c2i_unverified_entry();

}

char* methodOopDesc::name_and_sig_as_C_string() const {

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

}

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

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

}

char* methodOopDesc::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* methodOopDesc::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  methodOopDesc::fast_exception_handler_bci_for(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

  // iterate through all entries sequentially

  constantPoolHandle pool(THREAD, constants());

    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

      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

        klassOop 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 methodOopDesc::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;

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

      local_mask.print();

    }

  }

#endif

  instanceKlass::cast(method_holder())->mask_for(h_this, bci, mask);

  return;

}

int methodOopDesc::bci_from(address bcp) const {

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

  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 methodOop itself.

int methodOopDesc::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 methodOopDesc::bcp_from(int bci) const {

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

  address bcp = code_base() + bci;

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

  return bcp;

}

int methodOopDesc::object_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* methodOopDesc::klass_name() const {

  klassOop k = method_holder();

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

  instanceKlass* ik = (instanceKlass*) k->klass_part();

  return ik->name();

}

void methodOopDesc::set_interpreter_kind() {

  int kind = Interpreter::method_kind(methodOop(this));

  assert(kind != Interpreter::invalid,

         "interpreter entry must be valid");

  set_interpreter_kind(kind);

}

// 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 methodOopDesc::remove_unshareable_info() {

  unlink_method();

  set_interpreter_kind();

}

bool methodOopDesc::was_executed_more_than(int n) {

  // Invocation counter is reset when the methodOop 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 (_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;

  }

}

#ifndef PRODUCT

void methodOopDesc::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 ");

  method_holder()->klass_part()->name()->print_symbol_on(tty);

  tty->print(".");

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

  if (CountCompiledCalls) {

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

  }

}

#endif

// Build a methodDataOop object to hold information about this method

// collected in the interpreter.

void methodOopDesc::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

  // methodDataOops from being created.

  MutexLocker ml(MethodData_lock, THREAD);

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

    methodDataOop method_data = oopFactory::new_methodData(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.

    }

  }

}

void methodOopDesc::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 methodOopDesc::extra_stack_words() {

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

  return extra_stack_entries() * Interpreter::stackElementSize;

}

void methodOopDesc::compute_size_of_parameters(Thread *thread) {

  ArgumentSizeComputer asc(signature());

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

}

#ifdef CC_INTERP

void methodOopDesc::set_result_index(BasicType type)          {

  _result_index = Interpreter::BasicType_as_index(type);

}

#endif

BasicType methodOopDesc::result_type() const {

  ResultTypeFinder rtf(signature());

  return rtf.type();

}

bool methodOopDesc::is_empty_method() const {

  return  code_size() == 1

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

}

bool methodOopDesc::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 methodOopDesc::compute_has_loops_flag() {

  BytecodeStream bcs(methodOop(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;

    }

  }

  _access_flags.set_loops_flag_init();

  return _access_flags.has_loops();

}

bool methodOopDesc::is_final_method() const {

  // %%% Should return true for private methods also,

  // since there is no way to override them.

  return is_final() || Klass::cast(method_holder())->is_final();

}

bool methodOopDesc::is_strict_method() const {

  return is_strict();

}

bool methodOopDesc::can_be_statically_bound() const {

  if (is_final_method())  return true;

  return vtable_index() == nonvirtual_vtable_index;

}

bool methodOopDesc::is_accessor() const {

  if (code_size() != 5) return false;

  if (size_of_parameters() != 1) return false;

  if (java_code_at(0) != Bytecodes::_aload_0 ) return false;

  if (java_code_at(1) != Bytecodes::_getfield) return false;

  if (java_code_at(4) != Bytecodes::_areturn &&

      java_code_at(4) != Bytecodes::_ireturn ) return false;

  return true;

}

bool methodOopDesc::is_initializer() const {

  return name() == vmSymbols::object_initializer_name() || is_static_initializer();

}

bool methodOopDesc::has_valid_initializer_flags() const {

  return (is_static() ||

          instanceKlass::cast(method_holder())->major_version() < 51);

}

bool methodOopDesc::is_static_initializer() const {

  // For classfiles version 51 or greater, ensure that the clinit method is

  // static.  Non-static methods with the name "<clinit>" are not static

  // initializers. (older classfiles exempted for backward compatibility)

  return name() == vmSymbols::class_initializer_name() &&

         has_valid_initializer_flags();

}

objArrayHandle methodOopDesc::resolved_checked_exceptions_impl(methodOop this_oop, TRAPS) {

  int length = this_oop->checked_exceptions_length();

  if (length == 0) {  // common case

    return objArrayHandle(THREAD, Universe::the_empty_class_klass_array());

  } else {

    methodHandle h_this(THREAD, this_oop);

    objArrayOop m_oop = oopFactory::new_objArray(SystemDictionary::Class_klass(), length, CHECK_(objArrayHandle()));

    objArrayHandle mirrors (THREAD, m_oop);

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

      CheckedExceptionElement* table = h_this->checked_exceptions_start(); // recompute on each iteration, not gc safe

      klassOop k = h_this->constants()->klass_at(table[i].class_cp_index, CHECK_(objArrayHandle()));

      assert(Klass::cast(k)->is_subclass_of(SystemDictionary::Throwable_klass()), "invalid exception class");

      mirrors->obj_at_put(i, Klass::cast(k)->java_mirror());

    }

    return mirrors;

  }

};

int methodOopDesc::line_number_from_bci(int bci) const {

  if (bci == SynchronizationEntryBCI) bci = 0;

  assert(bci == 0 || 0 <= bci && bci < code_size(), "illegal bci");

  int best_bci  =  0;

  int best_line = -1;

  if (has_linenumber_table()) {

    // The line numbers are a short array of 2-tuples [start_pc, line_number].

    // Not necessarily sorted and not necessarily one-to-one.

    CompressedLineNumberReadStream stream(compressed_linenumber_table());

    while (stream.read_pair()) {

      if (stream.bci() == bci) {

        // perfect match

        return stream.line();

      } else {

        // update best_bci/line

        if (stream.bci() < bci && stream.bci() >= best_bci) {