/*

 * Copyright (c) 1999, 2019, 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/symbolTable.hpp"

#include "code/codeCache.hpp"

#include "memory/oopFactory.hpp"

#include "memory/resourceArea.hpp"

#include "memory/universe.hpp"

#include "oops/objArrayKlass.hpp"

#include "oops/typeArrayOop.inline.hpp"

#include "runtime/jniHandles.inline.hpp"

#include "runtime/javaCalls.hpp"

#include "jvmci/jniAccessMark.inline.hpp"

#include "jvmci/jvmciRuntime.hpp"

  _task(task),

  _retryable(true),

  _failure_reason(NULL),

  _failure_reason_on_C_heap(false) {

  // Get Jvmti capabilities under lock to get consistent values.

  MutexLocker mu(JvmtiThreadState_lock);

  _jvmti_can_hotswap_or_post_breakpoint = JvmtiExport::can_hotswap_or_post_breakpoint() ? 1 : 0;

  _jvmti_can_access_local_variables     = JvmtiExport::can_access_local_variables() ? 1 : 0;

  _jvmti_can_post_on_exceptions         = JvmtiExport::can_post_on_exceptions() ? 1 : 0;

  _jvmti_can_pop_frame                  = JvmtiExport::can_pop_frame() ? 1 : 0;

}

bool JVMCICompileState::jvmti_state_changed() const {

  if (!jvmti_can_access_local_variables() &&

      JvmtiExport::can_access_local_variables()) {

    return true;

  }

  if (!jvmti_can_hotswap_or_post_breakpoint() &&

      JvmtiExport::can_hotswap_or_post_breakpoint()) {

    return true;

  }

  if (!jvmti_can_post_on_exceptions() &&

      JvmtiExport::can_post_on_exceptions()) {

    return true;

  }

  if (!jvmti_can_pop_frame() &&

      JvmtiExport::can_pop_frame()) {

    return true;

  }

  return false;

}

JavaVM* JVMCIEnv::_shared_library_javavm = NULL;

void* JVMCIEnv::_shared_library_handle = NULL;

char* JVMCIEnv::_shared_library_path = NULL;

void JVMCIEnv::copy_saved_properties() {

  assert(!is_hotspot(), "can only copy saved properties from HotSpot to native image");

  JavaThread* THREAD = JavaThread::current();

  Klass* k = SystemDictionary::resolve_or_fail(vmSymbols::jdk_vm_ci_services_Services(), Handle(), Handle(), true, THREAD);

  if (HAS_PENDING_EXCEPTION) {

    JVMCIRuntime::exit_on_pending_exception(NULL, "Error initializing jdk.vm.ci.services.Services");

  }

  InstanceKlass* ik = InstanceKlass::cast(k);

  if (ik->should_be_initialized()) {

    ik->initialize(THREAD);

    if (HAS_PENDING_EXCEPTION) {

      JVMCIRuntime::exit_on_pending_exception(NULL, "Error initializing jdk.vm.ci.services.Services");

    }

  }

  // Get the serialized saved properties from HotSpot

  TempNewSymbol serializeSavedProperties = SymbolTable::new_symbol("serializeSavedProperties");

  JavaValue result(T_OBJECT);

  JavaCallArguments args;

  JavaCalls::call_static(&result, ik, serializeSavedProperties, vmSymbols::serializePropertiesToByteArray_signature(), &args, THREAD);

  if (HAS_PENDING_EXCEPTION) {

    JVMCIRuntime::exit_on_pending_exception(NULL, "Error calling jdk.vm.ci.services.Services.serializeSavedProperties");

  }

  oop res = (oop) result.get_jobject();

  assert(res->is_typeArray(), "must be");

  assert(TypeArrayKlass::cast(res->klass())->element_type() == T_BYTE, "must be");

  typeArrayOop ba = typeArrayOop(res);

  int serialized_properties_len = ba->length();

  // Copy serialized saved properties from HotSpot object into native buffer

  jbyte* serialized_properties = NEW_RESOURCE_ARRAY(jbyte, serialized_properties_len);

  memcpy(serialized_properties, ba->byte_at_addr(0), serialized_properties_len);

  // Copy native buffer into shared library object

  JVMCIPrimitiveArray buf = new_byteArray(serialized_properties_len, this);

  if (has_pending_exception()) {

    describe_pending_exception(true);

    fatal("Error in copy_saved_properties");

  }

  copy_bytes_from(serialized_properties, buf, 0, serialized_properties_len);

  if (has_pending_exception()) {

    describe_pending_exception(true);

    fatal("Error in copy_saved_properties");

  }

  // Initialize saved properties in shared library

  jclass servicesClass = JNIJVMCI::Services::clazz();

  jmethodID initializeSavedProperties = JNIJVMCI::Services::initializeSavedProperties_method();

  JNIAccessMark jni(this);

  jni()->CallStaticVoidMethod(servicesClass, initializeSavedProperties, buf.as_jobject());

  if (jni()->ExceptionCheck()) {

    jni()->ExceptionDescribe();

    fatal("Error calling jdk.vm.ci.services.Services.initializeSavedProperties");

  }

}

JNIEnv* JVMCIEnv::init_shared_library(JavaThread* thread) {

  if (_shared_library_javavm == NULL) {

    MutexLocker locker(JVMCI_lock);

    if (_shared_library_javavm == NULL) {

      char path[JVM_MAXPATHLEN];

      char ebuf[1024];

      if (JVMCILibPath != NULL) {

        if (!os::dll_locate_lib(path, sizeof(path), JVMCILibPath, JVMCI_SHARED_LIBRARY_NAME)) {

          vm_exit_during_initialization("Unable to create JVMCI shared library path from -XX:JVMCILibPath value", JVMCILibPath);

        }

      } else {

        if (!os::dll_locate_lib(path, sizeof(path), Arguments::get_dll_dir(), JVMCI_SHARED_LIBRARY_NAME)) {

          vm_exit_during_initialization("Unable to create path to JVMCI shared library");

        }

      }

      void* handle = os::dll_load(path, ebuf, sizeof ebuf);

      if (handle == NULL) {

        vm_exit_during_initialization("Unable to load JVMCI shared library", ebuf);

      }

      _shared_library_handle = handle;

      _shared_library_path = strdup(path);

      jint (*JNI_CreateJavaVM)(JavaVM **pvm, void **penv, void *args);

      typedef jint (*JNI_CreateJavaVM_t)(JavaVM **pvm, void **penv, void *args);

      JNI_CreateJavaVM = CAST_TO_FN_PTR(JNI_CreateJavaVM_t, os::dll_lookup(handle, "JNI_CreateJavaVM"));

      JNIEnv* env;

      if (JNI_CreateJavaVM == NULL) {

        vm_exit_during_initialization("Unable to find JNI_CreateJavaVM", path);

      }

      ResourceMark rm;

      JavaVMInitArgs vm_args;

      vm_args.version = JNI_VERSION_1_2;

      vm_args.ignoreUnrecognized = JNI_TRUE;

      vm_args.options = NULL;

      vm_args.nOptions = 0;

      JavaVM* the_javavm = NULL;

      int result = (*JNI_CreateJavaVM)(&the_javavm, (void**) &env, &vm_args);

      if (result == JNI_OK) {

        guarantee(env != NULL, "missing env");

        _shared_library_javavm = the_javavm;

        return env;

      } else {

        vm_exit_during_initialization(err_msg("JNI_CreateJavaVM failed with return value %d", result), path);

      }

    }

  }

  return NULL;

}

void JVMCIEnv::init_env_mode_runtime(JavaThread* thread, JNIEnv* parent_env) {

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

  // By default there is only one runtime which is the compiler runtime.

  _runtime = JVMCI::compiler_runtime();

  _env = NULL;

  _pop_frame_on_close = false;

  _detach_on_close = false;

  if (!UseJVMCINativeLibrary) {

    // In HotSpot mode, JNI isn't used at all.

    _is_hotspot = true;

    return;

  }

  if (parent_env != NULL) {

    // If the parent JNI environment is non-null then figure out whether it

    // is a HotSpot or shared library JNIEnv and set the state appropriately.

    _is_hotspot = thread->jni_environment() == parent_env;

    if (_is_hotspot) {

      // Select the Java runtime

      _runtime = JVMCI::java_runtime();

      return;

    }

    _env = parent_env;

    return;

  }

  // Running in JVMCI shared library mode so ensure the shared library

  // is loaded and initialized and get a shared library JNIEnv

  _is_hotspot = false;

  _env = init_shared_library(thread);

  if (_env != NULL) {

    // Creating the JVMCI shared library VM also attaches the current thread

    _detach_on_close = true;

  } else {

    _shared_library_javavm->GetEnv((void**)&parent_env, JNI_VERSION_1_2);

    if (parent_env != NULL) {

      // Even though there's a parent JNI env, there's no guarantee

      // it was opened by a JVMCIEnv scope and thus may not have

      // pushed a local JNI frame. As such, we use a new JNI local

      // frame in this scope to ensure local JNI refs are collected

      // in a timely manner after leaving this scope.

      _env = parent_env;

    } else {

      ResourceMark rm; // Thread name is resource allocated

      JavaVMAttachArgs attach_args;

      attach_args.version = JNI_VERSION_1_2;

      attach_args.name = thread->name();

      attach_args.group = NULL;

      if (_shared_library_javavm->AttachCurrentThread((void**)&_env, &attach_args) != JNI_OK) {

        fatal("Error attaching current thread (%s) to JVMCI shared library JNI interface", attach_args.name);

      }

      _detach_on_close = true;

    }

  }

  assert(_env != NULL, "missing env");

  assert(_throw_to_caller == false, "must be");

  JNIAccessMark jni(this);

  jint result = _env->PushLocalFrame(32);

  if (result != JNI_OK) {

    char message[256];

    jio_snprintf(message, 256, "Uncaught exception pushing local frame for JVMCIEnv scope entered at %s:%d", _file, _line);

    JVMCIRuntime::exit_on_pending_exception(this, message);

  }

  _pop_frame_on_close = true;

}

JVMCIEnv::JVMCIEnv(JavaThread* thread, JVMCICompileState* compile_state, const char* file, int line):

    _throw_to_caller(false), _file(file), _line(line), _compile_state(compile_state) {

  init_env_mode_runtime(thread, NULL);

}

JVMCIEnv::JVMCIEnv(JavaThread* thread, const char* file, int line):

    _throw_to_caller(false), _file(file), _line(line), _compile_state(NULL) {

  init_env_mode_runtime(thread, NULL);

}

JVMCIEnv::JVMCIEnv(JavaThread* thread, JNIEnv* parent_env, const char* file, int line):

    _throw_to_caller(true), _file(file), _line(line), _compile_state(NULL) {

  init_env_mode_runtime(thread, parent_env);

  assert(_env == NULL || parent_env == _env, "mismatched JNIEnvironment");

}

void JVMCIEnv::init(JavaThread* thread, bool is_hotspot, const char* file, int line) {

  _compile_state = NULL;

  _throw_to_caller = false;

  _file = file;

  _line = line;

  if (is_hotspot) {

    _env = NULL;

    _pop_frame_on_close = false;

    _detach_on_close = false;

    _is_hotspot = true;

    _runtime = JVMCI::java_runtime();

  } else {

    init_env_mode_runtime(thread, NULL);

  }

}

// Prints a pending exception (if any) and its stack trace.

void JVMCIEnv::describe_pending_exception(bool clear) {

  if (!is_hotspot()) {

    JNIAccessMark jni(this);

    if (jni()->ExceptionCheck()) {

      jthrowable ex = !clear ? jni()->ExceptionOccurred() : NULL;

      jni()->ExceptionDescribe();

      if (ex != NULL) {

        jni()->Throw(ex);

      }

    }

  } else {

    Thread* THREAD = Thread::current();

    if (HAS_PENDING_EXCEPTION) {

      JVMCIRuntime::describe_pending_hotspot_exception((JavaThread*) THREAD, clear);

    }

  }

}

void JVMCIEnv::translate_hotspot_exception_to_jni_exception(JavaThread* THREAD, const Handle& throwable) {

  assert(!is_hotspot(), "must_be");

  // Resolve HotSpotJVMCIRuntime class explicitly as HotSpotJVMCI::compute_offsets

  // may not have been called.

  Klass* runtimeKlass = SystemDictionary::resolve_or_fail(vmSymbols::jdk_vm_ci_hotspot_HotSpotJVMCIRuntime(), true, CHECK);

  JavaCallArguments jargs;

  jargs.push_oop(throwable);

  JavaValue result(T_OBJECT);

  JavaCalls::call_static(&result,

                          runtimeKlass,

                          vmSymbols::encodeThrowable_name(),

                          vmSymbols::encodeThrowable_signature(), &jargs, THREAD);

  if (HAS_PENDING_EXCEPTION) {

    JVMCIRuntime::exit_on_pending_exception(this, "HotSpotJVMCIRuntime.encodeThrowable should not throw an exception");

  }

  oop encoded_throwable_string = (oop) result.get_jobject();

  ResourceMark rm;

  const char* encoded_throwable_chars = java_lang_String::as_utf8_string(encoded_throwable_string);

  JNIAccessMark jni(this);

  jobject jni_encoded_throwable_string = jni()->NewStringUTF(encoded_throwable_chars);

  jthrowable jni_throwable = (jthrowable) jni()->CallStaticObjectMethod(JNIJVMCI::HotSpotJVMCIRuntime::clazz(),

                                JNIJVMCI::HotSpotJVMCIRuntime::decodeThrowable_method(),

                                jni_encoded_throwable_string);

  jni()->Throw(jni_throwable);

}

JVMCIEnv::~JVMCIEnv() {

  if (_throw_to_caller) {

    if (is_hotspot()) {

      // Nothing to do

    } else {

      if (Thread::current()->is_Java_thread()) {

        JavaThread* THREAD = JavaThread::current();

        if (HAS_PENDING_EXCEPTION) {

          Handle throwable = Handle(THREAD, PENDING_EXCEPTION);

          CLEAR_PENDING_EXCEPTION;

          translate_hotspot_exception_to_jni_exception(THREAD, throwable);

        }

      }

    }

  } else {

    if (_pop_frame_on_close) {

      // Pop the JNI local frame that was pushed when entering this JVMCIEnv scope.

      JNIAccessMark jni(this);

      jni()->PopLocalFrame(NULL);

    }

    if (has_pending_exception()) {

      char message[256];

      jio_snprintf(message, 256, "Uncaught exception exiting JVMCIEnv scope entered at %s:%d", _file, _line);

      JVMCIRuntime::exit_on_pending_exception(this, message);

    }

    if (_detach_on_close) {

      get_shared_library_javavm()->DetachCurrentThread();

    }

  }

}

jboolean JVMCIEnv::has_pending_exception() {

  if (is_hotspot()) {

    Thread* THREAD = Thread::current();

    return HAS_PENDING_EXCEPTION;

  } else {

    JNIAccessMark jni(this);

    return jni()->ExceptionCheck();

  }

}

void JVMCIEnv::clear_pending_exception() {

  if (is_hotspot()) {

    Thread* THREAD = Thread::current();

    CLEAR_PENDING_EXCEPTION;

  } else {

    JNIAccessMark jni(this);

    jni()->ExceptionClear();

  }

}

int JVMCIEnv::get_length(JVMCIArray array) {

  if (is_hotspot()) {

    return HotSpotJVMCI::resolve(array)->length();

  } else {

    JNIAccessMark jni(this);

    return jni()->GetArrayLength(get_jarray(array));

  }

}

JVMCIObject JVMCIEnv::get_object_at(JVMCIObjectArray array, int index) {

  if (is_hotspot()) {

    oop result = HotSpotJVMCI::resolve(array)->obj_at(index);

    return wrap(result);

  } else {

    JNIAccessMark jni(this);

    jobject result = jni()->GetObjectArrayElement(get_jobjectArray(array), index);

    return wrap(result);

  }

}

void JVMCIEnv::put_object_at(JVMCIObjectArray array, int index, JVMCIObject value) {

  if (is_hotspot()) {

    HotSpotJVMCI::resolve(array)->obj_at_put(index, HotSpotJVMCI::resolve(value));

  } else {

    JNIAccessMark jni(this);

    jni()->SetObjectArrayElement(get_jobjectArray(array), index, get_jobject(value));

  }

}

jboolean JVMCIEnv::get_bool_at(JVMCIPrimitiveArray array, int index) {

  if (is_hotspot()) {

    return HotSpotJVMCI::resolve(array)->bool_at(index);

  } else {

    JNIAccessMark jni(this);

    jboolean result;

    jni()->GetBooleanArrayRegion(array.as_jbooleanArray(), index, 1, &result);

    return result;

  }

}

void JVMCIEnv::put_bool_at(JVMCIPrimitiveArray array, int index, jboolean value) {

  if (is_hotspot()) {

    HotSpotJVMCI::resolve(array)->bool_at_put(index, value);

  } else {

    JNIAccessMark jni(this);

    jni()->SetBooleanArrayRegion(array.as_jbooleanArray(), index, 1, &value);

  }

}

jbyte JVMCIEnv::get_byte_at(JVMCIPrimitiveArray array, int index) {

  if (is_hotspot()) {

    return HotSpotJVMCI::resolve(array)->byte_at(index);

  } else {

    JNIAccessMark jni(this);

    jbyte result;

    jni()->GetByteArrayRegion(array.as_jbyteArray(), index, 1, &result);

    return result;

  }

}

void JVMCIEnv::put_byte_at(JVMCIPrimitiveArray array, int index, jbyte value) {

  if (is_hotspot()) {

    HotSpotJVMCI::resolve(array)->byte_at_put(index, value);

  } else {

    JNIAccessMark jni(this);

    jni()->SetByteArrayRegion(array.as_jbyteArray(), index, 1, &value);

  }

}

jint JVMCIEnv::get_int_at(JVMCIPrimitiveArray array, int index) {

  if (is_hotspot()) {

    return HotSpotJVMCI::resolve(array)->int_at(index);

  } else {

    JNIAccessMark jni(this);

    jint result;

    jni()->GetIntArrayRegion(array.as_jintArray(), index, 1, &result);

    return result;

  }

}

void JVMCIEnv::put_int_at(JVMCIPrimitiveArray array, int index, jint value) {

  if (is_hotspot()) {

    HotSpotJVMCI::resolve(array)->int_at_put(index, value);

  } else {

    JNIAccessMark jni(this);

    jni()->SetIntArrayRegion(array.as_jintArray(), index, 1, &value);

  }

}

long JVMCIEnv::get_long_at(JVMCIPrimitiveArray array, int index) {

  if (is_hotspot()) {

    return HotSpotJVMCI::resolve(array)->long_at(index);

  } else {

    JNIAccessMark jni(this);

    jlong result;

    jni()->GetLongArrayRegion(array.as_jlongArray(), index, 1, &result);

    return result;

  }

}

void JVMCIEnv::put_long_at(JVMCIPrimitiveArray array, int index, jlong value) {

  if (is_hotspot()) {

    HotSpotJVMCI::resolve(array)->long_at_put(index, value);

  } else {

    JNIAccessMark jni(this);

    jni()->SetLongArrayRegion(array.as_jlongArray(), index, 1, &value);

  }

}

void JVMCIEnv::copy_bytes_to(JVMCIPrimitiveArray src, jbyte* dest, int offset, jsize length) {