/*

 * 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 "classfile/vmSymbols.hpp"

#include "code/compiledIC.hpp"

#include "code/scopeDesc.hpp"

#include "code/vtableStubs.hpp"

#include "compiler/abstractCompiler.hpp"

#include "compiler/compileBroker.hpp"

#include "compiler/compilerOracle.hpp"

#include "interpreter/interpreter.hpp"

#include "interpreter/interpreterRuntime.hpp"

#include "memory/gcLocker.inline.hpp"

#include "memory/universe.inline.hpp"

#include "oops/oop.inline.hpp"

#include "prims/forte.hpp"

#include "prims/jvmtiExport.hpp"

#include "prims/jvmtiRedefineClassesTrace.hpp"

#include "prims/methodHandles.hpp"

#include "prims/nativeLookup.hpp"

#include "runtime/arguments.hpp"

#include "runtime/biasedLocking.hpp"

#include "runtime/handles.inline.hpp"

#include "runtime/init.hpp"

#include "runtime/interfaceSupport.hpp"

#include "runtime/javaCalls.hpp"

#include "runtime/sharedRuntime.hpp"

#include "runtime/stubRoutines.hpp"

#include "runtime/vframe.hpp"

#include "runtime/vframeArray.hpp"

#include "utilities/copy.hpp"

#include "utilities/dtrace.hpp"

#include "utilities/events.hpp"

#include "utilities/hashtable.inline.hpp"

#include "utilities/xmlstream.hpp"

#ifdef TARGET_ARCH_x86

# include "nativeInst_x86.hpp"

# include "vmreg_x86.inline.hpp"

#endif

#ifdef TARGET_ARCH_sparc

# include "nativeInst_sparc.hpp"

# include "vmreg_sparc.inline.hpp"

#endif

#ifdef TARGET_ARCH_zero

# include "nativeInst_zero.hpp"

# include "vmreg_zero.inline.hpp"

#endif

#ifdef TARGET_ARCH_arm

# include "nativeInst_arm.hpp"

# include "vmreg_arm.inline.hpp"

#endif

#ifdef TARGET_ARCH_ppc

# include "nativeInst_ppc.hpp"

# include "vmreg_ppc.inline.hpp"

#endif

#ifdef COMPILER1

#include "c1/c1_Runtime1.hpp"

#endif

// Shared stub locations

RuntimeStub*        SharedRuntime::_wrong_method_blob;

RuntimeStub*        SharedRuntime::_ic_miss_blob;

RuntimeStub*        SharedRuntime::_resolve_opt_virtual_call_blob;

RuntimeStub*        SharedRuntime::_resolve_virtual_call_blob;

RuntimeStub*        SharedRuntime::_resolve_static_call_blob;

DeoptimizationBlob* SharedRuntime::_deopt_blob;

RicochetBlob*       SharedRuntime::_ricochet_blob;

SafepointBlob*      SharedRuntime::_polling_page_safepoint_handler_blob;

SafepointBlob*      SharedRuntime::_polling_page_return_handler_blob;

#ifdef COMPILER2

UncommonTrapBlob*   SharedRuntime::_uncommon_trap_blob;

#endif // COMPILER2

//----------------------------generate_stubs-----------------------------------

void SharedRuntime::generate_stubs() {

  _wrong_method_blob                   = generate_resolve_blob(CAST_FROM_FN_PTR(address, SharedRuntime::handle_wrong_method),         "wrong_method_stub");

  _ic_miss_blob                        = generate_resolve_blob(CAST_FROM_FN_PTR(address, SharedRuntime::handle_wrong_method_ic_miss), "ic_miss_stub");

  _resolve_opt_virtual_call_blob       = generate_resolve_blob(CAST_FROM_FN_PTR(address, SharedRuntime::resolve_opt_virtual_call_C),  "resolve_opt_virtual_call");

  _resolve_virtual_call_blob           = generate_resolve_blob(CAST_FROM_FN_PTR(address, SharedRuntime::resolve_virtual_call_C),      "resolve_virtual_call");

  _resolve_static_call_blob            = generate_resolve_blob(CAST_FROM_FN_PTR(address, SharedRuntime::resolve_static_call_C),       "resolve_static_call");

  _polling_page_safepoint_handler_blob = generate_handler_blob(CAST_FROM_FN_PTR(address, SafepointSynchronize::handle_polling_page_exception), false);

  _polling_page_return_handler_blob    = generate_handler_blob(CAST_FROM_FN_PTR(address, SafepointSynchronize::handle_polling_page_exception), true);

  generate_ricochet_blob();

  generate_deopt_blob();

#ifdef COMPILER2

  generate_uncommon_trap_blob();

#endif // COMPILER2

}

//----------------------------generate_ricochet_blob---------------------------

void SharedRuntime::generate_ricochet_blob() {

  if (!EnableInvokeDynamic)  return;  // leave it as a null

  // allocate space for the code

  ResourceMark rm;

  // setup code generation tools

  CodeBuffer buffer("ricochet_blob", 256 LP64_ONLY(+ 256), 256);  // XXX x86 LP64L: 512, 512

  MacroAssembler* masm = new MacroAssembler(&buffer);

  int bounce_offset = -1, exception_offset = -1, frame_size_in_words = -1;

  MethodHandles::RicochetFrame::generate_ricochet_blob(masm, &bounce_offset, &exception_offset, &frame_size_in_words);

  // -------------

  // make sure all code is generated

  masm->flush();

  // failed to generate?

  if (bounce_offset < 0 || exception_offset < 0 || frame_size_in_words < 0) {

    assert(false, "bad ricochet blob");

    return;

  }

  _ricochet_blob = RicochetBlob::create(&buffer, bounce_offset, exception_offset, frame_size_in_words);

}

#include <math.h>

#ifndef USDT2

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

#endif /* !USDT2 */

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

#ifdef __SOFTFP__

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

  return x + y;

JRT_END

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

  return x - y;

JRT_END

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

  return x * y;

JRT_END

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

  return x / y;

JRT_END

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

  return x + y;

JRT_END

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

  return x - y;

JRT_END

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

  return x * y;

JRT_END

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

  return x / y;

JRT_END

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

  return (jfloat)x;

JRT_END

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

  return (jdouble)x;

JRT_END

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

  return (jdouble)x;

JRT_END

JRT_LEAF(int,  SharedRuntime::fcmpl(float x, float y))

  return x>y ? 1 : (x==y ? 0 : -1);  /* x<y or is_nan*/

JRT_END

JRT_LEAF(int,  SharedRuntime::fcmpg(float x, float y))

  return x<y ? -1 : (x==y ? 0 : 1);  /* x>y or is_nan */

JRT_END

JRT_LEAF(int,  SharedRuntime::dcmpl(double x, double y))

  return x>y ? 1 : (x==y ? 0 : -1); /* x<y or is_nan */

JRT_END

JRT_LEAF(int,  SharedRuntime::dcmpg(double x, double y))

  return x<y ? -1 : (x==y ? 0 : 1);  /* x>y or is_nan */

JRT_END

// Functions to return the opposite of the aeabi functions for nan.

JRT_LEAF(int, SharedRuntime::unordered_fcmplt(float x, float y))

  return (x < y) ? 1 : ((g_isnan(x) || g_isnan(y)) ? 1 : 0);

JRT_END

JRT_LEAF(int, SharedRuntime::unordered_dcmplt(double x, double y))

  return (x < y) ? 1 : ((g_isnan(x) || g_isnan(y)) ? 1 : 0);

JRT_END

JRT_LEAF(int, SharedRuntime::unordered_fcmple(float x, float y))

  return (x <= y) ? 1 : ((g_isnan(x) || g_isnan(y)) ? 1 : 0);

JRT_END

JRT_LEAF(int, SharedRuntime::unordered_dcmple(double x, double y))

  return (x <= y) ? 1 : ((g_isnan(x) || g_isnan(y)) ? 1 : 0);

JRT_END

JRT_LEAF(int, SharedRuntime::unordered_fcmpge(float x, float y))

  return (x >= y) ? 1 : ((g_isnan(x) || g_isnan(y)) ? 1 : 0);

JRT_END

JRT_LEAF(int, SharedRuntime::unordered_dcmpge(double x, double y))

  return (x >= y) ? 1 : ((g_isnan(x) || g_isnan(y)) ? 1 : 0);

JRT_END

JRT_LEAF(int, SharedRuntime::unordered_fcmpgt(float x, float y))

  return (x > y) ? 1 : ((g_isnan(x) || g_isnan(y)) ? 1 : 0);

JRT_END

JRT_LEAF(int, SharedRuntime::unordered_dcmpgt(double x, double y))

  return (x > y) ? 1 : ((g_isnan(x) || g_isnan(y)) ? 1 : 0);

JRT_END

// Intrinsics make gcc generate code for these.

float  SharedRuntime::fneg(float f)   {

  return -f;

}

double SharedRuntime::dneg(double f)  {

  return -f;

}

#endif // __SOFTFP__

#if defined(__SOFTFP__) || defined(E500V2)

// Intrinsics make gcc generate code for these.

double SharedRuntime::dabs(double f)  {

  return (f <= (double)0.0) ? (double)0.0 - f : f;

}

#endif

#if defined(__SOFTFP__) || defined(PPC)

double SharedRuntime::dsqrt(double f) {

  return sqrt(f);

}

#endif

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(JavaThread* thread, address return_address) {

  assert(frame::verify_return_pc(return_address), err_msg("must be a return address: " INTPTR_FORMAT, return_address));

  // Reset method handle flag.

  thread->set_is_method_handle_return(false);

  // The fastest case first