/*

 * 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 "asm/codeBuffer.hpp"

#include "classfile/javaClasses.inline.hpp"

#include "code/codeCache.hpp"

#include "compiler/compileBroker.hpp"

#include "compiler/disassembler.hpp"

#include "jvmci/jvmciRuntime.hpp"

#include "jvmci/jvmciCompilerToVM.hpp"

#include "jvmci/jvmciCompiler.hpp"

#include "jvmci/jvmciJavaClasses.hpp"

#include "jvmci/jvmciEnv.hpp"

#include "logging/log.hpp"

#include "memory/oopFactory.hpp"

#include "memory/resourceArea.hpp"

#include "oops/oop.inline.hpp"

#include "oops/objArrayOop.inline.hpp"

#include "prims/jvm.h"

#include "runtime/biasedLocking.hpp"

#include "runtime/interfaceSupport.hpp"

#include "runtime/reflection.hpp"

#include "runtime/sharedRuntime.hpp"

#include "utilities/debug.hpp"

#include "utilities/defaultStream.hpp"

#include "utilities/macros.hpp"

#if defined(_MSC_VER)

#define strtoll _strtoi64

#endif

jobject JVMCIRuntime::_HotSpotJVMCIRuntime_instance = NULL;

bool JVMCIRuntime::_HotSpotJVMCIRuntime_initialized = false;

bool JVMCIRuntime::_well_known_classes_initialized = false;

int JVMCIRuntime::_trivial_prefixes_count = 0;

char** JVMCIRuntime::_trivial_prefixes = NULL;

JVMCIRuntime::CompLevelAdjustment JVMCIRuntime::_comp_level_adjustment = JVMCIRuntime::none;

bool JVMCIRuntime::_shutdown_called = false;

BasicType JVMCIRuntime::kindToBasicType(Handle kind, TRAPS) {

  if (kind.is_null()) {

    THROW_(vmSymbols::java_lang_NullPointerException(), T_ILLEGAL);

  }

  jchar ch = JavaKind::typeChar(kind);

  switch(ch) {

    case 'Z': return T_BOOLEAN;

    case 'B': return T_BYTE;

    case 'S': return T_SHORT;

    case 'C': return T_CHAR;

    case 'I': return T_INT;

    case 'F': return T_FLOAT;

    case 'J': return T_LONG;

    case 'D': return T_DOUBLE;

    case 'A': return T_OBJECT;

    case '-': return T_ILLEGAL;

    default:

      JVMCI_ERROR_(T_ILLEGAL, "unexpected Kind: %c", ch);

  }

}

// Simple helper to see if the caller of a runtime stub which

// entered the VM has been deoptimized

static bool caller_is_deopted() {

  JavaThread* thread = JavaThread::current();

  RegisterMap reg_map(thread, false);

  frame runtime_frame = thread->last_frame();

  frame caller_frame = runtime_frame.sender(&reg_map);

  assert(caller_frame.is_compiled_frame(), "must be compiled");

  return caller_frame.is_deoptimized_frame();

}

// Stress deoptimization

static void deopt_caller() {

  if ( !caller_is_deopted()) {

    JavaThread* thread = JavaThread::current();

    RegisterMap reg_map(thread, false);

    frame runtime_frame = thread->last_frame();

    frame caller_frame = runtime_frame.sender(&reg_map);

    Deoptimization::deoptimize_frame(thread, caller_frame.id(), Deoptimization::Reason_constraint);

    assert(caller_is_deopted(), "Must be deoptimized");

  }

}

JRT_BLOCK_ENTRY(void, JVMCIRuntime::new_instance(JavaThread* thread, Klass* klass))

  JRT_BLOCK;

  assert(klass->is_klass(), "not a class");

  Handle holder(THREAD, klass->klass_holder()); // keep the klass alive

  instanceKlassHandle h(thread, klass);

  h->check_valid_for_instantiation(true, CHECK);

  // make sure klass is initialized

  h->initialize(CHECK);

  // allocate instance and return via TLS

  oop obj = h->allocate_instance(CHECK);

  thread->set_vm_result(obj);

  JRT_BLOCK_END;

  if (ReduceInitialCardMarks) {

    new_store_pre_barrier(thread);

  }

JRT_END

JRT_BLOCK_ENTRY(void, JVMCIRuntime::new_array(JavaThread* thread, Klass* array_klass, jint length))

  JRT_BLOCK;

  // Note: no handle for klass needed since they are not used

  //       anymore after new_objArray() and no GC can happen before.

  //       (This may have to change if this code changes!)

  assert(array_klass->is_klass(), "not a class");

  oop obj;

  if (array_klass->is_typeArray_klass()) {

    BasicType elt_type = TypeArrayKlass::cast(array_klass)->element_type();

    obj = oopFactory::new_typeArray(elt_type, length, CHECK);

  } else {

    Handle holder(THREAD, array_klass->klass_holder()); // keep the klass alive

    Klass* elem_klass = ObjArrayKlass::cast(array_klass)->element_klass();

    obj = oopFactory::new_objArray(elem_klass, length, CHECK);

  }

  thread->set_vm_result(obj);

  // This is pretty rare but this runtime patch is stressful to deoptimization

  // if we deoptimize here so force a deopt to stress the path.

  if (DeoptimizeALot) {

    static int deopts = 0;

    // Alternate between deoptimizing and raising an error (which will also cause a deopt)

    if (deopts++ % 2 == 0) {

      ResourceMark rm(THREAD);

      THROW(vmSymbols::java_lang_OutOfMemoryError());

    } else {

      deopt_caller();

    }

  }

  JRT_BLOCK_END;

  if (ReduceInitialCardMarks) {

    new_store_pre_barrier(thread);

  }

JRT_END

void JVMCIRuntime::new_store_pre_barrier(JavaThread* thread) {

  // After any safepoint, just before going back to compiled code,

  // we inform the GC that we will be doing initializing writes to

  // this object in the future without emitting card-marks, so

  // GC may take any compensating steps.

  // NOTE: Keep this code consistent with GraphKit::store_barrier.

  oop new_obj = thread->vm_result();

  if (new_obj == NULL)  return;

  assert(Universe::heap()->can_elide_tlab_store_barriers(),

         "compiler must check this first");

  // GC may decide to give back a safer copy of new_obj.

  new_obj = Universe::heap()->new_store_pre_barrier(thread, new_obj);

  thread->set_vm_result(new_obj);

}

JRT_ENTRY(void, JVMCIRuntime::new_multi_array(JavaThread* thread, Klass* klass, int rank, jint* dims))

  assert(klass->is_klass(), "not a class");

  assert(rank >= 1, "rank must be nonzero");

  Handle holder(THREAD, klass->klass_holder()); // keep the klass alive

  oop obj = ArrayKlass::cast(klass)->multi_allocate(rank, dims, CHECK);

  thread->set_vm_result(obj);

JRT_END

JRT_ENTRY(void, JVMCIRuntime::dynamic_new_array(JavaThread* thread, oopDesc* element_mirror, jint length))

  oop obj = Reflection::reflect_new_array(element_mirror, length, CHECK);

  thread->set_vm_result(obj);

JRT_END

JRT_ENTRY(void, JVMCIRuntime::dynamic_new_instance(JavaThread* thread, oopDesc* type_mirror))

  instanceKlassHandle klass(THREAD, java_lang_Class::as_Klass(type_mirror));

  if (klass == NULL) {

    ResourceMark rm(THREAD);

    THROW(vmSymbols::java_lang_InstantiationException());

  }

  // Create new instance (the receiver)

  klass->check_valid_for_instantiation(false, CHECK);

  // Make sure klass gets initialized

  klass->initialize(CHECK);

  oop obj = klass->allocate_instance(CHECK);

  thread->set_vm_result(obj);

JRT_END

extern void vm_exit(int code);

// Enter this method from compiled code handler below. This is where we transition

// to VM mode. This is done as a helper routine so that the method called directly

// from compiled code does not have to transition to VM. This allows the entry

// method to see if the nmethod that we have just looked up a handler for has

// been deoptimized while we were in the vm. This simplifies the assembly code

// cpu directories.

//

// We are entering here from exception stub (via the entry method below)

// If there is a compiled exception handler in this method, we will continue there;

// otherwise we will unwind the stack and continue at the caller of top frame method

// Note: we enter in Java using a special JRT wrapper. This wrapper allows us to

// control the area where we can allow a safepoint. After we exit the safepoint area we can

// check to see if the handler we are going to return is now in a nmethod that has

// been deoptimized. If that is the case we return the deopt blob

// unpack_with_exception entry instead. This makes life for the exception blob easier

// because making that same check and diverting is painful from assembly language.

JRT_ENTRY_NO_ASYNC(static address, exception_handler_for_pc_helper(JavaThread* thread, oopDesc* ex, address pc, CompiledMethod*& cm))

  // Reset method handle flag.

  thread->set_is_method_handle_return(false);

  Handle exception(thread, ex);

  cm = CodeCache::find_compiled(pc);

  assert(cm != NULL, "this is not a compiled method");

  // Adjust the pc as needed/

  if (cm->is_deopt_pc(pc)) {

    RegisterMap map(thread, false);

    frame exception_frame = thread->last_frame().sender(&map);

    // if the frame isn't deopted then pc must not correspond to the caller of last_frame

    assert(exception_frame.is_deoptimized_frame(), "must be deopted");

    pc = exception_frame.pc();

  }

#ifdef ASSERT

  assert(exception.not_null(), "NULL exceptions should be handled by throw_exception");

  assert(exception->is_oop(), "just checking");

  // Check that exception is a subclass of Throwable, otherwise we have a VerifyError

  if (!(exception->is_a(SystemDictionary::Throwable_klass()))) {

    if (ExitVMOnVerifyError) vm_exit(-1);

    ShouldNotReachHere();

  }

#endif

  // Check the stack guard pages and reenable them if necessary and there is

  // enough space on the stack to do so.  Use fast exceptions only if the guard

  // pages are enabled.

  bool guard_pages_enabled = thread->stack_guards_enabled();

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

  if (JvmtiExport::can_post_on_exceptions()) {

    // To ensure correct notification of exception catches and throws

    // we have to deoptimize here.  If we attempted to notify the

    // catches and throws during this exception lookup it's possible

    // we could deoptimize on the way out of the VM and end back in

    // the interpreter at the throw site.  This would result in double

    // notifications since the interpreter would also notify about

    // these same catches and throws as it unwound the frame.

    RegisterMap reg_map(thread);

    frame stub_frame = thread->last_frame();

    frame caller_frame = stub_frame.sender(&reg_map);

    // We don't really want to deoptimize the nmethod itself since we

    // can actually continue in the exception handler ourselves but I

    // don't see an easy way to have the desired effect.

    Deoptimization::deoptimize_frame(thread, caller_frame.id(), Deoptimization::Reason_constraint);

    assert(caller_is_deopted(), "Must be deoptimized");

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

  }

  // ExceptionCache is used only for exceptions at call sites and not for implicit exceptions

  if (guard_pages_enabled) {

    address fast_continuation = cm->handler_for_exception_and_pc(exception, pc);

    if (fast_continuation != NULL) {

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

      thread->set_is_method_handle_return(cm->is_method_handle_return(pc));

      return fast_continuation;

    }

  }

  // If the stack guard pages are enabled, check whether there is a handler in

  // the current method.  Otherwise (guard pages disabled), force an unwind and

  // skip the exception cache update (i.e., just leave continuation==NULL).

  address continuation = NULL;

  if (guard_pages_enabled) {

    // New exception handling mechanism can support inlined methods

    // with exception handlers since the mappings are from PC to PC

    // debugging support

    // tracing

    if (log_is_enabled(Info, exceptions)) {

      ResourceMark rm;

      stringStream tempst;

      tempst.print("compiled method <%s>\n"

                   " at PC" INTPTR_FORMAT " for thread " INTPTR_FORMAT,

                   cm->method()->print_value_string(), p2i(pc), p2i(thread));

      Exceptions::log_exception(exception, tempst);

    }

    // for AbortVMOnException flag

    NOT_PRODUCT(Exceptions::debug_check_abort(exception));

    // Clear out the exception oop and pc since looking up an

    // exception handler can cause class loading, which might throw an

    // exception and those fields are expected to be clear during

    // normal bytecode execution.

    thread->clear_exception_oop_and_pc();

    bool recursive_exception = false;

    continuation = SharedRuntime::compute_compiled_exc_handler(cm, pc, exception, false, false, recursive_exception);

    // If an exception was thrown during exception dispatch, the exception oop may have changed

    thread->set_exception_oop(exception());

    thread->set_exception_pc(pc);

    // the exception cache is used only by non-implicit exceptions

    // Update the exception cache only when there didn't happen

    // another exception during the computation of the compiled

    // exception handler. Checking for exception oop equality is not

    // sufficient because some exceptions are pre-allocated and reused.

    if (continuation != NULL && !recursive_exception && !SharedRuntime::deopt_blob()->contains(continuation)) {

      cm->add_handler_for_exception_and_pc(exception, pc, continuation);

    }

  }

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

  thread->set_is_method_handle_return(cm->is_method_handle_return(pc));

  if (log_is_enabled(Info, exceptions)) {

    ResourceMark rm;

    log_info(exceptions)("Thread " PTR_FORMAT " continuing at PC " PTR_FORMAT

                         " for exception thrown at PC " PTR_FORMAT,

                         p2i(thread), p2i(continuation), p2i(pc));

  }

  return continuation;

JRT_END

// Enter this method from compiled code only if there is a Java exception handler

// in the method handling the exception.

// We are entering here from exception stub. We don't do a normal VM transition here.

// We do it in a helper. This is so we can check to see if the nmethod we have just

// searched for an exception handler has been deoptimized in the meantime.

address JVMCIRuntime::exception_handler_for_pc(JavaThread* thread) {

  oop exception = thread->exception_oop();

  address pc = thread->exception_pc();

  // Still in Java mode

  DEBUG_ONLY(ResetNoHandleMark rnhm);

  CompiledMethod* cm = NULL;

  address continuation = NULL;

  {

    // Enter VM mode by calling the helper

    ResetNoHandleMark rnhm;

    continuation = exception_handler_for_pc_helper(thread, exception, pc, cm);

  }

  // Back in JAVA, use no oops DON'T safepoint

  // Now check to see if the compiled method we were called from is now deoptimized.

  // If so we must return to the deopt blob and deoptimize the nmethod

  if (cm != NULL && caller_is_deopted()) {

    continuation = SharedRuntime::deopt_blob()->unpack_with_exception_in_tls();

  }

  assert(continuation != NULL, "no handler found");

  return continuation;

}

JRT_ENTRY_NO_ASYNC(void, JVMCIRuntime::monitorenter(JavaThread* thread, oopDesc* obj, BasicLock* lock))

  IF_TRACE_jvmci_3 {

    char type[O_BUFLEN];

    obj->klass()->name()->as_C_string(type, O_BUFLEN);

    markOop mark = obj->mark();

    TRACE_jvmci_3("%s: entered locking slow case with obj=" INTPTR_FORMAT ", type=%s, mark=" INTPTR_FORMAT ", lock=" INTPTR_FORMAT, thread->name(), p2i(obj), type, p2i(mark), p2i(lock));

    tty->flush();

  }

#ifdef ASSERT

  if (PrintBiasedLockingStatistics) {

    Atomic::inc(BiasedLocking::slow_path_entry_count_addr());

  }

#endif

  Handle h_obj(thread, obj);

  assert(h_obj()->is_oop(), "must be NULL or an object");

  if (UseBiasedLocking) {

    // Retry fast entry if bias is revoked to avoid unnecessary inflation

    ObjectSynchronizer::fast_enter(h_obj, lock, true, CHECK);

  } else {

    if (JVMCIUseFastLocking) {

      // When using fast locking, the compiled code has already tried the fast case

      ObjectSynchronizer::slow_enter(h_obj, lock, THREAD);

    } else {

      ObjectSynchronizer::fast_enter(h_obj, lock, false, THREAD);

    }

  }

  TRACE_jvmci_3("%s: exiting locking slow with obj=" INTPTR_FORMAT, thread->name(), p2i(obj));

JRT_END

JRT_LEAF(void, JVMCIRuntime::monitorexit(JavaThread* thread, oopDesc* obj, BasicLock* lock))

  assert(thread == JavaThread::current(), "threads must correspond");

  assert(thread->last_Java_sp(), "last_Java_sp must be set");

  // monitorexit is non-blocking (leaf routine) => no exceptions can be thrown

  EXCEPTION_MARK;

#ifdef DEBUG

  if (!obj->is_oop()) {

    ResetNoHandleMark rhm;

    nmethod* method = thread->last_frame().cb()->as_nmethod_or_null();

    if (method != NULL) {

      tty->print_cr("ERROR in monitorexit in method %s wrong obj " INTPTR_FORMAT, method->name(), p2i(obj));

    }

    thread->print_stack_on(tty);

    assert(false, "invalid lock object pointer dected");

  }

#endif

  if (JVMCIUseFastLocking) {

    // When using fast locking, the compiled code has already tried the fast case

    ObjectSynchronizer::slow_exit(obj, lock, THREAD);

  } else {

    ObjectSynchronizer::fast_exit(obj, lock, THREAD);

  }

  IF_TRACE_jvmci_3 {

    char type[O_BUFLEN];

    obj->klass()->name()->as_C_string(type, O_BUFLEN);

    TRACE_jvmci_3("%s: exited locking slow case with obj=" INTPTR_FORMAT ", type=%s, mark=" INTPTR_FORMAT ", lock=" INTPTR_FORMAT, thread->name(), p2i(obj), type, p2i(obj->mark()), p2i(lock));

    tty->flush();

  }

JRT_END

JRT_ENTRY(void, JVMCIRuntime::throw_and_post_jvmti_exception(JavaThread* thread, const char* exception, const char* message))

  TempNewSymbol symbol = SymbolTable::new_symbol(exception, CHECK);

  SharedRuntime::throw_and_post_jvmti_exception(thread, symbol, message);

JRT_END

JRT_ENTRY(void, JVMCIRuntime::throw_klass_external_name_exception(JavaThread* thread, const char* exception, Klass* klass))

  ResourceMark rm(thread);

  TempNewSymbol symbol = SymbolTable::new_symbol(exception, CHECK);

  SharedRuntime::throw_and_post_jvmti_exception(thread, symbol, klass->external_name());

JRT_END

JRT_ENTRY(void, JVMCIRuntime::throw_class_cast_exception(JavaThread* thread, const char* exception, Klass* caster_klass, Klass* target_klass))

  ResourceMark rm(thread);

  const char* message = SharedRuntime::generate_class_cast_message(caster_klass, target_klass);

  TempNewSymbol symbol = SymbolTable::new_symbol(exception, CHECK);

  SharedRuntime::throw_and_post_jvmti_exception(thread, symbol, message);

JRT_END

JRT_LEAF(void, JVMCIRuntime::log_object(JavaThread* thread, oopDesc* obj, bool as_string, bool newline))

  ttyLocker ttyl;

  if (obj == NULL) {

    tty->print("NULL");

  } else if (obj->is_oop_or_null(true) && (!as_string || !java_lang_String::is_instance(obj))) {

    if (obj->is_oop_or_null(true)) {

      char buf[O_BUFLEN];

      tty->print("%s@" INTPTR_FORMAT, obj->klass()->name()->as_C_string(buf, O_BUFLEN), p2i(obj));

    } else {

      tty->print(INTPTR_FORMAT, p2i(obj));

    }

  } else {

    ResourceMark rm;

    assert(obj != NULL && java_lang_String::is_instance(obj), "must be");

    char *buf = java_lang_String::as_utf8_string(obj);

    tty->print_raw(buf);

  }

  if (newline) {

    tty->cr();

  }

JRT_END

JRT_LEAF(void, JVMCIRuntime::write_barrier_pre(JavaThread* thread, oopDesc* obj))

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

JRT_END

JRT_LEAF(void, JVMCIRuntime::write_barrier_post(JavaThread* thread, void* card_addr))

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

JRT_END

JRT_LEAF(jboolean, JVMCIRuntime::validate_object(JavaThread* thread, oopDesc* parent, oopDesc* child))

  bool ret = true;

  if(!Universe::heap()->is_in_closed_subset(parent)) {

    tty->print_cr("Parent Object " INTPTR_FORMAT " not in heap", p2i(parent));

    parent->print();

    ret=false;

  }

  if(!Universe::heap()->is_in_closed_subset(child)) {

    tty->print_cr("Child Object " INTPTR_FORMAT " not in heap", p2i(child));

    child->print();

    ret=false;

  }

  return (jint)ret;

JRT_END

JRT_ENTRY(void, JVMCIRuntime::vm_error(JavaThread* thread, jlong where, jlong format, jlong value))

  ResourceMark rm;

  const char *error_msg = where == 0L ? "<internal JVMCI error>" : (char*) (address) where;

  char *detail_msg = NULL;

  if (format != 0L) {

    const char* buf = (char*) (address) format;

    size_t detail_msg_length = strlen(buf) * 2;

    detail_msg = (char *) NEW_RESOURCE_ARRAY(u_char, detail_msg_length);

    jio_snprintf(detail_msg, detail_msg_length, buf, value);

    report_vm_error(__FILE__, __LINE__, error_msg, "%s", detail_msg);

  } else {

    report_vm_error(__FILE__, __LINE__, error_msg);

  }

JRT_END

JRT_LEAF(oopDesc*, JVMCIRuntime::load_and_clear_exception(JavaThread* thread))

  oop exception = thread->exception_oop();

  assert(exception != NULL, "npe");

  thread->set_exception_oop(NULL);

  thread->set_exception_pc(0);