/*

 * Copyright 1997-2010 Sun Microsystems, Inc.  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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

 * CA 95054 USA or visit www.sun.com if you need additional information or

 * have any questions.

 *

 */

# include "incls/_precompiled.incl"

# include "incls/_methodOop.cpp.incl"

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

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

  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, symbolOop method_name, symbolOop 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, symbolOop method_name, symbolOop signature, char* buf, int size) {

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

  const int beg_bci_offset     = 0;

  const int end_bci_offset     = 1;

  const int handler_bci_offset = 2;

  const int klass_index_offset = 3;

  const int entry_size         = 4;

  // access exception table

  typeArrayHandle table (THREAD, constMethod()->exception_table());

  int length = table->length();

  assert(length % entry_size == 0, "exception table format has changed");

  // iterate through all entries sequentially

  constantPoolHandle pool(THREAD, constants());

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

    int beg_bci = table->int_at(i + beg_bci_offset);

    int end_bci = table->int_at(i + end_bci_offset);

    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->int_at(i + handler_bci_offset);

      int klass_index = table->int_at(i + klass_index_offset);

      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;

}

methodOop methodOopDesc::method_from_bcp(address bcp) {

  debug_only(static int count = 0; count++);

  assert(Universe::heap()->is_in_permanent(bcp), "bcp not in perm_gen");

  // TO DO: this may be unsafe in some configurations

  HeapWord* p = Universe::heap()->block_start(bcp);

  assert(Universe::heap()->block_is_obj(p), "must be obj");

  assert(oop(p)->is_constMethod(), "not a method");

  return constMethodOop(p)->method();

}

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(), "bcp doesn't belong to this method");

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

}

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

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

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

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

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

  symbolHandle h_signature(thread, signature());

  ArgumentSizeComputer asc(h_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;

  methodOop m = (methodOop)this;  // pass to code_at() to avoid method_from_bcp

  if (Bytecodes::java_code_at(code_base()+0, m) != Bytecodes::_aload_0 ) return false;

  if (Bytecodes::java_code_at(code_base()+1, m) != Bytecodes::_getfield) return false;

  if (Bytecodes::java_code_at(code_base()+4, m) != Bytecodes::_areturn &&

      Bytecodes::java_code_at(code_base()+4, m) != Bytecodes::_ireturn ) return false;

  return true;

}

bool methodOopDesc::is_initializer() const {

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

}

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

          best_bci  = stream.bci();

          best_line = stream.line();

        }

      }

    }

  }

  return best_line;

}

bool methodOopDesc::is_klass_loaded_by_klass_index(int klass_index) const {

  if( _constants->tag_at(klass_index).is_unresolved_klass() ) {

    Thread *thread = Thread::current();

    symbolHandle klass_name(thread, _constants->klass_name_at(klass_index));

    Handle loader(thread, instanceKlass::cast(method_holder())->class_loader());

    Handle prot  (thread, Klass::cast(method_holder())->protection_domain());

    return SystemDictionary::find(klass_name, loader, prot, thread) != NULL;

  } else {

    return true;

  }

}

bool methodOopDesc::is_klass_loaded(int refinfo_index, bool must_be_resolved) const {

  int klass_index = _constants->klass_ref_index_at(refinfo_index);

  if (must_be_resolved) {

    // Make sure klass is resolved in constantpool.

    if (constants()->tag_at(klass_index).is_unresolved_klass()) return false;

  }

  return is_klass_loaded_by_klass_index(klass_index);

}

void methodOopDesc::set_native_function(address function, bool post_event_flag) {

  assert(function != NULL, "use clear_native_function to unregister natives");

  address* native_function = native_function_addr();

  // We can see racers trying to place the same native function into place. Once

  // is plenty.