/*

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

#include "classfile/systemDictionary.hpp"

#include "classfile/vmSymbols.hpp"

#include "code/codeCache.hpp"

#include "code/compiledIC.hpp"

#include "code/codeCacheExtensions.hpp"

#include "code/scopeDesc.hpp"

#include "code/vtableStubs.hpp"

#include "compiler/abstractCompiler.hpp"

#include "compiler/compileBroker.hpp"

#include "compiler/disassembler.hpp"

#include "gc/shared/gcLocker.inline.hpp"

#include "interpreter/interpreter.hpp"

#include "interpreter/interpreterRuntime.hpp"

#include "logging/log.hpp"

#include "memory/resourceArea.hpp"

#include "memory/universe.inline.hpp"

#include "oops/klass.hpp"

#include "oops/objArrayKlass.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/atomic.inline.hpp"

#include "runtime/biasedLocking.hpp"

#include "runtime/compilationPolicy.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 "trace/tracing.hpp"

#include "utilities/copy.hpp"

#include "utilities/dtrace.hpp"

#include "utilities/events.hpp"

#include "utilities/hashtable.inline.hpp"

#include "utilities/macros.hpp"

#include "utilities/xmlstream.hpp"

#ifdef COMPILER1

#include "c1/c1_Runtime1.hpp"

#endif

// Shared stub locations

RuntimeStub*        SharedRuntime::_wrong_method_blob;

RuntimeStub*        SharedRuntime::_wrong_method_abstract_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;

SafepointBlob*      SharedRuntime::_polling_page_vectors_safepoint_handler_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");

  _wrong_method_abstract_blob          = generate_resolve_blob(CAST_FROM_FN_PTR(address, SharedRuntime::handle_wrong_method_abstract), "wrong_method_abstract_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");

#if defined(COMPILER2) || INCLUDE_JVMCI

  // Vectors are generated only by C2 and JVMCI.

  bool support_wide = is_wide_vector(MaxVectorSize);

  if (support_wide) {

    _polling_page_vectors_safepoint_handler_blob = generate_handler_blob(CAST_FROM_FN_PTR(address, SafepointSynchronize::handle_polling_page_exception), POLL_AT_VECTOR_LOOP);

  }

#endif // COMPILER2 || INCLUDE_JVMCI

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

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

  generate_deopt_blob();

#ifdef COMPILER2

  generate_uncommon_trap_blob();

#endif // COMPILER2

}

#include <math.h>

// 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", p2i(_ICmiss_at[i]), _ICmiss_count[i]);

      tot_misses += _ICmiss_count[i];

    }

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

  }

}

#endif // PRODUCT

#if INCLUDE_ALL_GCS

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

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;

  }

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

#else

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

#endif

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;

  }

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

#else

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

#endif

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 across 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), "must be a return address: " INTPTR_FORMAT, p2i(return_address));

  assert(thread->frames_to_pop_failed_realloc() == 0 || Interpreter::contains(return_address), "missed frames to pop?");

  // Reset method handle flag.

  thread->set_is_method_handle_return(false);

#if INCLUDE_JVMCI

  // JVMCI's ExceptionHandlerStub expects the thread local exception PC to be clear

  // and other exception handler continuations do not read it

  thread->set_exception_pc(NULL);

#endif

  // The fastest case first

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

  nmethod* nm = (blob != NULL) ? blob->as_nmethod_or_null() : NULL;

  if (nm != NULL) {

    // Set flag if return address is a method handle call site.

    thread->set_is_method_handle_return(nm->is_method_handle_return(return_address));

    // native nmethods don't have exception handlers

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

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

    if (nm->is_deopt_pc(return_address)) {

      // If we come here because of a stack overflow, the stack may be

      // unguarded. Reguard the stack otherwise if we return to the

      // deopt blob and the stack bang causes a stack overflow we

      // crash.

      bool guard_pages_enabled = thread->stack_guards_enabled();

      if (!guard_pages_enabled) guard_pages_enabled = thread->reguard_stack();

      if (thread->reserved_stack_activation() != thread->stack_base()) {

        thread->set_reserved_stack_activation(thread->stack_base());

      }

      assert(guard_pages_enabled, "stack banging in deopt blob may cause crash");

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