#include "classfile/stringTable.hpp"

#include "oops/typeArrayOop.inline.hpp"

#include "runtime/jniHandles.inline.hpp"

#include "runtime/javaCalls.hpp"

#include "jvmci/jniAccessMark.inline.hpp"

JVMCICompileState::JVMCICompileState(CompileTask* task, int system_dictionary_modification_counter):

  _failure_reason_on_C_heap(false) {

bool JVMCICompileState::jvmti_state_changed() const {

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", CHECK_EXIT);

  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::attach_shared_library() {

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

      }

  JNIEnv* env;

  if (_shared_library_javavm->AttachCurrentThread((void**)&env, NULL) == JNI_OK) {

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

    return env;

  }

  fatal("Error attaching current thread to JVMCI shared library JNI interface");

  return NULL;

}

void JVMCIEnv::init_env_mode_runtime(JNIEnv* parent_env) {

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

  _runtime = JVMCI::compiler_runtime();

  if (!UseJVMCINativeLibrary) {

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

    _is_hotspot = true;

    _env = NULL;

    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.

    JavaThread* thread = JavaThread::current();

    if (thread->jni_environment() == parent_env) {

      // Select the Java runtime

      _runtime = JVMCI::java_runtime();

      _is_hotspot = true;

      _env = NULL;

      return;

  // Running in JVMCI shared library mode so get a shared library JNIEnv

  _is_hotspot = false;

  _env = attach_shared_library();

  assert(parent_env == NULL || _env == parent_env, "must be");

  if (parent_env == NULL) {

    // There is no parent shared library JNI env so push

    // a JNI local frame to release all local handles in

    // this JVMCIEnv scope when it's closed.

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

    }

  }

}

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

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

  init_env_mode_runtime(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(NULL);

}

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

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

  init_env_mode_runtime(parent_env);

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

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

  _compile_state = NULL;

  _throw_to_caller = false;

  _file = file;

  _line = line;

  if (is_hotspot) {

    _env = NULL;

    _is_hotspot = true;

    _runtime = JVMCI::java_runtime();

  } else {

    init_env_mode_runtime(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

      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 (!is_hotspot()) {

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

  }

}

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, int size_in_bytes) {

  if (size_in_bytes == 0) {

    return;

  }

  if (is_hotspot()) {

    memcpy(dest, HotSpotJVMCI::resolve(src)->byte_at_addr(offset), size_in_bytes);

  } else {

    JNIAccessMark jni(this);

    jni()->GetByteArrayRegion(src.as_jbyteArray(), offset, size_in_bytes, dest);

  }

}

void JVMCIEnv::copy_bytes_from(jbyte* src, JVMCIPrimitiveArray dest, int offset, int size_in_bytes) {

  if (size_in_bytes == 0) {

    return;

  }

  if (is_hotspot()) {

    memcpy(HotSpotJVMCI::resolve(dest)->byte_at_addr(offset), src, size_in_bytes);

  } else {

    JNIAccessMark jni(this);

    jni()->SetByteArrayRegion(dest.as_jbyteArray(), offset, size_in_bytes, src);

  }

jboolean JVMCIEnv::is_boxing_object(BasicType type, JVMCIObject object) {

  if (is_hotspot()) {

    return java_lang_boxing_object::is_instance(HotSpotJVMCI::resolve(object), type);

  } else {

    JNIAccessMark jni(this);

    return jni()->IsInstanceOf(get_jobject(object), JNIJVMCI::box_class(type));

  }

}