/*

 * 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/_sharedRuntime.cpp.incl"

#include <math.h>

HS_DTRACE_PROBE_DECL4(hotspot, object__alloc, Thread*, char*, int, size_t);

HS_DTRACE_PROBE_DECL7(hotspot, method__entry, int,

                      char*, int, char*, int, char*, int);

HS_DTRACE_PROBE_DECL7(hotspot, method__return, int,

                      char*, int, char*, int, char*, int);

// Implementation of SharedRuntime

#ifndef PRODUCT

// For statistics

int SharedRuntime::_ic_miss_ctr = 0;

int SharedRuntime::_wrong_method_ctr = 0;

int SharedRuntime::_resolve_static_ctr = 0;

int SharedRuntime::_resolve_virtual_ctr = 0;

int SharedRuntime::_resolve_opt_virtual_ctr = 0;

int SharedRuntime::_implicit_null_throws = 0;

int SharedRuntime::_implicit_div0_throws = 0;

int SharedRuntime::_throw_null_ctr = 0;

int SharedRuntime::_nof_normal_calls = 0;

int SharedRuntime::_nof_optimized_calls = 0;

int SharedRuntime::_nof_inlined_calls = 0;

int SharedRuntime::_nof_megamorphic_calls = 0;

int SharedRuntime::_nof_static_calls = 0;

int SharedRuntime::_nof_inlined_static_calls = 0;

int SharedRuntime::_nof_interface_calls = 0;

int SharedRuntime::_nof_optimized_interface_calls = 0;

int SharedRuntime::_nof_inlined_interface_calls = 0;

int SharedRuntime::_nof_megamorphic_interface_calls = 0;

int SharedRuntime::_nof_removable_exceptions = 0;

int SharedRuntime::_new_instance_ctr=0;

int SharedRuntime::_new_array_ctr=0;

int SharedRuntime::_multi1_ctr=0;

int SharedRuntime::_multi2_ctr=0;

int SharedRuntime::_multi3_ctr=0;

int SharedRuntime::_multi4_ctr=0;

int SharedRuntime::_multi5_ctr=0;

int SharedRuntime::_mon_enter_stub_ctr=0;

int SharedRuntime::_mon_exit_stub_ctr=0;

int SharedRuntime::_mon_enter_ctr=0;

int SharedRuntime::_mon_exit_ctr=0;

int SharedRuntime::_partial_subtype_ctr=0;

int SharedRuntime::_jbyte_array_copy_ctr=0;

int SharedRuntime::_jshort_array_copy_ctr=0;

int SharedRuntime::_jint_array_copy_ctr=0;

int SharedRuntime::_jlong_array_copy_ctr=0;

int SharedRuntime::_oop_array_copy_ctr=0;

int SharedRuntime::_checkcast_array_copy_ctr=0;

int SharedRuntime::_unsafe_array_copy_ctr=0;

int SharedRuntime::_generic_array_copy_ctr=0;

int SharedRuntime::_slow_array_copy_ctr=0;

int SharedRuntime::_find_handler_ctr=0;

int SharedRuntime::_rethrow_ctr=0;

int     SharedRuntime::_ICmiss_index                    = 0;

int     SharedRuntime::_ICmiss_count[SharedRuntime::maxICmiss_count];

address SharedRuntime::_ICmiss_at[SharedRuntime::maxICmiss_count];

void SharedRuntime::trace_ic_miss(address at) {

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

    if (_ICmiss_at[i] == at) {

      _ICmiss_count[i]++;

      return;

    }

  }

  int index = _ICmiss_index++;

  if (_ICmiss_index >= maxICmiss_count) _ICmiss_index = maxICmiss_count - 1;

  _ICmiss_at[index] = at;

  _ICmiss_count[index] = 1;

}

void SharedRuntime::print_ic_miss_histogram() {

  if (ICMissHistogram) {

    tty->print_cr ("IC Miss Histogram:");

    int tot_misses = 0;

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

      tty->print_cr("  at: " INTPTR_FORMAT "  nof: %d", _ICmiss_at[i], _ICmiss_count[i]);

      tot_misses += _ICmiss_count[i];

    }

    tty->print_cr ("Total IC misses: %7d", tot_misses);

  }

}

#endif // PRODUCT

#ifndef SERIALGC

// G1 write-barrier pre: executed before a pointer store.

JRT_LEAF(void, SharedRuntime::g1_wb_pre(oopDesc* orig, JavaThread *thread))

  if (orig == NULL) {

    assert(false, "should be optimized out");

    return;

  }

  assert(orig->is_oop(true /* ignore mark word */), "Error");

  // store the original value that was in the field reference

  thread->satb_mark_queue().enqueue(orig);

JRT_END

// G1 write-barrier post: executed after a pointer store.

JRT_LEAF(void, SharedRuntime::g1_wb_post(void* card_addr, JavaThread* thread))

  thread->dirty_card_queue().enqueue(card_addr);

JRT_END

#endif // !SERIALGC

JRT_LEAF(jlong, SharedRuntime::lmul(jlong y, jlong x))

  return x * y;

JRT_END

JRT_LEAF(jlong, SharedRuntime::ldiv(jlong y, jlong x))

  if (x == min_jlong && y == CONST64(-1)) {

    return x;

  } else {

    return x / y;

  }

JRT_END

JRT_LEAF(jlong, SharedRuntime::lrem(jlong y, jlong x))

  if (x == min_jlong && y == CONST64(-1)) {

    return 0;

  } else {

    return x % y;

  }

JRT_END

const juint  float_sign_mask  = 0x7FFFFFFF;

const juint  float_infinity   = 0x7F800000;

const julong double_sign_mask = CONST64(0x7FFFFFFFFFFFFFFF);

const julong double_infinity  = CONST64(0x7FF0000000000000);

JRT_LEAF(jfloat, SharedRuntime::frem(jfloat  x, jfloat  y))

#ifdef _WIN64

  // 64-bit Windows on amd64 returns the wrong values for

  // infinity operands.

  union { jfloat f; juint i; } xbits, ybits;

  xbits.f = x;

  ybits.f = y;

  // x Mod Infinity == x unless x is infinity

  if ( ((xbits.i & float_sign_mask) != float_infinity) &&

       ((ybits.i & float_sign_mask) == float_infinity) ) {

    return x;

  }

#endif

  return ((jfloat)fmod((double)x,(double)y));

JRT_END

JRT_LEAF(jdouble, SharedRuntime::drem(jdouble x, jdouble y))

#ifdef _WIN64

  union { jdouble d; julong l; } xbits, ybits;

  xbits.d = x;

  ybits.d = y;

  // x Mod Infinity == x unless x is infinity

  if ( ((xbits.l & double_sign_mask) != double_infinity) &&

       ((ybits.l & double_sign_mask) == double_infinity) ) {

    return x;

  }

#endif

  return ((jdouble)fmod((double)x,(double)y));

JRT_END

JRT_LEAF(jint, SharedRuntime::f2i(jfloat  x))

  if (g_isnan(x))

    return 0;

  if (x >= (jfloat) max_jint)

    return max_jint;

  if (x <= (jfloat) min_jint)

    return min_jint;

  return (jint) x;

JRT_END

JRT_LEAF(jlong, SharedRuntime::f2l(jfloat  x))

  if (g_isnan(x))

    return 0;

  if (x >= (jfloat) max_jlong)

    return max_jlong;

  if (x <= (jfloat) min_jlong)

    return min_jlong;

  return (jlong) x;

JRT_END

JRT_LEAF(jint, SharedRuntime::d2i(jdouble x))

  if (g_isnan(x))

    return 0;

  if (x >= (jdouble) max_jint)

    return max_jint;

  if (x <= (jdouble) min_jint)

    return min_jint;

  return (jint) x;

JRT_END

JRT_LEAF(jlong, SharedRuntime::d2l(jdouble x))

  if (g_isnan(x))

    return 0;

  if (x >= (jdouble) max_jlong)

    return max_jlong;

  if (x <= (jdouble) min_jlong)

    return min_jlong;

  return (jlong) x;

JRT_END

JRT_LEAF(jfloat, SharedRuntime::d2f(jdouble x))

  return (jfloat)x;

JRT_END

JRT_LEAF(jfloat, SharedRuntime::l2f(jlong x))

  return (jfloat)x;

JRT_END

JRT_LEAF(jdouble, SharedRuntime::l2d(jlong x))

  return (jdouble)x;

JRT_END

// Exception handling accross interpreter/compiler boundaries

//

// exception_handler_for_return_address(...) returns the continuation address.

// The continuation address is the entry point of the exception handler of the

// previous frame depending on the return address.

address SharedRuntime::raw_exception_handler_for_return_address(address return_address) {

  assert(frame::verify_return_pc(return_address), "must be a return pc");

  // the fastest case first

  CodeBlob* blob = CodeCache::find_blob(return_address);

  if (blob != NULL && blob->is_nmethod()) {

    nmethod* code = (nmethod*)blob;

    assert(code != NULL, "nmethod must be present");

    // native nmethods don't have exception handlers

    assert(!code->is_native_method(), "no exception handler");

    assert(code->header_begin() != code->exception_begin(), "no exception handler");

    if (code->is_deopt_pc(return_address)) {

      return SharedRuntime::deopt_blob()->unpack_with_exception();

    } else {

      return code->exception_begin();

    }

  }

  // Entry code

  if (StubRoutines::returns_to_call_stub(return_address)) {

    return StubRoutines::catch_exception_entry();

  }

  // Interpreted code

  if (Interpreter::contains(return_address)) {

    return Interpreter::rethrow_exception_entry();

  }

  // Compiled code

  if (CodeCache::contains(return_address)) {

    CodeBlob* blob = CodeCache::find_blob(return_address);

    if (blob->is_nmethod()) {

      nmethod* code = (nmethod*)blob;

      assert(code != NULL, "nmethod must be present");

      assert(code->header_begin() != code->exception_begin(), "no exception handler");

      return code->exception_begin();

    }

    if (blob->is_runtime_stub()) {

      ShouldNotReachHere();   // callers are responsible for skipping runtime stub frames

    }

  }

  guarantee(!VtableStubs::contains(return_address), "NULL exceptions in vtables should have been handled already!");

#ifndef PRODUCT

  { ResourceMark rm;

    tty->print_cr("No exception handler found for exception at " INTPTR_FORMAT " - potential problems:", return_address);

    tty->print_cr("a) exception happened in (new?) code stubs/buffers that is not handled here");

    tty->print_cr("b) other problem");

  }

#endif // PRODUCT

  ShouldNotReachHere();

  return NULL;

}

JRT_LEAF(address, SharedRuntime::exception_handler_for_return_address(address return_address))

  return raw_exception_handler_for_return_address(return_address);

JRT_END

address SharedRuntime::get_poll_stub(address pc) {

  address stub;

  // Look up the code blob

  CodeBlob *cb = CodeCache::find_blob(pc);

  // Should be an nmethod

  assert( cb && cb->is_nmethod(), "safepoint polling: pc must refer to an nmethod" );

  // Look up the relocation information

  assert( ((nmethod*)cb)->is_at_poll_or_poll_return(pc),

    "safepoint polling: type must be poll" );

  assert( ((NativeInstruction*)pc)->is_safepoint_poll(),

    "Only polling locations are used for safepoint");

  bool at_poll_return = ((nmethod*)cb)->is_at_poll_return(pc);

  if (at_poll_return) {

    assert(SharedRuntime::polling_page_return_handler_blob() != NULL,

           "polling page return stub not created yet");

    stub = SharedRuntime::polling_page_return_handler_blob()->instructions_begin();

  } else {

    assert(SharedRuntime::polling_page_safepoint_handler_blob() != NULL,

           "polling page safepoint stub not created yet");

    stub = SharedRuntime::polling_page_safepoint_handler_blob()->instructions_begin();

  }

#ifndef PRODUCT

  if( TraceSafepoint ) {

    char buf[256];

    jio_snprintf(buf, sizeof(buf),

                 "... found polling page %s exception at pc = "

                 INTPTR_FORMAT ", stub =" INTPTR_FORMAT,

                 at_poll_return ? "return" : "loop",

                 (intptr_t)pc, (intptr_t)stub);

    tty->print_raw_cr(buf);

  }

#endif // PRODUCT

  return stub;

}

oop SharedRuntime::retrieve_receiver( symbolHandle sig, frame caller ) {

  assert(caller.is_interpreted_frame(), "");

  int args_size = ArgumentSizeComputer(sig).size() + 1;

  assert(args_size <= caller.interpreter_frame_expression_stack_size(), "receiver must be on interpreter stack");

  oop result = (oop) *caller.interpreter_frame_tos_at(args_size - 1);

  assert(Universe::heap()->is_in(result) && result->is_oop(), "receiver must be an oop");

  return result;

}

void SharedRuntime::throw_and_post_jvmti_exception(JavaThread *thread, Handle h_exception) {

  if (JvmtiExport::can_post_exceptions()) {

    vframeStream vfst(thread, true);

    methodHandle method = methodHandle(thread, vfst.method());

    address bcp = method()->bcp_from(vfst.bci());

    JvmtiExport::post_exception_throw(thread, method(), bcp, h_exception());

  }

  Exceptions::_throw(thread, __FILE__, __LINE__, h_exception);

}

void SharedRuntime::throw_and_post_jvmti_exception(JavaThread *thread, symbolOop name, const char *message) {

  Handle h_exception = Exceptions::new_exception(thread, name, message);

  throw_and_post_jvmti_exception(thread, h_exception);

}

// The interpreter code to call this tracing function is only

// called/generated when TraceRedefineClasses has the right bits

// set. Since obsolete methods are never compiled, we don't have

// to modify the compilers to generate calls to this function.

//

JRT_LEAF(int, SharedRuntime::rc_trace_method_entry(

    JavaThread* thread, methodOopDesc* method))

  assert(RC_TRACE_IN_RANGE(0x00001000, 0x00002000), "wrong call");

  if (method->is_obsolete()) {

    // We are calling an obsolete method, but this is not necessarily

    // an error. Our method could have been redefined just after we

    // fetched the methodOop from the constant pool.

    // RC_TRACE macro has an embedded ResourceMark

    RC_TRACE_WITH_THREAD(0x00001000, thread,

                         ("calling obsolete method '%s'",

                          method->name_and_sig_as_C_string()));

    if (RC_TRACE_ENABLED(0x00002000)) {

      // this option is provided to debug calls to obsolete methods

      guarantee(false, "faulting at call to an obsolete method.");

    }

  }

  return 0;

JRT_END

// ret_pc points into caller; we are returning caller's exception handler

// for given exception

address SharedRuntime::compute_compiled_exc_handler(nmethod* nm, address ret_pc, Handle& exception,

                                                    bool force_unwind, bool top_frame_only) {

  assert(nm != NULL, "must exist");

  ResourceMark rm;

  ScopeDesc* sd = nm->scope_desc_at(ret_pc);

  // determine handler bci, if any

  EXCEPTION_MARK;

  int handler_bci = -1;

  int scope_depth = 0;

  if (!force_unwind) {

    int bci = sd->bci();

    do {

      bool skip_scope_increment = false;

      // exception handler lookup

      KlassHandle ek (THREAD, exception->klass());

      handler_bci = sd->method()->fast_exception_handler_bci_for(ek, bci, THREAD);

      if (HAS_PENDING_EXCEPTION) {

        // We threw an exception while trying to find the exception handler.

        // Transfer the new exception to the exception handle which will

        // be set into thread local storage, and do another lookup for an

        // exception handler for this exception, this time starting at the

        // BCI of the exception handler which caused the exception to be

        // thrown (bugs 4307310 and 4546590). Set "exception" reference

        // argument to ensure that the correct exception is thrown (4870175).

        exception = Handle(THREAD, PENDING_EXCEPTION);

        CLEAR_PENDING_EXCEPTION;

        if (handler_bci >= 0) {

          bci = handler_bci;

          handler_bci = -1;

          skip_scope_increment = true;

        }

      }

      if (!top_frame_only && handler_bci < 0 && !skip_scope_increment) {

        sd = sd->sender();

        if (sd != NULL) {

          bci = sd->bci();

        }

        ++scope_depth;

      }

    } while (!top_frame_only && handler_bci < 0 && sd != NULL);

  }

  // found handling method => lookup exception handler

  int catch_pco = ret_pc - nm->instructions_begin();

  ExceptionHandlerTable table(nm);

  HandlerTableEntry *t = table.entry_for(catch_pco, handler_bci, scope_depth);

  if (t == NULL && (nm->is_compiled_by_c1() || handler_bci != -1)) {

    // Allow abbreviated catch tables.  The idea is to allow a method

    // to materialize its exceptions without committing to the exact

    // routing of exceptions.  In particular this is needed for adding

    // a synthethic handler to unlock monitors when inlining

    // synchonized methods since the unlock path isn't represented in

    // the bytecodes.

    t = table.entry_for(catch_pco, -1, 0);

  }

#ifdef COMPILER1

  if (nm->is_compiled_by_c1() && t == NULL && handler_bci == -1) {

    // Exception is not handled by this frame so unwind.  Note that

    // this is not the same as how C2 does this.  C2 emits a table

    // entry that dispatches to the unwind code in the nmethod.

    return NULL;

  }

#endif /* COMPILER1 */

  if (t == NULL) {

    tty->print_cr("MISSING EXCEPTION HANDLER for pc " INTPTR_FORMAT " and handler bci %d", ret_pc, handler_bci);

    tty->print_cr("   Exception:");

    exception->print();

    tty->cr();

    tty->print_cr(" Compiled exception table :");

    table.print();

    nm->print_code();

    guarantee(false, "missing exception handler");

    return NULL;

  }

  return nm->instructions_begin() + t->pco();

}

JRT_ENTRY(void, SharedRuntime::throw_AbstractMethodError(JavaThread* thread))

  // These errors occur only at call sites

  throw_and_post_jvmti_exception(thread, vmSymbols::java_lang_AbstractMethodError());

JRT_END

JRT_ENTRY(void, SharedRuntime::throw_IncompatibleClassChangeError(JavaThread* thread))

  // These errors occur only at call sites

  throw_and_post_jvmti_exception(thread, vmSymbols::java_lang_IncompatibleClassChangeError(), "vtable stub");

JRT_END

JRT_ENTRY(void, SharedRuntime::throw_ArithmeticException(JavaThread* thread))

  throw_and_post_jvmti_exception(thread, vmSymbols::java_lang_ArithmeticException(), "/ by zero");

JRT_END

JRT_ENTRY(void, SharedRuntime::throw_NullPointerException(JavaThread* thread))

  throw_and_post_jvmti_exception(thread, vmSymbols::java_lang_NullPointerException());

JRT_END

JRT_ENTRY(void, SharedRuntime::throw_NullPointerException_at_call(JavaThread* thread))

  // This entry point is effectively only used for NullPointerExceptions which occur at inline

  // cache sites (when the callee activation is not yet set up) so we are at a call site

  throw_and_post_jvmti_exception(thread, vmSymbols::java_lang_NullPointerException());

JRT_END

JRT_ENTRY(void, SharedRuntime::throw_StackOverflowError(JavaThread* thread))

  // We avoid using the normal exception construction in this case because

  // it performs an upcall to Java, and we're already out of stack space.

  klassOop k = SystemDictionary::StackOverflowError_klass();

  oop exception_oop = instanceKlass::cast(k)->allocate_instance(CHECK);

  Handle exception (thread, exception_oop);