< prev index next >
src/hotspot/share/jvmci/jvmciEnv.cpp
Print this page
@@ -66,14 +66,10 @@
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();
@@ -120,79 +116,26 @@
}
// Initialize saved properties in shared library
jclass servicesClass = JNIJVMCI::Services::clazz();
jmethodID initializeSavedProperties = JNIJVMCI::Services::initializeSavedProperties_method();
- JNIAccessMark jni(this);
+ JNIAccessMark jni(this, THREAD);
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.
+ _runtime = JVMCI::java_runtime();
_is_hotspot = true;
return;
}
if (parent_env != NULL) {
@@ -202,24 +145,28 @@
if (_is_hotspot) {
// Select the Java runtime
_runtime = JVMCI::java_runtime();
return;
}
+ _runtime = JVMCI::compiler_runtime();
+ assert(_runtime != NULL, "npe");
_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);
+
+ _runtime = JVMCI::compiler_runtime();
+ _env = _runtime->init_shared_library_javavm();
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);
+ _runtime->GetEnv(thread, (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
@@ -229,21 +176,21 @@
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) {
+ if (_runtime->AttachCurrentThread(thread, (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);
+ JNIAccessMark jni(this, thread);
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);
@@ -283,21 +230,21 @@
}
}
// Prints a pending exception (if any) and its stack trace.
void JVMCIEnv::describe_pending_exception(bool clear) {
+ Thread* THREAD = Thread::current();
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);
}
}
}
@@ -321,11 +268,11 @@
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);
+ JNIAccessMark jni(this, THREAD);
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);
@@ -357,11 +304,11 @@
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();
+ _runtime->DetachCurrentThread(JavaThread::current());
}
}
}
jboolean JVMCIEnv::has_pending_exception() {
@@ -592,16 +539,16 @@
case T_DOUBLE:
break;
default:
JVMCI_THROW_MSG_(IllegalArgumentException, "Only boxes for primitive values can be created", JVMCIObject());
}
- if (is_hotspot()) {
JavaThread* THREAD = JavaThread::current();
+ if (is_hotspot()) {
oop box = java_lang_boxing_object::create(type, value, CHECK_(JVMCIObject()));
return HotSpotJVMCI::wrap(box);
} else {
- JNIAccessMark jni(this);
+ JNIAccessMark jni(this, THREAD);
jobject box = jni()->NewObjectA(JNIJVMCI::box_class(type), JNIJVMCI::box_constructor(type), value);
assert(box != NULL, "");
return wrap(box);
}
}
@@ -661,17 +608,17 @@
va_start(ap, format);
char msg[max_msg_size];
vsnprintf(msg, max_msg_size, format, ap);
msg[max_msg_size-1] = '\0';
va_end(ap);
- if (is_hotspot()) {
JavaThread* THREAD = JavaThread::current();
+ if (is_hotspot()) {
Handle h_loader = Handle();
Handle h_protection_domain = Handle();
Exceptions::_throw_msg(THREAD, file, line, vmSymbols::jdk_vm_ci_common_JVMCIError(), msg, h_loader, h_protection_domain);
} else {
- JNIAccessMark jni(this);
+ JNIAccessMark jni(this, THREAD);
jni()->ThrowNew(JNIJVMCI::JVMCIError::clazz(), msg);
}
}
JVMCIObject JVMCIEnv::call_HotSpotJVMCIRuntime_compileMethod (JVMCIObject runtime, JVMCIObject method, int entry_bci,
@@ -724,11 +671,11 @@
JavaCallArguments jargs;
jargs.push_oop(Handle(THREAD, HotSpotJVMCI::resolve(runtime)));
JavaValue result(T_VOID);
JavaCalls::call_special(&result, HotSpotJVMCI::HotSpotJVMCIRuntime::klass(), vmSymbols::shutdown_name(), vmSymbols::void_method_signature(), &jargs, THREAD);
} else {
- JNIAccessMark jni(this);
+ JNIAccessMark jni(this, THREAD);
jni()->CallNonvirtualVoidMethod(runtime.as_jobject(), JNIJVMCI::HotSpotJVMCIRuntime::clazz(), JNIJVMCI::HotSpotJVMCIRuntime::shutdown_method());
}
if (has_pending_exception()) {
// This should never happen as HotSpotJVMCIRuntime.shutdown() should
// handle all exceptions.
@@ -742,11 +689,11 @@
JavaCallArguments jargs;
JavaValue result(T_OBJECT);
JavaCalls::call_static(&result, HotSpotJVMCI::HotSpotJVMCIRuntime::klass(), vmSymbols::runtime_name(), vmSymbols::runtime_signature(), &jargs, CHECK_(JVMCIObject()));
return wrap((oop) result.get_jobject());
} else {
- JNIAccessMark jni(this);
+ JNIAccessMark jni(this, THREAD);
jobject result = jni()->CallStaticObjectMethod(JNIJVMCI::HotSpotJVMCIRuntime::clazz(), JNIJVMCI::HotSpotJVMCIRuntime::runtime_method());
if (jni()->ExceptionCheck()) {
return JVMCIObject();
}
return wrap(result);
@@ -759,11 +706,11 @@
JavaCallArguments jargs;
JavaValue result(T_OBJECT);
JavaCalls::call_static(&result, HotSpotJVMCI::JVMCI::klass(), vmSymbols::getRuntime_name(), vmSymbols::getRuntime_signature(), &jargs, CHECK_(JVMCIObject()));
return wrap((oop) result.get_jobject());
} else {
- JNIAccessMark jni(this);
+ JNIAccessMark jni(this, THREAD);
jobject result = jni()->CallStaticObjectMethod(JNIJVMCI::JVMCI::clazz(), JNIJVMCI::JVMCI::getRuntime_method());
if (jni()->ExceptionCheck()) {
return JVMCIObject();
}
return wrap(result);
@@ -777,11 +724,11 @@
jargs.push_oop(Handle(THREAD, HotSpotJVMCI::resolve(runtime)));
JavaValue result(T_OBJECT);
JavaCalls::call_virtual(&result, HotSpotJVMCI::HotSpotJVMCIRuntime::klass(), vmSymbols::getCompiler_name(), vmSymbols::getCompiler_signature(), &jargs, CHECK_(JVMCIObject()));
return wrap((oop) result.get_jobject());
} else {
- JNIAccessMark jni(this);
+ JNIAccessMark jni(this, THREAD);
jobject result = jni()->CallObjectMethod(runtime.as_jobject(), JNIJVMCI::HotSpotJVMCIRuntime::getCompiler_method());
if (jni()->ExceptionCheck()) {
return JVMCIObject();
}
return wrap(result);
@@ -799,11 +746,11 @@
HotSpotJVMCI::HotSpotJVMCIRuntime::klass(),
vmSymbols::callToString_name(),
vmSymbols::callToString_signature(), &jargs, CHECK_(JVMCIObject()));
return wrap((oop) result.get_jobject());
} else {
- JNIAccessMark jni(this);
+ JNIAccessMark jni(this, THREAD);
jobject result = (jstring) jni()->CallStaticObjectMethod(JNIJVMCI::HotSpotJVMCIRuntime::clazz(),
JNIJVMCI::HotSpotJVMCIRuntime::callToString_method(),
object.as_jobject());
if (jni()->ExceptionCheck()) {
return JVMCIObject();
@@ -824,11 +771,11 @@
HotSpotJVMCI::PrimitiveConstant::klass(),
vmSymbols::forTypeChar_name(),
vmSymbols::forTypeChar_signature(), &jargs, CHECK_(JVMCIObject()));
return wrap((oop) result.get_jobject());
} else {
- JNIAccessMark jni(this);
+ JNIAccessMark jni(this, THREAD);
jobject result = (jstring) jni()->CallStaticObjectMethod(JNIJVMCI::PrimitiveConstant::clazz(),
JNIJVMCI::PrimitiveConstant::forTypeChar_method(),
kind, value);
if (jni()->ExceptionCheck()) {
return JVMCIObject();
@@ -847,11 +794,11 @@
HotSpotJVMCI::JavaConstant::klass(),
vmSymbols::forFloat_name(),
vmSymbols::forFloat_signature(), &jargs, CHECK_(JVMCIObject()));
return wrap((oop) result.get_jobject());
} else {
- JNIAccessMark jni(this);
+ JNIAccessMark jni(this, THREAD);
jobject result = (jstring) jni()->CallStaticObjectMethod(JNIJVMCI::JavaConstant::clazz(),
JNIJVMCI::JavaConstant::forFloat_method(),
value);
if (jni()->ExceptionCheck()) {
return JVMCIObject();
@@ -870,11 +817,11 @@
HotSpotJVMCI::JavaConstant::klass(),
vmSymbols::forDouble_name(),
vmSymbols::forDouble_signature(), &jargs, CHECK_(JVMCIObject()));
return wrap((oop) result.get_jobject());
} else {
- JNIAccessMark jni(this);
+ JNIAccessMark jni(this, THREAD);
jobject result = (jstring) jni()->CallStaticObjectMethod(JNIJVMCI::JavaConstant::clazz(),
JNIJVMCI::JavaConstant::forDouble_method(),
value);
if (jni()->ExceptionCheck()) {
return JVMCIObject();
@@ -915,11 +862,11 @@
HotSpotJVMCI::StackTraceElement::set_fileName(this, obj(), file_name);
}
HotSpotJVMCI::StackTraceElement::set_lineNumber(this, obj(), line_number);
return wrap(obj());
} else {
- JNIAccessMark jni(this);
+ JNIAccessMark jni(this, THREAD);
jobject declaring_class = jni()->NewStringUTF(declaring_class_str);
if (jni()->ExceptionCheck()) {
return JVMCIObject();
}
jobject method_name = jni()->NewStringUTF(method_name_sym->as_C_string());
@@ -967,11 +914,11 @@
vmSymbols::object_initializer_name(),
vmSymbols::method_string_bool_long_signature(),
&jargs, CHECK_(JVMCIObject()));
return wrap(obj_h());
} else {
- JNIAccessMark jni(this);
+ JNIAccessMark jni(this, THREAD);
jobject nameStr = name == NULL ? NULL : jni()->NewStringUTF(name);
if (jni()->ExceptionCheck()) {
return JVMCIObject();
}
@@ -1004,22 +951,10 @@
JNIAccessMark jni(this);
return wrap(jni()->NewGlobalRef(object.as_jobject()));
}
}
-JVMCIObject JVMCIEnv::make_weak(JVMCIObject object) {
- if (object.is_null()) {
- return JVMCIObject();
- }
- if (is_hotspot()) {
- return wrap(JNIHandles::make_weak_global(Handle(Thread::current(), HotSpotJVMCI::resolve(object))));
- } else {
- JNIAccessMark jni(this);
- return wrap(jni()->NewWeakGlobalRef(object.as_jobject()));
- }
-}
-
void JVMCIEnv::destroy_local(JVMCIObject object) {
if (is_hotspot()) {
JNIHandles::destroy_local(object.as_jobject());
} else {
JNIAccessMark jni(this);
@@ -1034,19 +969,10 @@
JNIAccessMark jni(this);
jni()->DeleteGlobalRef(object.as_jobject());
}
}
-void JVMCIEnv::destroy_weak(JVMCIObject object) {
- if (is_hotspot()) {
- JNIHandles::destroy_weak_global(object.as_jweak());
- } else {
- JNIAccessMark jni(this);
- jni()->DeleteWeakGlobalRef(object.as_jweak());
- }
-}
-
const char* JVMCIEnv::klass_name(JVMCIObject object) {
if (is_hotspot()) {
return HotSpotJVMCI::resolve(object)->klass()->signature_name();
} else {
JVMCIObject name;
@@ -1065,11 +991,11 @@
if (method() == NULL) {
return method_object;
}
Thread* THREAD = Thread::current();
- jmetadata handle = JVMCI::allocate_handle(method);
+ jmetadata handle = _runtime->allocate_handle(method);
jboolean exception = false;
if (is_hotspot()) {
JavaValue result(T_OBJECT);
JavaCallArguments args;
args.push_long((jlong) handle);
@@ -1088,17 +1014,17 @@
(jlong) handle));
exception = jni()->ExceptionCheck();
}
if (exception) {
- JVMCI::release_handle(handle);
+ _runtime->release_handle(handle);
return JVMCIObject();
}
assert(asMethod(method_object) == method(), "must be");
if (get_HotSpotResolvedJavaMethodImpl_metadataHandle(method_object) != (jlong) handle) {
- JVMCI::release_handle(handle);
+ _runtime->release_handle(handle);
}
assert(!method_object.is_null(), "must be");
return method_object;
}
@@ -1126,11 +1052,11 @@
exception = true;
} else {
type = wrap((oop)result.get_jobject());
}
} else {
- JNIAccessMark jni(this);
+ JNIAccessMark jni(this, THREAD);
HandleMark hm(THREAD);
type = JNIJVMCI::wrap(jni()->CallStaticObjectMethod(JNIJVMCI::HotSpotResolvedObjectTypeImpl::clazz(),
JNIJVMCI::HotSpotResolvedObjectTypeImpl_fromMetaspace_method(),
pointer, signature.as_jstring()));
@@ -1144,14 +1070,14 @@
return type;
}
JVMCIObject JVMCIEnv::get_jvmci_constant_pool(const constantPoolHandle& cp, JVMCI_TRAPS) {
JVMCIObject cp_object;
- jmetadata handle = JVMCI::allocate_handle(cp);
+ jmetadata handle = _runtime->allocate_handle(cp);
jboolean exception = false;
- if (is_hotspot()) {
JavaThread* THREAD = JavaThread::current();
+ if (is_hotspot()) {
JavaValue result(T_OBJECT);
JavaCallArguments args;
args.push_long((jlong) handle);
JavaCalls::call_static(&result,
HotSpotJVMCI::HotSpotConstantPool::klass(),
@@ -1161,139 +1087,139 @@
exception = true;
} else {
cp_object = wrap((oop)result.get_jobject());
}
} else {
- JNIAccessMark jni(this);
+ JNIAccessMark jni(this, THREAD);
cp_object = JNIJVMCI::wrap(jni()->CallStaticObjectMethod(JNIJVMCI::HotSpotConstantPool::clazz(),
JNIJVMCI::HotSpotConstantPool_fromMetaspace_method(),
(jlong) handle));
exception = jni()->ExceptionCheck();
}
if (exception) {
- JVMCI::release_handle(handle);
+ _runtime->release_handle(handle);
return JVMCIObject();
}
assert(!cp_object.is_null(), "must be");
// Constant pools aren't cached so this is always a newly created object using the handle
assert(get_HotSpotConstantPool_metadataHandle(cp_object) == (jlong) handle, "must use same handle");
return cp_object;
}
JVMCIPrimitiveArray JVMCIEnv::new_booleanArray(int length, JVMCI_TRAPS) {
- if (is_hotspot()) {
JavaThread* THREAD = JavaThread::current();
+ if (is_hotspot()) {
typeArrayOop result = oopFactory::new_boolArray(length, CHECK_(JVMCIObject()));
return wrap(result);
} else {
- JNIAccessMark jni(this);
+ JNIAccessMark jni(this, THREAD);
jbooleanArray result = jni()->NewBooleanArray(length);
return wrap(result);
}
}
JVMCIPrimitiveArray JVMCIEnv::new_byteArray(int length, JVMCI_TRAPS) {
- if (is_hotspot()) {
JavaThread* THREAD = JavaThread::current();
+ if (is_hotspot()) {
typeArrayOop result = oopFactory::new_byteArray(length, CHECK_(JVMCIObject()));
return wrap(result);
} else {
- JNIAccessMark jni(this);
+ JNIAccessMark jni(this, THREAD);
jbyteArray result = jni()->NewByteArray(length);
return wrap(result);
}
}
JVMCIObjectArray JVMCIEnv::new_byte_array_array(int length, JVMCI_TRAPS) {
- if (is_hotspot()) {
JavaThread* THREAD = JavaThread::current();
+ if (is_hotspot()) {
Klass* byteArrayArrayKlass = TypeArrayKlass::cast(Universe::byteArrayKlassObj ())->array_klass(CHECK_(JVMCIObject()));
objArrayOop result = ObjArrayKlass::cast(byteArrayArrayKlass) ->allocate(length, CHECK_(JVMCIObject()));
return wrap(result);
} else {
- JNIAccessMark jni(this);
+ JNIAccessMark jni(this, THREAD);
jobjectArray result = jni()->NewObjectArray(length, JNIJVMCI::byte_array(), NULL);
return wrap(result);
}
}
JVMCIPrimitiveArray JVMCIEnv::new_intArray(int length, JVMCI_TRAPS) {
- if (is_hotspot()) {
JavaThread* THREAD = JavaThread::current();
+ if (is_hotspot()) {
typeArrayOop result = oopFactory::new_intArray(length, CHECK_(JVMCIObject()));
return wrap(result);
} else {
- JNIAccessMark jni(this);
+ JNIAccessMark jni(this, THREAD);
jintArray result = jni()->NewIntArray(length);
return wrap(result);
}
}
JVMCIPrimitiveArray JVMCIEnv::new_longArray(int length, JVMCI_TRAPS) {
- if (is_hotspot()) {
JavaThread* THREAD = JavaThread::current();
+ if (is_hotspot()) {
typeArrayOop result = oopFactory::new_longArray(length, CHECK_(JVMCIObject()));
return wrap(result);
} else {
- JNIAccessMark jni(this);
+ JNIAccessMark jni(this, THREAD);
jlongArray result = jni()->NewLongArray(length);
return wrap(result);
}
}
JVMCIObject JVMCIEnv::new_VMField(JVMCIObject name, JVMCIObject type, jlong offset, jlong address, JVMCIObject value, JVMCI_TRAPS) {
- if (is_hotspot()) {
JavaThread* THREAD = JavaThread::current();
+ if (is_hotspot()) {
HotSpotJVMCI::VMField::klass()->initialize(CHECK_(JVMCIObject()));
oop obj = HotSpotJVMCI::VMField::klass()->allocate_instance(CHECK_(JVMCIObject()));
HotSpotJVMCI::VMField::set_name(this, obj, HotSpotJVMCI::resolve(name));
HotSpotJVMCI::VMField::set_type(this, obj, HotSpotJVMCI::resolve(type));
HotSpotJVMCI::VMField::set_offset(this, obj, offset);
HotSpotJVMCI::VMField::set_address(this, obj, address);
HotSpotJVMCI::VMField::set_value(this, obj, HotSpotJVMCI::resolve(value));
return wrap(obj);
} else {
- JNIAccessMark jni(this);
+ JNIAccessMark jni(this, THREAD);
jobject result = jni()->NewObject(JNIJVMCI::VMField::clazz(),
JNIJVMCI::VMField::constructor(),
get_jobject(name), get_jobject(type), offset, address, get_jobject(value));
return wrap(result);
}
}
JVMCIObject JVMCIEnv::new_VMFlag(JVMCIObject name, JVMCIObject type, JVMCIObject value, JVMCI_TRAPS) {
- if (is_hotspot()) {
JavaThread* THREAD = JavaThread::current();
+ if (is_hotspot()) {
HotSpotJVMCI::VMFlag::klass()->initialize(CHECK_(JVMCIObject()));
oop obj = HotSpotJVMCI::VMFlag::klass()->allocate_instance(CHECK_(JVMCIObject()));
HotSpotJVMCI::VMFlag::set_name(this, obj, HotSpotJVMCI::resolve(name));
HotSpotJVMCI::VMFlag::set_type(this, obj, HotSpotJVMCI::resolve(type));
HotSpotJVMCI::VMFlag::set_value(this, obj, HotSpotJVMCI::resolve(value));
return wrap(obj);
} else {
- JNIAccessMark jni(this);
+ JNIAccessMark jni(this, THREAD);
jobject result = jni()->NewObject(JNIJVMCI::VMFlag::clazz(),
JNIJVMCI::VMFlag::constructor(),
get_jobject(name), get_jobject(type), get_jobject(value));
return wrap(result);
}
}
JVMCIObject JVMCIEnv::new_VMIntrinsicMethod(JVMCIObject declaringClass, JVMCIObject name, JVMCIObject descriptor, int id, JVMCI_TRAPS) {
- if (is_hotspot()) {
JavaThread* THREAD = JavaThread::current();
+ if (is_hotspot()) {
HotSpotJVMCI::VMIntrinsicMethod::klass()->initialize(CHECK_(JVMCIObject()));
oop obj = HotSpotJVMCI::VMIntrinsicMethod::klass()->allocate_instance(CHECK_(JVMCIObject()));
HotSpotJVMCI::VMIntrinsicMethod::set_declaringClass(this, obj, HotSpotJVMCI::resolve(declaringClass));
HotSpotJVMCI::VMIntrinsicMethod::set_name(this, obj, HotSpotJVMCI::resolve(name));
HotSpotJVMCI::VMIntrinsicMethod::set_descriptor(this, obj, HotSpotJVMCI::resolve(descriptor));
HotSpotJVMCI::VMIntrinsicMethod::set_id(this, obj, id);
return wrap(obj);
} else {
- JNIAccessMark jni(this);
+ JNIAccessMark jni(this, THREAD);
jobject result = jni()->NewObject(JNIJVMCI::VMIntrinsicMethod::clazz(),
JNIJVMCI::VMIntrinsicMethod::constructor(),
get_jobject(declaringClass), get_jobject(name), get_jobject(descriptor), id);
return wrap(result);
}
@@ -1335,11 +1261,11 @@
HotSpotJVMCI::DirectHotSpotObjectConstantImpl::set_object(this, constant, obj());
HotSpotJVMCI::HotSpotObjectConstantImpl::set_compressed(this, constant, compressed);
return wrap(constant);
} else {
jlong handle = make_handle(obj);
- JNIAccessMark jni(this);
+ JNIAccessMark jni(this, THREAD);
jobject result = jni()->NewObject(JNIJVMCI::IndirectHotSpotObjectConstantImpl::clazz(),
JNIJVMCI::IndirectHotSpotObjectConstantImpl::constructor(),
handle, compressed, dont_register);
return wrap(result);
}
@@ -1374,11 +1300,11 @@
return JVMCIObject::create(object, is_hotspot());
}
jlong JVMCIEnv::make_handle(const Handle& obj) {
assert(!obj.is_null(), "should only create handle for non-NULL oops");
- jobject handle = JVMCI::make_global(obj);
+ jobject handle = _runtime->make_global(obj);
return (jlong) handle;
}
oop JVMCIEnv::resolve_handle(jlong objectHandle) {
assert(objectHandle != 0, "should be a valid handle");
@@ -1388,19 +1314,19 @@
}
return obj;
}
JVMCIObject JVMCIEnv::create_string(const char* str, JVMCI_TRAPS) {
- if (is_hotspot()) {
JavaThread* THREAD = JavaThread::current();
+ if (is_hotspot()) {
Handle result = java_lang_String::create_from_str(str, CHECK_(JVMCIObject()));
return HotSpotJVMCI::wrap(result());
} else {
jobject result;
jboolean exception = false;
{
- JNIAccessMark jni(this);
+ JNIAccessMark jni(this, THREAD);
result = jni()->NewStringUTF(str);
exception = jni()->ExceptionCheck();
}
return wrap(result);
}
< prev index next >