jdk-sandbox: comparison src/hotspot/share/jvmci/jvmciCompilerToVM.cpp

equal deleted inserted replaced

-:81de17a33575
+:2d012a75d35c
 _holder = Handle(_thread, klass->klass_holder());
 }
 return *this;
 }
-void JNIHandleMark::push_jni_handle_block() {
+static void requireInHotSpot(const char* caller, JVMCI_TRAPS) {
-JavaThread* thread = JavaThread::current();
+if (!JVMCIENV->is_hotspot()) {
+JVMCI_THROW_MSG(IllegalStateException, err_msg("Cannot call %s from JVMCI shared library", caller));
+}
+}
+void JNIHandleMark::push_jni_handle_block(JavaThread* thread) {
 if (thread != NULL) {
 // Allocate a new block for JNI handles.
 // Inlined code from jni_PushLocalFrame()
-JNIHandleBlock* java_handles = ((JavaThread*)thread)->active_handles();
+JNIHandleBlock* java_handles = thread->active_handles();
 JNIHandleBlock* compile_handles = JNIHandleBlock::allocate_block(thread);
 assert(compile_handles != NULL && java_handles != NULL, "should not be NULL");
 compile_handles->set_pop_frame_link(java_handles);
 thread->set_active_handles(compile_handles);
 }
 }
-void JNIHandleMark::pop_jni_handle_block() {
+void JNIHandleMark::pop_jni_handle_block(JavaThread* thread) {
-JavaThread* thread = JavaThread::current();
 if (thread != NULL) {
 // Release our JNI handle block
 JNIHandleBlock* compile_handles = thread->active_handles();
 JNIHandleBlock* java_handles = compile_handles->pop_frame_link();
 thread->set_active_handles(java_handles);
 oop arg=((objArrayOop) (_args))->obj_at(_index++);
 assert(expectedType == T_OBJECT || java_lang_boxing_object::is_instance(arg, expectedType), "arg type mismatch");
 return Handle(Thread::current(), arg);
 }
-// Entry to native method implementation that transitions current thread to '_thread_in_vm'.
+// Bring the JVMCI compiler thread into the VM state.
+#define JVMCI_VM_ENTRY_MARK                   \
+ThreadInVMfromNative __tiv(thread);         \
+ResetNoHandleMark rnhm;                     \
+HandleMarkCleaner __hm(thread);             \
+Thread* THREAD = thread;                    \
+debug_only(VMNativeEntryWrapper __vew;)
+// Native method block that transitions current thread to '_thread_in_vm'.
+#define C2V_BLOCK(result_type, name, signature)      \
+TRACE_CALL(result_type, jvmci_ ## name signature)  \
+JVMCI_VM_ENTRY_MARK;                               \
+ResourceMark rm;                                   \
+JNI_JVMCIENV(thread, env);
+static Thread* get_current_thread() {
+return Thread::current_or_null_safe();
+}
+// Entry to native method implementation that transitions
+// current thread to '_thread_in_vm'.
 #define C2V_VMENTRY(result_type, name, signature)        \
 JNIEXPORT result_type JNICALL c2v_ ## name signature { \
+Thread* base_thread = get_current_thread();            \
+if (base_thread == NULL) {                             \
+env->ThrowNew(JNIJVMCI::InternalError::clazz(),      \
+err_msg("Cannot call into HotSpot from JVMCI shared library without attaching current thread")); \
+return;                                              \
+}                                                      \
+assert(base_thread->is_Java_thread(), "just checking");\
+JavaThread* thread = (JavaThread*) base_thread;        \
 JVMCITraceMark jtm("CompilerToVM::" #name);            \
-TRACE_CALL(result_type, jvmci_ ## name signature)      \
+C2V_BLOCK(result_type, name, signature)
-JVMCI_VM_ENTRY_MARK;                                   \
-ResourceMark rm;                                       \
+#define C2V_VMENTRY_(result_type, name, signature, result) \
-JNI_JVMCIENV(env);
+JNIEXPORT result_type JNICALL c2v_ ## name signature { \
+Thread* base_thread = get_current_thread();            \
+if (base_thread == NULL) {                             \
+env->ThrowNew(JNIJVMCI::InternalError::clazz(),      \
+err_msg("Cannot call into HotSpot from JVMCI shared library without attaching current thread")); \
+return result;                                       \
+}                                                      \
+assert(base_thread->is_Java_thread(), "just checking");\
+JavaThread* thread = (JavaThread*) base_thread;        \
+JVMCITraceMark jtm("CompilerToVM::" #name);            \
+C2V_BLOCK(result_type, name, signature)
+#define C2V_VMENTRY_NULL(result_type, name, signature) C2V_VMENTRY_(result_type, name, signature, NULL)
+#define C2V_VMENTRY_0(result_type, name, signature) C2V_VMENTRY_(result_type, name, signature, 0)
+// Entry to native method implementation that does not transition
+// current thread to '_thread_in_vm'.
+#define C2V_VMENTRY_PREFIX(result_type, name, signature) \
+JNIEXPORT result_type JNICALL c2v_ ## name signature { \
+Thread* base_thread = get_current_thread();
 #define C2V_END }
+#define JNI_THROW(caller, name, msg) do {                                         \
+jint __throw_res = env->ThrowNew(JNIJVMCI::name::clazz(), msg);               \
+if (__throw_res != JNI_OK) {                                                  \
+tty->print_cr("Throwing " #name " in " caller " returned %d", __throw_res); \
+}                                                                             \
+return;                                                                       \
+} while (0);
+#define JNI_THROW_(caller, name, msg, result) do {                                \
+jint __throw_res = env->ThrowNew(JNIJVMCI::name::clazz(), msg);               \
+if (__throw_res != JNI_OK) {                                                  \
+tty->print_cr("Throwing " #name " in " caller " returned %d", __throw_res); \
+}                                                                             \
+return result;                                                                \
+} while (0)
 jobjectArray readConfiguration0(JNIEnv *env, JVMCI_TRAPS);
-C2V_VMENTRY(jobjectArray, readConfiguration, (JNIEnv* env))
+C2V_VMENTRY_NULL(jobjectArray, readConfiguration, (JNIEnv* env))
 jobjectArray config = readConfiguration0(env, JVMCI_CHECK_NULL);
 return config;
 }
-C2V_VMENTRY(jobject, getFlagValue, (JNIEnv* env, jobject c2vm, jobject name_handle))
+C2V_VMENTRY_NULL(jobject, getFlagValue, (JNIEnv* env, jobject c2vm, jobject name_handle))
 #define RETURN_BOXED_LONG(value) jvalue p; p.j = (jlong) (value); JVMCIObject box = JVMCIENV->create_box(T_LONG, &p, JVMCI_CHECK_NULL); return box.as_jobject();
 #define RETURN_BOXED_DOUBLE(value) jvalue p; p.d = (jdouble) (value); JVMCIObject box = JVMCIENV->create_box(T_DOUBLE, &p, JVMCI_CHECK_NULL); return box.as_jobject();
 JVMCIObject name = JVMCIENV->wrap(name_handle);
 if (name.is_null()) {
 JVMCI_THROW_NULL(NullPointerException);
 }
 #undef RETURN_BOXED_LONG
 #undef RETURN_BOXED_DOUBLE
 C2V_END
-C2V_VMENTRY(jobject, getObjectAtAddress, (JNIEnv* env, jobject c2vm, jlong oop_address))
+C2V_VMENTRY_NULL(jobject, getObjectAtAddress, (JNIEnv* env, jobject c2vm, jlong oop_address))
-if (env != JavaThread::current()->jni_environment()) {
+requireInHotSpot("getObjectAtAddress", JVMCI_CHECK_NULL);
-JVMCI_THROW_MSG_NULL(InternalError, "Only supported when running in HotSpot");
-}
 if (oop_address == 0) {
 JVMCI_THROW_MSG_NULL(InternalError, "Handle must be non-zero");
 }
 oop obj = *((oopDesc**) oop_address);
 if (obj != NULL) {
 oopDesc::verify(obj);
 }
 return JNIHandles::make_local(obj);
 C2V_END
-C2V_VMENTRY(jbyteArray, getBytecode, (JNIEnv* env, jobject, jobject jvmci_method))
+C2V_VMENTRY_NULL(jbyteArray, getBytecode, (JNIEnv* env, jobject, jobject jvmci_method))
 methodHandle method = JVMCIENV->asMethod(jvmci_method);
 int code_size = method->code_size();
 jbyte* reconstituted_code = NEW_RESOURCE_ARRAY(jbyte, code_size);
 JVMCIPrimitiveArray result = JVMCIENV->new_byteArray(code_size, JVMCI_CHECK_NULL);
 JVMCIENV->copy_bytes_from(reconstituted_code, result, 0, code_size);
 return JVMCIENV->get_jbyteArray(result);
 C2V_END
-C2V_VMENTRY(jint, getExceptionTableLength, (JNIEnv* env, jobject, jobject jvmci_method))
+C2V_VMENTRY_0(jint, getExceptionTableLength, (JNIEnv* env, jobject, jobject jvmci_method))
 methodHandle method = JVMCIENV->asMethod(jvmci_method);
 return method->exception_table_length();
 C2V_END
-C2V_VMENTRY(jlong, getExceptionTableStart, (JNIEnv* env, jobject, jobject jvmci_method))
+C2V_VMENTRY_0(jlong, getExceptionTableStart, (JNIEnv* env, jobject, jobject jvmci_method))
 methodHandle method = JVMCIENV->asMethod(jvmci_method);
 if (method->exception_table_length() == 0) {
 return 0L;
 }
 return (jlong) (address) method->exception_table_start();
 C2V_END
-C2V_VMENTRY(jobject, asResolvedJavaMethod, (JNIEnv* env, jobject, jobject executable_handle))
+C2V_VMENTRY_NULL(jobject, asResolvedJavaMethod, (JNIEnv* env, jobject, jobject executable_handle))
-if (env != JavaThread::current()->jni_environment()) {
+requireInHotSpot("asResolvedJavaMethod", JVMCI_CHECK_NULL);
-JVMCI_THROW_MSG_NULL(InternalError, "Only supported when running in HotSpot");
-}
 oop executable = JNIHandles::resolve(executable_handle);
 oop mirror = NULL;
 int slot = 0;
 if (executable->klass() == SystemDictionary::reflect_Constructor_klass()) {
 methodHandle method = InstanceKlass::cast(holder)->method_with_idnum(slot);
 JVMCIObject result = JVMCIENV->get_jvmci_method(method, JVMCI_CHECK_NULL);
 return JVMCIENV->get_jobject(result);
 }
-C2V_VMENTRY(jobject, getResolvedJavaMethod, (JNIEnv* env, jobject, jobject base, jlong offset))
+C2V_VMENTRY_NULL(jobject, getResolvedJavaMethod, (JNIEnv* env, jobject, jobject base, jlong offset))
 methodHandle method;
 JVMCIObject base_object = JVMCIENV->wrap(base);
 if (base_object.is_null()) {
 method = *((Method**)(offset));
 } else if (JVMCIENV->isa_HotSpotObjectConstantImpl(base_object)) {
 assert (method.is_null() || method->is_method(), "invalid read");
 JVMCIObject result = JVMCIENV->get_jvmci_method(method, JVMCI_CHECK_NULL);
 return JVMCIENV->get_jobject(result);
 }
-C2V_VMENTRY(jobject, getConstantPool, (JNIEnv* env, jobject, jobject object_handle))
+C2V_VMENTRY_NULL(jobject, getConstantPool, (JNIEnv* env, jobject, jobject object_handle))
 constantPoolHandle cp;
 JVMCIObject object = JVMCIENV->wrap(object_handle);
 if (object.is_null()) {
 JVMCI_THROW_NULL(NullPointerException);
 }
 JVMCIObject result = JVMCIENV->get_jvmci_constant_pool(cp, JVMCI_CHECK_NULL);
 return JVMCIENV->get_jobject(result);
 }
-C2V_VMENTRY(jobject, getResolvedJavaType0, (JNIEnv* env, jobject, jobject base, jlong offset, jboolean compressed))
+C2V_VMENTRY_NULL(jobject, getResolvedJavaType0, (JNIEnv* env, jobject, jobject base, jlong offset, jboolean compressed))
 JVMCIKlassHandle klass(THREAD);
 JVMCIObject base_object = JVMCIENV->wrap(base);
 jlong base_address = 0;
 if (base_object.is_non_null() && offset == oopDesc::klass_offset_in_bytes()) {
 // klass = JVMCIENV->unhandle(base_object)->klass();
 assert (klass == NULL || klass->is_klass(), "invalid read");
 JVMCIObject result = JVMCIENV->get_jvmci_type(klass, JVMCI_CHECK_NULL);
 return JVMCIENV->get_jobject(result);
 }
-C2V_VMENTRY(jobject, findUniqueConcreteMethod, (JNIEnv* env, jobject, jobject jvmci_type, jobject jvmci_method))
+C2V_VMENTRY_NULL(jobject, findUniqueConcreteMethod, (JNIEnv* env, jobject, jobject jvmci_type, jobject jvmci_method))
 methodHandle method = JVMCIENV->asMethod(jvmci_method);
 Klass* holder = JVMCIENV->asKlass(jvmci_type);
 if (holder->is_interface()) {
 JVMCI_THROW_MSG_NULL(InternalError, err_msg("Interface %s should be handled in Java code", holder->external_name()));
 }
 }
 JVMCIObject result = JVMCIENV->get_jvmci_method(ucm, JVMCI_CHECK_NULL);
 return JVMCIENV->get_jobject(result);
 C2V_END
-C2V_VMENTRY(jobject, getImplementor, (JNIEnv* env, jobject, jobject jvmci_type))
+C2V_VMENTRY_NULL(jobject, getImplementor, (JNIEnv* env, jobject, jobject jvmci_type))
 Klass* klass = JVMCIENV->asKlass(jvmci_type);
 if (!klass->is_interface()) {
 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(),
 err_msg("Expected interface type, got %s", klass->external_name()));
 }
 }
 JVMCIObject implementor = JVMCIENV->get_jvmci_type(handle, JVMCI_CHECK_NULL);
 return JVMCIENV->get_jobject(implementor);
 C2V_END
-C2V_VMENTRY(jboolean, methodIsIgnoredBySecurityStackWalk,(JNIEnv* env, jobject, jobject jvmci_method))
+C2V_VMENTRY_0(jboolean, methodIsIgnoredBySecurityStackWalk,(JNIEnv* env, jobject, jobject jvmci_method))
 methodHandle method = JVMCIENV->asMethod(jvmci_method);
 return method->is_ignored_by_security_stack_walk();
 C2V_END
-C2V_VMENTRY(jboolean, isCompilable,(JNIEnv* env, jobject, jobject jvmci_method))
+C2V_VMENTRY_0(jboolean, isCompilable,(JNIEnv* env, jobject, jobject jvmci_method))
 methodHandle method = JVMCIENV->asMethod(jvmci_method);
 constantPoolHandle cp = method->constMethod()->constants();
 assert(!cp.is_null(), "npe");
 // don't inline method when constant pool contains a CONSTANT_Dynamic
 return !method->is_not_compilable(CompLevel_full_optimization) && !cp->has_dynamic_constant();
 C2V_END
-C2V_VMENTRY(jboolean, hasNeverInlineDirective,(JNIEnv* env, jobject, jobject jvmci_method))
+C2V_VMENTRY_0(jboolean, hasNeverInlineDirective,(JNIEnv* env, jobject, jobject jvmci_method))
 methodHandle method = JVMCIENV->asMethod(jvmci_method);
 return !Inline || CompilerOracle::should_not_inline(method) || method->dont_inline();
 C2V_END
-C2V_VMENTRY(jboolean, shouldInlineMethod,(JNIEnv* env, jobject, jobject jvmci_method))
+C2V_VMENTRY_0(jboolean, shouldInlineMethod,(JNIEnv* env, jobject, jobject jvmci_method))
 methodHandle method = JVMCIENV->asMethod(jvmci_method);
 return CompilerOracle::should_inline(method) || method->force_inline();
 C2V_END
-C2V_VMENTRY(jobject, lookupType, (JNIEnv* env, jobject, jstring jname, jclass accessing_class, jboolean resolve))
+C2V_VMENTRY_NULL(jobject, lookupType, (JNIEnv* env, jobject, jstring jname, jclass accessing_class, jboolean resolve))
 JVMCIObject name = JVMCIENV->wrap(jname);
 const char* str = JVMCIENV->as_utf8_string(name);
 TempNewSymbol class_name = SymbolTable::new_symbol(str, CHECK_NULL);
 if (class_name->utf8_length() <= 1) {
 JVMCIENV->runtime()->initialize(JVMCIENV);
 }
 if (resolve) {
 resolved_klass = SystemDictionary::resolve_or_null(class_name, class_loader, protection_domain, CHECK_0);
+if (resolved_klass == NULL) {
+JVMCI_THROW_MSG_NULL(ClassNotFoundException, str);
+}
 } else {
 if (class_name->char_at(0) == 'L' &&
 class_name->char_at(class_name->utf8_length()-1) == ';') {
 // This is a name from a signature.  Strip off the trimmings.
 // Call recursive to keep scope of strippedsym.
 BasicType t = FieldType::get_array_info(class_name, fd, CHECK_0);
 if (t == T_OBJECT) {
 TempNewSymbol strippedsym = SymbolTable::new_symbol(class_name->as_utf8()+1+fd.dimension(),
 class_name->utf8_length()-2-fd.dimension(),
 CHECK_0);
-// naked oop "k" is OK here -- we assign back into it
 resolved_klass = SystemDictionary::find(strippedsym,
 class_loader,
 protection_domain,
 CHECK_0);
 if (!resolved_klass.is_null()) {
 }
 JVMCIObject result = JVMCIENV->get_jvmci_type(resolved_klass, JVMCI_CHECK_NULL);
 return JVMCIENV->get_jobject(result);
 C2V_END
-C2V_VMENTRY(jobject, lookupClass, (JNIEnv* env, jobject, jclass mirror))
+C2V_VMENTRY_NULL(jobject, lookupClass, (JNIEnv* env, jobject, jclass mirror))
-if (env != JavaThread::current()->jni_environment()) {
+requireInHotSpot("lookupClass", JVMCI_CHECK_NULL);
-JVMCI_THROW_MSG_NULL(InternalError, "Only supported when running in HotSpot");
-}
 if (mirror == NULL) {
 return NULL;
 }
 JVMCIKlassHandle klass(THREAD);
 klass = java_lang_Class::as_Klass(JNIHandles::resolve(mirror));
 }
 JVMCIObject result = JVMCIENV->get_jvmci_type(klass, JVMCI_CHECK_NULL);
 return JVMCIENV->get_jobject(result);
 }
-C2V_VMENTRY(jobject, resolveConstantInPool, (JNIEnv* env, jobject, jobject jvmci_constant_pool, jint index))
+C2V_VMENTRY_NULL(jobject, resolveConstantInPool, (JNIEnv* env, jobject, jobject jvmci_constant_pool, jint index))
 constantPoolHandle cp = JVMCIENV->asConstantPool(jvmci_constant_pool);
 oop result = cp->resolve_constant_at(index, CHECK_NULL);
 return JVMCIENV->get_jobject(JVMCIENV->get_object_constant(result));
 C2V_END
-C2V_VMENTRY(jobject, resolvePossiblyCachedConstantInPool, (JNIEnv* env, jobject, jobject jvmci_constant_pool, jint index))
+C2V_VMENTRY_NULL(jobject, resolvePossiblyCachedConstantInPool, (JNIEnv* env, jobject, jobject jvmci_constant_pool, jint index))
 constantPoolHandle cp = JVMCIENV->asConstantPool(jvmci_constant_pool);
 oop result = cp->resolve_possibly_cached_constant_at(index, CHECK_NULL);
 return JVMCIENV->get_jobject(JVMCIENV->get_object_constant(result));
 C2V_END
-C2V_VMENTRY(jint, lookupNameAndTypeRefIndexInPool, (JNIEnv* env, jobject, jobject jvmci_constant_pool, jint index))
+C2V_VMENTRY_0(jint, lookupNameAndTypeRefIndexInPool, (JNIEnv* env, jobject, jobject jvmci_constant_pool, jint index))
 constantPoolHandle cp = JVMCIENV->asConstantPool(jvmci_constant_pool);
 return cp->name_and_type_ref_index_at(index);
 C2V_END
-C2V_VMENTRY(jobject, lookupNameInPool, (JNIEnv* env, jobject, jobject jvmci_constant_pool, jint which))
+C2V_VMENTRY_NULL(jobject, lookupNameInPool, (JNIEnv* env, jobject, jobject jvmci_constant_pool, jint which))
 constantPoolHandle cp = JVMCIENV->asConstantPool(jvmci_constant_pool);
 JVMCIObject sym = JVMCIENV->create_string(cp->name_ref_at(which), JVMCI_CHECK_NULL);
 return JVMCIENV->get_jobject(sym);
 C2V_END
-C2V_VMENTRY(jobject, lookupSignatureInPool, (JNIEnv* env, jobject, jobject jvmci_constant_pool, jint which))
+C2V_VMENTRY_NULL(jobject, lookupSignatureInPool, (JNIEnv* env, jobject, jobject jvmci_constant_pool, jint which))
 constantPoolHandle cp = JVMCIENV->asConstantPool(jvmci_constant_pool);
 JVMCIObject sym = JVMCIENV->create_string(cp->signature_ref_at(which), JVMCI_CHECK_NULL);
 return JVMCIENV->get_jobject(sym);
 C2V_END
-C2V_VMENTRY(jint, lookupKlassRefIndexInPool, (JNIEnv* env, jobject, jobject jvmci_constant_pool, jint index))
+C2V_VMENTRY_0(jint, lookupKlassRefIndexInPool, (JNIEnv* env, jobject, jobject jvmci_constant_pool, jint index))
 constantPoolHandle cp = JVMCIENV->asConstantPool(jvmci_constant_pool);
 return cp->klass_ref_index_at(index);
 C2V_END
-C2V_VMENTRY(jobject, resolveTypeInPool, (JNIEnv* env, jobject, jobject jvmci_constant_pool, jint index))
+C2V_VMENTRY_NULL(jobject, resolveTypeInPool, (JNIEnv* env, jobject, jobject jvmci_constant_pool, jint index))
 constantPoolHandle cp = JVMCIENV->asConstantPool(jvmci_constant_pool);
 Klass* klass = cp->klass_at(index, CHECK_NULL);
 JVMCIKlassHandle resolved_klass(THREAD, klass);
 if (resolved_klass->is_instance_klass()) {
-bool linked = InstanceKlass::cast(resolved_klass())->link_class_or_fail(CHECK_NULL);
+InstanceKlass::cast(resolved_klass())->link_class(CHECK_NULL);
-if (!linked) {
+if (!InstanceKlass::cast(resolved_klass())->is_linked()) {
-return NULL;
+// link_class() should not return here if there is an issue.
+JVMCI_THROW_MSG_NULL(InternalError, err_msg("Class %s must be linked", resolved_klass()->external_name()));
 }
 }
 JVMCIObject klassObject = JVMCIENV->get_jvmci_type(resolved_klass, JVMCI_CHECK_NULL);
 return JVMCIENV->get_jobject(klassObject);
 C2V_END
-C2V_VMENTRY(jobject, lookupKlassInPool, (JNIEnv* env, jobject, jobject jvmci_constant_pool, jint index, jbyte opcode))
+C2V_VMENTRY_NULL(jobject, lookupKlassInPool, (JNIEnv* env, jobject, jobject jvmci_constant_pool, jint index, jbyte opcode))
 constantPoolHandle cp = JVMCIENV->asConstantPool(jvmci_constant_pool);
 Klass* loading_klass = cp->pool_holder();
 bool is_accessible = false;
 JVMCIKlassHandle klass(THREAD, JVMCIRuntime::get_klass_by_index(cp, index, is_accessible, loading_klass));
 Symbol* symbol = NULL;
 result = JVMCIENV->create_string(symbol, JVMCI_CHECK_NULL);
 }
 return JVMCIENV->get_jobject(result);
 C2V_END
-C2V_VMENTRY(jobject, lookupAppendixInPool, (JNIEnv* env, jobject, jobject jvmci_constant_pool, jint index))
+C2V_VMENTRY_NULL(jobject, lookupAppendixInPool, (JNIEnv* env, jobject, jobject jvmci_constant_pool, jint index))
 constantPoolHandle cp = JVMCIENV->asConstantPool(jvmci_constant_pool);
 oop appendix_oop = ConstantPool::appendix_at_if_loaded(cp, index);
 return JVMCIENV->get_jobject(JVMCIENV->get_object_constant(appendix_oop));
 C2V_END
-C2V_VMENTRY(jobject, lookupMethodInPool, (JNIEnv* env, jobject, jobject jvmci_constant_pool, jint index, jbyte opcode))
+C2V_VMENTRY_NULL(jobject, lookupMethodInPool, (JNIEnv* env, jobject, jobject jvmci_constant_pool, jint index, jbyte opcode))
 constantPoolHandle cp = JVMCIENV->asConstantPool(jvmci_constant_pool);
 InstanceKlass* pool_holder = cp->pool_holder();
 Bytecodes::Code bc = (Bytecodes::Code) (((int) opcode) & 0xFF);
 methodHandle method = JVMCIRuntime::get_method_by_index(cp, index, bc, pool_holder);
 JVMCIObject result = JVMCIENV->get_jvmci_method(method, JVMCI_CHECK_NULL);
 return JVMCIENV->get_jobject(result);
 C2V_END
-C2V_VMENTRY(jint, constantPoolRemapInstructionOperandFromCache, (JNIEnv* env, jobject, jobject jvmci_constant_pool, jint index))
+C2V_VMENTRY_0(jint, constantPoolRemapInstructionOperandFromCache, (JNIEnv* env, jobject, jobject jvmci_constant_pool, jint index))
 constantPoolHandle cp = JVMCIENV->asConstantPool(jvmci_constant_pool);
 return cp->remap_instruction_operand_from_cache(index);
 C2V_END
-C2V_VMENTRY(jobject, resolveFieldInPool, (JNIEnv* env, jobject, jobject jvmci_constant_pool, jint index, jobject jvmci_method, jbyte opcode, jintArray info_handle))
+C2V_VMENTRY_NULL(jobject, resolveFieldInPool, (JNIEnv* env, jobject, jobject jvmci_constant_pool, jint index, jobject jvmci_method, jbyte opcode, jintArray info_handle))
 constantPoolHandle cp = JVMCIENV->asConstantPool(jvmci_constant_pool);
 Bytecodes::Code code = (Bytecodes::Code)(((int) opcode) & 0xFF);
 fieldDescriptor fd;
 LinkInfo link_info(cp, index, (jvmci_method != NULL) ? JVMCIENV->asMethod(jvmci_method) : NULL, CHECK_0);
 LinkResolver::resolve_field(fd, link_info, Bytecodes::java_code(code), false, CHECK_0);
 JVMCIKlassHandle handle(THREAD, fd.field_holder());
 JVMCIObject field_holder = JVMCIENV->get_jvmci_type(handle, JVMCI_CHECK_NULL);
 return JVMCIENV->get_jobject(field_holder);
 C2V_END
-C2V_VMENTRY(jint, getVtableIndexForInterfaceMethod, (JNIEnv* env, jobject, jobject jvmci_type, jobject jvmci_method))
+C2V_VMENTRY_0(jint, getVtableIndexForInterfaceMethod, (JNIEnv* env, jobject, jobject jvmci_type, jobject jvmci_method))
 Klass* klass = JVMCIENV->asKlass(jvmci_type);
 Method* method = JVMCIENV->asMethod(jvmci_method);
 if (klass->is_interface()) {
 JVMCI_THROW_MSG_0(InternalError, err_msg("Interface %s should be handled in Java code", klass->external_name()));
 }
 JVMCI_THROW_MSG_0(InternalError, err_msg("Class %s must be linked", klass->external_name()));
 }
 return LinkResolver::vtable_index_of_interface_method(klass, method);
 C2V_END
-C2V_VMENTRY(jobject, resolveMethod, (JNIEnv* env, jobject, jobject receiver_jvmci_type, jobject jvmci_method, jobject caller_jvmci_type))
+C2V_VMENTRY_NULL(jobject, resolveMethod, (JNIEnv* env, jobject, jobject receiver_jvmci_type, jobject jvmci_method, jobject caller_jvmci_type))
 Klass* recv_klass = JVMCIENV->asKlass(receiver_jvmci_type);
 Klass* caller_klass = JVMCIENV->asKlass(caller_jvmci_type);
 methodHandle method = JVMCIENV->asMethod(jvmci_method);
 Klass* resolved     = method->method_holder();
 JVMCIObject result = JVMCIENV->get_jvmci_method(m, JVMCI_CHECK_NULL);
 return JVMCIENV->get_jobject(result);
 C2V_END
-C2V_VMENTRY(jboolean, hasFinalizableSubclass,(JNIEnv* env, jobject, jobject jvmci_type))
+C2V_VMENTRY_0(jboolean, hasFinalizableSubclass,(JNIEnv* env, jobject, jobject jvmci_type))
 Klass* klass = JVMCIENV->asKlass(jvmci_type);
 assert(klass != NULL, "method must not be called for primitive types");
 return Dependencies::find_finalizable_subclass(klass) != NULL;
 C2V_END
-C2V_VMENTRY(jobject, getClassInitializer, (JNIEnv* env, jobject, jobject jvmci_type))
+C2V_VMENTRY_NULL(jobject, getClassInitializer, (JNIEnv* env, jobject, jobject jvmci_type))
 Klass* klass = JVMCIENV->asKlass(jvmci_type);
 if (!klass->is_instance_klass()) {
 return NULL;
 }
 InstanceKlass* iklass = InstanceKlass::cast(klass);
 JVMCIObject result = JVMCIENV->get_jvmci_method(iklass->class_initializer(), JVMCI_CHECK_NULL);
 return JVMCIENV->get_jobject(result);
 C2V_END
-C2V_VMENTRY(jlong, getMaxCallTargetOffset, (JNIEnv* env, jobject, jlong addr))
+C2V_VMENTRY_0(jlong, getMaxCallTargetOffset, (JNIEnv* env, jobject, jlong addr))
 address target_addr = (address) addr;
 if (target_addr != 0x0) {
 int64_t off_low = (int64_t)target_addr - ((int64_t)CodeCache::low_bound() + sizeof(int));
 int64_t off_high = (int64_t)target_addr - ((int64_t)CodeCache::high_bound() + sizeof(int));
 return MAX2(ABS(off_low), ABS(off_high));
 method->set_not_c1_compilable();
 method->set_not_c2_compilable();
 method->set_dont_inline(true);
 C2V_END
-C2V_VMENTRY(jint, installCode, (JNIEnv *env, jobject, jobject target, jobject compiled_code,
+C2V_VMENTRY_0(jint, installCode, (JNIEnv *env, jobject, jobject target, jobject compiled_code,
 jobject installed_code, jlong failed_speculations_address, jbyteArray speculations_obj))
 HandleMark hm;
-JNIHandleMark jni_hm;
+JNIHandleMark jni_hm(thread);
 JVMCIObject target_handle = JVMCIENV->wrap(target);
 JVMCIObject compiled_code_handle = JVMCIENV->wrap(compiled_code);
 CodeBlob* cb = NULL;
 JVMCIObject installed_code_handle = JVMCIENV->wrap(installed_code);
 }
 }
 return result;
 C2V_END
-C2V_VMENTRY(jint, getMetadata, (JNIEnv *env, jobject, jobject target, jobject compiled_code, jobject metadata))
+C2V_VMENTRY_0(jint, getMetadata, (JNIEnv *env, jobject, jobject target, jobject compiled_code, jobject metadata))
 #if INCLUDE_AOT
 HandleMark hm;
 assert(JVMCIENV->is_hotspot(), "AOT code is executed only in HotSpot mode");
 JVMCIObject target_handle = JVMCIENV->wrap(target);
 CompilerStatistics* stats = compiler->stats();
 stats->_standard.reset();
 stats->_osr.reset();
 C2V_END
-C2V_VMENTRY(jobject, disassembleCodeBlob, (JNIEnv* env, jobject, jobject installedCode))
+C2V_VMENTRY_NULL(jobject, disassembleCodeBlob, (JNIEnv* env, jobject, jobject installedCode))
 HandleMark hm;
 if (installedCode == NULL) {
 JVMCI_THROW_MSG_NULL(NullPointerException, "installedCode is null");
 }
 JVMCIObject result = JVMCIENV->create_string(st.as_string(), JVMCI_CHECK_NULL);
 return JVMCIENV->get_jobject(result);
 C2V_END
-C2V_VMENTRY(jobject, getStackTraceElement, (JNIEnv* env, jobject, jobject jvmci_method, int bci))
+C2V_VMENTRY_NULL(jobject, getStackTraceElement, (JNIEnv* env, jobject, jobject jvmci_method, int bci))
 HandleMark hm;
 methodHandle method = JVMCIENV->asMethod(jvmci_method);
 JVMCIObject element = JVMCIENV->new_StackTraceElement(method, bci, JVMCI_CHECK_NULL);
 return JVMCIENV->get_jobject(element);
 C2V_END
-C2V_VMENTRY(jobject, executeHotSpotNmethod, (JNIEnv* env, jobject, jobject args, jobject hs_nmethod))
+C2V_VMENTRY_NULL(jobject, executeHotSpotNmethod, (JNIEnv* env, jobject, jobject args, jobject hs_nmethod))
-if (env != JavaThread::current()->jni_environment()) {
+// The incoming arguments array would have to contain JavaConstants instead of regular objects
-// The incoming arguments array would have to contain JavaConstants instead of regular objects
+// and the return value would have to be wrapped as a JavaConstant.
-// and the return value would have to be wrapped as a JavaConstant.
+requireInHotSpot("executeHotSpotNmethod", JVMCI_CHECK_NULL);
-JVMCI_THROW_MSG_NULL(InternalError, "Wrapping of arguments is currently unsupported");
-}
 HandleMark hm;
 JVMCIObject nmethod_mirror = JVMCIENV->wrap(hs_nmethod);
 nmethod* nm = JVMCIENV->asNmethod(nmethod_mirror);
 JVMCIObject o = JVMCIENV->create_box(jap.get_ret_type(), value, JVMCI_CHECK_NULL);
 return JVMCIENV->get_jobject(o);
 }
 C2V_END
-C2V_VMENTRY(jlongArray, getLineNumberTable, (JNIEnv* env, jobject, jobject jvmci_method))
+C2V_VMENTRY_NULL(jlongArray, getLineNumberTable, (JNIEnv* env, jobject, jobject jvmci_method))
 Method* method = JVMCIENV->asMethod(jvmci_method);
 if (!method->has_linenumber_table()) {
 return NULL;
 }
 u2 num_entries = 0;
 }
 return (jlongArray) JVMCIENV->get_jobject(result);
 C2V_END
-C2V_VMENTRY(jlong, getLocalVariableTableStart, (JNIEnv* env, jobject, jobject jvmci_method))
+C2V_VMENTRY_0(jlong, getLocalVariableTableStart, (JNIEnv* env, jobject, jobject jvmci_method))
 Method* method = JVMCIENV->asMethod(jvmci_method);
 if (!method->has_localvariable_table()) {
 return 0;
 }
 return (jlong) (address) method->localvariable_table_start();
 C2V_END
-C2V_VMENTRY(jint, getLocalVariableTableLength, (JNIEnv* env, jobject, jobject jvmci_method))
+C2V_VMENTRY_0(jint, getLocalVariableTableLength, (JNIEnv* env, jobject, jobject jvmci_method))
 Method* method = JVMCIENV->asMethod(jvmci_method);
 return method->localvariable_table_length();
 C2V_END
 C2V_VMENTRY(void, reprofile, (JNIEnv* env, jobject, jobject jvmci_method))
 C2V_VMENTRY(void, invalidateHotSpotNmethod, (JNIEnv* env, jobject, jobject hs_nmethod))
 JVMCIObject nmethod_mirror = JVMCIENV->wrap(hs_nmethod);
 JVMCIENV->invalidate_nmethod_mirror(nmethod_mirror, JVMCI_CHECK);
 C2V_END
-C2V_VMENTRY(jobject, readUncompressedOop, (JNIEnv* env, jobject, jlong addr))
+C2V_VMENTRY_NULL(jobject, readUncompressedOop, (JNIEnv* env, jobject, jlong addr))
 oop ret = RawAccess<>::oop_load((oop*)(address)addr);
 return JVMCIENV->get_jobject(JVMCIENV->get_object_constant(ret));
 C2V_END
-C2V_VMENTRY(jlongArray, collectCounters, (JNIEnv* env, jobject))
+C2V_VMENTRY_NULL(jlongArray, collectCounters, (JNIEnv* env, jobject))
+// Returns a zero length array if counters aren't enabled
 JVMCIPrimitiveArray array = JVMCIENV->new_longArray(JVMCICounterSize, JVMCI_CHECK_NULL);
-JavaThread::collect_counters(JVMCIENV, array);
+if (JVMCICounterSize > 0) {
+jlong* temp_array = NEW_RESOURCE_ARRAY(jlong, JVMCICounterSize);
+JavaThread::collect_counters(temp_array, JVMCICounterSize);
+JVMCIENV->copy_longs_from(temp_array, array, 0, JVMCICounterSize);
+}
 return (jlongArray) JVMCIENV->get_jobject(array);
 C2V_END
-C2V_VMENTRY(int, allocateCompileId, (JNIEnv* env, jobject, jobject jvmci_method, int entry_bci))
+C2V_VMENTRY_0(int, allocateCompileId, (JNIEnv* env, jobject, jobject jvmci_method, int entry_bci))
 HandleMark hm;
 if (jvmci_method == NULL) {
 JVMCI_THROW_0(NullPointerException);
 }
 Method* method = JVMCIENV->asMethod(jvmci_method);
 }
 return CompileBroker::assign_compile_id_unlocked(THREAD, method, entry_bci);
 C2V_END
-C2V_VMENTRY(jboolean, isMature, (JNIEnv* env, jobject, jlong metaspace_method_data))
+C2V_VMENTRY_0(jboolean, isMature, (JNIEnv* env, jobject, jlong metaspace_method_data))
 MethodData* mdo = JVMCIENV->asMethodData(metaspace_method_data);
 return mdo != NULL && mdo->is_mature();
 C2V_END
-C2V_VMENTRY(jboolean, hasCompiledCodeForOSR, (JNIEnv* env, jobject, jobject jvmci_method, int entry_bci, int comp_level))
+C2V_VMENTRY_0(jboolean, hasCompiledCodeForOSR, (JNIEnv* env, jobject, jobject jvmci_method, int entry_bci, int comp_level))
 Method* method = JVMCIENV->asMethod(jvmci_method);
 return method->lookup_osr_nmethod_for(entry_bci, comp_level, true) != NULL;
 C2V_END
-C2V_VMENTRY(jobject, getSymbol, (JNIEnv* env, jobject, jlong symbol))
+C2V_VMENTRY_NULL(jobject, getSymbol, (JNIEnv* env, jobject, jlong symbol))
 JVMCIObject sym = JVMCIENV->create_string((Symbol*)(address)symbol, JVMCI_CHECK_NULL);
 return JVMCIENV->get_jobject(sym);
 C2V_END
 bool matches(jobjectArray methods, Method* method, JVMCIEnv* JVMCIENV) {
 // Invoke the method
 JavaCalls::call(result, method, args, CHECK);
 }
-C2V_VMENTRY(jobject, iterateFrames, (JNIEnv* env, jobject compilerToVM, jobjectArray initial_methods, jobjectArray match_methods, jint initialSkip, jobject visitor_handle))
+C2V_VMENTRY_NULL(jobject, iterateFrames, (JNIEnv* env, jobject compilerToVM, jobjectArray initial_methods, jobjectArray match_methods, jint initialSkip, jobject visitor_handle))
 if (!thread->has_last_Java_frame()) {
 return NULL;
 }
 Handle visitor(THREAD, JNIHandles::resolve_non_null(visitor_handle));
-if (env != JavaThread::current()->jni_environment()) {
+requireInHotSpot("iterateFrames", JVMCI_CHECK_NULL);
-JVMCI_THROW_MSG_NULL(InternalError, "getNextStackFrame is only supported for HotSpot stack walking");
-}
 HotSpotJVMCI::HotSpotStackFrameReference::klass()->initialize(CHECK_NULL);
 Handle frame_reference = HotSpotJVMCI::HotSpotStackFrameReference::klass()->allocate_instance_handle(CHECK_NULL);
 StackFrameStream fst(thread);
 ConstantPoolCacheEntry* cp_cache_entry = cp->cache()->entry_at(cp->decode_cpcache_index(index));
 cp_cache_entry->set_method_handle(cp, callInfo);
 }
 C2V_END
-C2V_VMENTRY(jint, isResolvedInvokeHandleInPool, (JNIEnv* env, jobject, jobject jvmci_constant_pool, jint index))
+C2V_VMENTRY_0(jint, isResolvedInvokeHandleInPool, (JNIEnv* env, jobject, jobject jvmci_constant_pool, jint index))
 constantPoolHandle cp = JVMCIENV->asConstantPool(jvmci_constant_pool);
 ConstantPoolCacheEntry* cp_cache_entry = cp->cache()->entry_at(cp->decode_cpcache_index(index));
 if (cp_cache_entry->is_resolved(Bytecodes::_invokehandle)) {
 // MethodHandle.invoke* --> LambdaForm?
 ResourceMark rm;
 }
 return -1;
 C2V_END
-C2V_VMENTRY(jobject, getSignaturePolymorphicHolders, (JNIEnv* env, jobject))
+C2V_VMENTRY_NULL(jobject, getSignaturePolymorphicHolders, (JNIEnv* env, jobject))
 JVMCIObjectArray holders = JVMCIENV->new_String_array(2, JVMCI_CHECK_NULL);
 JVMCIObject mh = JVMCIENV->create_string("Ljava/lang/invoke/MethodHandle;", JVMCI_CHECK_NULL);
 JVMCIObject vh = JVMCIENV->create_string("Ljava/lang/invoke/VarHandle;", JVMCI_CHECK_NULL);
 JVMCIENV->put_object_at(holders, 0, mh);
 JVMCIENV->put_object_at(holders, 1, vh);
 return JVMCIENV->get_jobject(holders);
 C2V_END
-C2V_VMENTRY(jboolean, shouldDebugNonSafepoints, (JNIEnv* env, jobject))
+C2V_VMENTRY_0(jboolean, shouldDebugNonSafepoints, (JNIEnv* env, jobject))
 //see compute_recording_non_safepoints in debugInfroRec.cpp
 if (JvmtiExport::should_post_compiled_method_load() && FLAG_IS_DEFAULT(DebugNonSafepoints)) {
 return true;
 }
 return DebugNonSafepoints;
 JVMCIObject hs_frame = JVMCIENV->wrap(_hs_frame);
 if (hs_frame.is_null()) {
 JVMCI_THROW_MSG(NullPointerException, "stack frame is null");
 }
-if (env != JavaThread::current()->jni_environment()) {
+requireInHotSpot("materializeVirtualObjects", JVMCI_CHECK);
-JVMCI_THROW_MSG(InternalError, "getNextStackFrame is only supported for HotSpot stack walking");
-}
 JVMCIENV->HotSpotStackFrameReference_initialize(JVMCI_CHECK);
 // look for the given stack frame
 StackFrameStream fst(thread);
 }
 }
 HotSpotJVMCI::HotSpotStackFrameReference::set_objectsMaterialized(JVMCIENV, hs_frame, JNI_TRUE);
 C2V_END
-C2V_VMENTRY(void, writeDebugOutput, (JNIEnv* env, jobject, jbyteArray bytes, jint offset, jint length))
+// Creates a scope where the current thread is attached and detached
+// from HotSpot if it wasn't already attached when entering the scope.
+extern "C" void jio_printf(const char *fmt, ...);
+class AttachDetach : public StackObj {
+public:
+bool _attached;
+AttachDetach(JNIEnv* env, Thread* current_thread) {
+if (current_thread == NULL) {
+extern struct JavaVM_ main_vm;
+JNIEnv* hotspotEnv;
+jint res = main_vm.AttachCurrentThread((void**)&hotspotEnv, NULL);
+_attached = res == JNI_OK;
+static volatile int report_attach_error = 0;
+if (res != JNI_OK && report_attach_error == 0 && Atomic::cmpxchg(1, &report_attach_error, 0) == 0) {
+// Only report an attach error once
+jio_printf("Warning: attaching current thread to VM failed with %d (future attach errors are suppressed)\n", res);
+}
+} else {
+_attached = false;
+}
+}
+~AttachDetach() {
+if (_attached && get_current_thread() != NULL) {
+extern struct JavaVM_ main_vm;
+jint res = main_vm.DetachCurrentThread();
+static volatile int report_detach_error = 0;
+if (res != JNI_OK && report_detach_error == 0 && Atomic::cmpxchg(1, &report_detach_error, 0) == 0) {
+// Only report an attach error once
+jio_printf("Warning: detaching current thread from VM failed with %d (future attach errors are suppressed)\n", res);
+}
+}
+}
+};
+C2V_VMENTRY_PREFIX(jint, writeDebugOutput, (JNIEnv* env, jobject, jbyteArray bytes, jint offset, jint length, bool flush, bool can_throw))
+AttachDetach ad(env, base_thread);
+bool use_tty = true;
+if (base_thread == NULL) {
+if (!ad._attached) {
+// Can only use tty if the current thread is attached
+return 0;
+}
+base_thread = get_current_thread();
+}
+JVMCITraceMark jtm("writeDebugOutput");
+assert(base_thread->is_Java_thread(), "just checking");
+JavaThread* thread = (JavaThread*) base_thread;
+C2V_BLOCK(void, writeDebugOutput, (JNIEnv* env, jobject, jbyteArray bytes, jint offset, jint length))
 if (bytes == NULL) {
-JVMCI_THROW(NullPointerException);
+if (can_throw) {
+JVMCI_THROW_0(NullPointerException);
+}
+return -1;
 }
 JVMCIPrimitiveArray array = JVMCIENV->wrap(bytes);
 // Check if offset and length are non negative.
 if (offset < 0 || length < 0) {
-JVMCI_THROW(ArrayIndexOutOfBoundsException);
+if (can_throw) {
+JVMCI_THROW_0(ArrayIndexOutOfBoundsException);
+}
+return -2;
 }
 // Check if the range is valid.
 int array_length = JVMCIENV->get_length(array);
 if ((((unsigned int) length + (unsigned int) offset) > (unsigned int) array_length)) {
-JVMCI_THROW(ArrayIndexOutOfBoundsException);
+if (can_throw) {
+JVMCI_THROW_0(ArrayIndexOutOfBoundsException);
+}
+return -2;
 }
 jbyte buffer[O_BUFLEN];
 while (length > 0) {
 int copy_len = MIN2(length, (jint)O_BUFLEN);
 JVMCIENV->copy_bytes_to(array, buffer, offset, copy_len);
 tty->write((char*) buffer, copy_len);
 length -= O_BUFLEN;
 offset += O_BUFLEN;
 }
+if (flush) {
+tty->flush();
+}
+return 0;
 C2V_END
 C2V_VMENTRY(void, flushDebugOutput, (JNIEnv* env, jobject))
 tty->flush();
 C2V_END
-C2V_VMENTRY(int, methodDataProfileDataSize, (JNIEnv* env, jobject, jlong metaspace_method_data, jint position))
+C2V_VMENTRY_0(int, methodDataProfileDataSize, (JNIEnv* env, jobject, jlong metaspace_method_data, jint position))
 MethodData* mdo = JVMCIENV->asMethodData(metaspace_method_data);
 ProfileData* profile_data = mdo->data_at(position);
 if (mdo->is_valid(profile_data)) {
 return profile_data->size_in_bytes();
 }
 }
 }
 JVMCI_THROW_MSG_0(IllegalArgumentException, err_msg("Invalid profile data position %d", position));
 C2V_END
-C2V_VMENTRY(jlong, getFingerprint, (JNIEnv* env, jobject, jlong metaspace_klass))
+C2V_VMENTRY_0(jlong, getFingerprint, (JNIEnv* env, jobject, jlong metaspace_klass))
 #if INCLUDE_AOT
 Klass *k = (Klass*) (address) metaspace_klass;
 if (k->is_instance_klass()) {
 return InstanceKlass::cast(k)->get_stored_fingerprint();
 } else {
 #else
 JVMCI_THROW_MSG_0(InternalError, "unimplemented");
 #endif
 C2V_END
-C2V_VMENTRY(jobject, getHostClass, (JNIEnv* env, jobject, jobject jvmci_type))
+C2V_VMENTRY_NULL(jobject, getHostClass, (JNIEnv* env, jobject, jobject jvmci_type))
 InstanceKlass* k = InstanceKlass::cast(JVMCIENV->asKlass(jvmci_type));
 InstanceKlass* host = k->unsafe_anonymous_host();
 JVMCIKlassHandle handle(THREAD, host);
 JVMCIObject result = JVMCIENV->get_jvmci_type(handle, JVMCI_CHECK_NULL);
 return JVMCIENV->get_jobject(result);
 C2V_END
-C2V_VMENTRY(jobject, getInterfaces, (JNIEnv* env, jobject, jobject jvmci_type))
+C2V_VMENTRY_NULL(jobject, getInterfaces, (JNIEnv* env, jobject, jobject jvmci_type))
 if (jvmci_type == NULL) {
 JVMCI_THROW_0(NullPointerException);
 }
 Klass* klass = JVMCIENV->asKlass(jvmci_type);
 JVMCIENV->put_object_at(interfaces, index, type);
 }
 return JVMCIENV->get_jobject(interfaces);
 C2V_END
-C2V_VMENTRY(jobject, getComponentType, (JNIEnv* env, jobject, jobject jvmci_type))
+C2V_VMENTRY_NULL(jobject, getComponentType, (JNIEnv* env, jobject, jobject jvmci_type))
 if (jvmci_type == NULL) {
 JVMCI_THROW_0(NullPointerException);
 }
 Klass* klass = JVMCIENV->asKlass(jvmci_type);
 InstanceKlass* k = InstanceKlass::cast(klass);
 k->initialize(CHECK);
 }
 C2V_END
-C2V_VMENTRY(int, interpreterFrameSize, (JNIEnv* env, jobject, jobject bytecode_frame_handle))
+C2V_VMENTRY_0(int, interpreterFrameSize, (JNIEnv* env, jobject, jobject bytecode_frame_handle))
 if (bytecode_frame_handle == NULL) {
 JVMCI_THROW_0(NullPointerException);
 }
 JVMCIObject top_bytecode_frame = JVMCIENV->wrap(bytecode_frame_handle);
 JVMCI_THROW_MSG(IllegalArgumentException,
 err_msg("Unexpected type: %s", lambda_form->klass()->external_name()))
 }
 C2V_END
-C2V_VMENTRY(int, getIdentityHashCode, (JNIEnv* env, jobject, jobject object))
+C2V_VMENTRY_0(int, getIdentityHashCode, (JNIEnv* env, jobject, jobject object))
 Handle obj = JVMCIENV->asConstant(JVMCIENV->wrap(object), JVMCI_CHECK_0);
 return obj->identity_hash();
 C2V_END
-C2V_VMENTRY(jboolean, isInternedString, (JNIEnv* env, jobject, jobject object))
+C2V_VMENTRY_0(jboolean, isInternedString, (JNIEnv* env, jobject, jobject object))
 Handle str = JVMCIENV->asConstant(JVMCIENV->wrap(object), JVMCI_CHECK_0);
 if (!java_lang_String::is_instance(str())) {
 return false;
 }
 int len;
 jchar* name = java_lang_String::as_unicode_string(str(), len, CHECK_0);
 return (StringTable::lookup(name, len) != NULL);
 C2V_END
-C2V_VMENTRY(jobject, unboxPrimitive, (JNIEnv* env, jobject, jobject object))
+C2V_VMENTRY_NULL(jobject, unboxPrimitive, (JNIEnv* env, jobject, jobject object))
 if (object == NULL) {
 JVMCI_THROW_0(NullPointerException);
 }
 Handle box = JVMCIENV->asConstant(JVMCIENV->wrap(object), JVMCI_CHECK_NULL);
 BasicType type = java_lang_boxing_object::basic_type(box());
 }
 JVMCIObject boxResult = JVMCIENV->create_box(type, &result, JVMCI_CHECK_NULL);
 return JVMCIENV->get_jobject(boxResult);
 C2V_END
-C2V_VMENTRY(jobject, boxPrimitive, (JNIEnv* env, jobject, jobject object))
+C2V_VMENTRY_NULL(jobject, boxPrimitive, (JNIEnv* env, jobject, jobject object))
 if (object == NULL) {
 JVMCI_THROW_0(NullPointerException);
 }
 JVMCIObject box = JVMCIENV->wrap(object);
 BasicType type = JVMCIENV->get_box_type(box);
 oop hotspot_box = (oop) box_result.get_jobject();
 JVMCIObject result = JVMCIENV->get_object_constant(hotspot_box, false);
 return JVMCIENV->get_jobject(result);
 C2V_END
-C2V_VMENTRY(jobjectArray, getDeclaredConstructors, (JNIEnv* env, jobject, jobject holder))
+C2V_VMENTRY_NULL(jobjectArray, getDeclaredConstructors, (JNIEnv* env, jobject, jobject holder))
 if (holder == NULL) {
 JVMCI_THROW_0(NullPointerException);
 }
 Klass* klass = JVMCIENV->asKlass(holder);
 if (!klass->is_instance_klass()) {
 JVMCIENV->put_object_at(methods, i, method);
 }
 return JVMCIENV->get_jobjectArray(methods);
 C2V_END
-C2V_VMENTRY(jobjectArray, getDeclaredMethods, (JNIEnv* env, jobject, jobject holder))
+C2V_VMENTRY_NULL(jobjectArray, getDeclaredMethods, (JNIEnv* env, jobject, jobject holder))
 if (holder == NULL) {
 JVMCI_THROW_0(NullPointerException);
 }
 Klass* klass = JVMCIENV->asKlass(holder);
 if (!klass->is_instance_klass()) {
 JVMCIENV->put_object_at(methods, i, method);
 }
 return JVMCIENV->get_jobjectArray(methods);
 C2V_END
-C2V_VMENTRY(jobject, readFieldValue, (JNIEnv* env, jobject, jobject object, jobject field, jboolean is_volatile))
+C2V_VMENTRY_NULL(jobject, readFieldValue, (JNIEnv* env, jobject, jobject object, jobject field, jboolean is_volatile))
 if (object == NULL || field == NULL) {
 JVMCI_THROW_0(NullPointerException);
 }
 JVMCIObject field_object = JVMCIENV->wrap(field);
 JVMCIObject java_type = JVMCIENV->get_HotSpotResolvedJavaFieldImpl_type(field_object);
 }
 JVMCIObject result = JVMCIENV->call_PrimitiveConstant_forTypeChar(type2char(constant_type), value, JVMCI_CHECK_NULL);
 return JVMCIENV->get_jobject(result);
 C2V_END
-C2V_VMENTRY(jboolean, isInstance, (JNIEnv* env, jobject, jobject holder, jobject object))
+C2V_VMENTRY_0(jboolean, isInstance, (JNIEnv* env, jobject, jobject holder, jobject object))
 if (object == NULL || holder == NULL) {
 JVMCI_THROW_0(NullPointerException);
 }
 Handle obj = JVMCIENV->asConstant(JVMCIENV->wrap(object), JVMCI_CHECK_0);
 Klass* klass = JVMCIENV->asKlass(JVMCIENV->wrap(holder));
 return obj->is_a(klass);
 C2V_END
-C2V_VMENTRY(jboolean, isAssignableFrom, (JNIEnv* env, jobject, jobject holder, jobject otherHolder))
+C2V_VMENTRY_0(jboolean, isAssignableFrom, (JNIEnv* env, jobject, jobject holder, jobject otherHolder))
 if (holder == NULL || otherHolder == NULL) {
 JVMCI_THROW_0(NullPointerException);
 }
 Klass* klass = JVMCIENV->asKlass(JVMCIENV->wrap(holder));
 Klass* otherKlass = JVMCIENV->asKlass(JVMCIENV->wrap(otherHolder));
 return otherKlass->is_subtype_of(klass);
 C2V_END
-C2V_VMENTRY(jboolean, isTrustedForIntrinsics, (JNIEnv* env, jobject, jobject holder))
+C2V_VMENTRY_0(jboolean, isTrustedForIntrinsics, (JNIEnv* env, jobject, jobject holder))
 if (holder == NULL) {
 JVMCI_THROW_0(NullPointerException);
 }
 InstanceKlass* ik = InstanceKlass::cast(JVMCIENV->asKlass(JVMCIENV->wrap(holder)));
 if (ik->class_loader_data()->is_builtin_class_loader_data()) {
 return true;
 }
 return false;
 C2V_END
-C2V_VMENTRY(jobject, asJavaType, (JNIEnv* env, jobject, jobject object))
+C2V_VMENTRY_NULL(jobject, asJavaType, (JNIEnv* env, jobject, jobject object))
 if (object == NULL) {
 JVMCI_THROW_0(NullPointerException);
 }
 Handle obj = JVMCIENV->asConstant(JVMCIENV->wrap(object), JVMCI_CHECK_NULL);
 if (java_lang_Class::is_instance(obj())) {
 }
 return NULL;
 C2V_END
-C2V_VMENTRY(jobject, asString, (JNIEnv* env, jobject, jobject object))
+C2V_VMENTRY_NULL(jobject, asString, (JNIEnv* env, jobject, jobject object))
 if (object == NULL) {
 JVMCI_THROW_0(NullPointerException);
 }
 Handle obj = JVMCIENV->asConstant(JVMCIENV->wrap(object), JVMCI_CHECK_NULL);
 const char* str = java_lang_String::as_utf8_string(obj());
 JVMCIObject result = JVMCIENV->create_string(str, JVMCI_CHECK_NULL);
 return JVMCIENV->get_jobject(result);
 C2V_END
-C2V_VMENTRY(jboolean, equals, (JNIEnv* env, jobject, jobject x, jlong xHandle, jobject y, jlong yHandle))
+C2V_VMENTRY_0(jboolean, equals, (JNIEnv* env, jobject, jobject x, jlong xHandle, jobject y, jlong yHandle))
 if (x == NULL || y == NULL) {
 JVMCI_THROW_0(NullPointerException);
 }
 return JVMCIENV->resolve_handle(xHandle) == JVMCIENV->resolve_handle(yHandle);
 C2V_END
-C2V_VMENTRY(jobject, getJavaMirror, (JNIEnv* env, jobject, jobject object))
+C2V_VMENTRY_NULL(jobject, getJavaMirror, (JNIEnv* env, jobject, jobject object))
 if (object == NULL) {
 JVMCI_THROW_0(NullPointerException);
 }
 JVMCIObject base_object = JVMCIENV->wrap(object);
 Handle mirror;
 JVMCIObject result = JVMCIENV->get_object_constant(mirror());
 return JVMCIENV->get_jobject(result);
 C2V_END
-C2V_VMENTRY(jint, getArrayLength, (JNIEnv* env, jobject, jobject x))
+C2V_VMENTRY_0(jint, getArrayLength, (JNIEnv* env, jobject, jobject x))
 if (x == NULL) {
 JVMCI_THROW_0(NullPointerException);
 }
 Handle xobj = JVMCIENV->asConstant(JVMCIENV->wrap(x), JVMCI_CHECK_0);
 if (xobj->klass()->is_array_klass()) {
 }
 return -1;
 C2V_END
-C2V_VMENTRY(jobject, readArrayElement, (JNIEnv* env, jobject, jobject x, int index))
+C2V_VMENTRY_NULL(jobject, readArrayElement, (JNIEnv* env, jobject, jobject x, int index))
 if (x == NULL) {
 JVMCI_THROW_0(NullPointerException);
 }
 Handle xobj = JVMCIENV->asConstant(JVMCIENV->wrap(x), JVMCI_CHECK_NULL);
 if (xobj->klass()->is_array_klass()) {
 }
 return NULL;;
 C2V_END
-C2V_VMENTRY(jint, arrayBaseOffset, (JNIEnv* env, jobject, jobject kind))
+C2V_VMENTRY_0(jint, arrayBaseOffset, (JNIEnv* env, jobject, jobject kind))
 if (kind == NULL) {
 JVMCI_THROW_0(NullPointerException);
 }
 BasicType type = JVMCIENV->kindToBasicType(JVMCIENV->wrap(kind), JVMCI_CHECK_0);
 return arrayOopDesc::header_size(type) * HeapWordSize;
 C2V_END
-C2V_VMENTRY(jint, arrayIndexScale, (JNIEnv* env, jobject, jobject kind))
+C2V_VMENTRY_0(jint, arrayIndexScale, (JNIEnv* env, jobject, jobject kind))
 if (kind == NULL) {
 JVMCI_THROW_0(NullPointerException);
 }
 BasicType type = JVMCIENV->kindToBasicType(JVMCIENV->wrap(kind), JVMCI_CHECK_0);
 return type2aelembytes(type);
 C2V_END
-C2V_VMENTRY(jbyte, getByte, (JNIEnv* env, jobject, jobject x, long displacement))
+C2V_VMENTRY_0(jbyte, getByte, (JNIEnv* env, jobject, jobject x, long displacement))
 if (x == NULL) {
 JVMCI_THROW_0(NullPointerException);
 }
 Handle xobj = JVMCIENV->asConstant(JVMCIENV->wrap(x), JVMCI_CHECK_0);
 return xobj->byte_field(displacement);
 }
-C2V_VMENTRY(jshort, getShort, (JNIEnv* env, jobject, jobject x, long displacement))
+C2V_VMENTRY_0(jshort, getShort, (JNIEnv* env, jobject, jobject x, long displacement))
 if (x == NULL) {
 JVMCI_THROW_0(NullPointerException);
 }
 Handle xobj = JVMCIENV->asConstant(JVMCIENV->wrap(x), JVMCI_CHECK_0);
 return xobj->short_field(displacement);
 }
-C2V_VMENTRY(jint, getInt, (JNIEnv* env, jobject, jobject x, long displacement))
+C2V_VMENTRY_0(jint, getInt, (JNIEnv* env, jobject, jobject x, long displacement))
 if (x == NULL) {
 JVMCI_THROW_0(NullPointerException);
 }
 Handle xobj = JVMCIENV->asConstant(JVMCIENV->wrap(x), JVMCI_CHECK_0);
 return xobj->int_field(displacement);
 }
-C2V_VMENTRY(jlong, getLong, (JNIEnv* env, jobject, jobject x, long displacement))
+C2V_VMENTRY_0(jlong, getLong, (JNIEnv* env, jobject, jobject x, long displacement))
 if (x == NULL) {
 JVMCI_THROW_0(NullPointerException);
 }
 Handle xobj = JVMCIENV->asConstant(JVMCIENV->wrap(x), JVMCI_CHECK_0);
 return xobj->long_field(displacement);
 }
-C2V_VMENTRY(jobject, getObject, (JNIEnv* env, jobject, jobject x, long displacement))
+C2V_VMENTRY_NULL(jobject, getObject, (JNIEnv* env, jobject, jobject x, long displacement))
 if (x == NULL) {
 JVMCI_THROW_0(NullPointerException);
 }
 Handle xobj = JVMCIENV->asConstant(JVMCIENV->wrap(x), JVMCI_CHECK_0);
 oop res = xobj->obj_field(displacement);
 assert(JVMCI::is_global_handle(handle), "Invalid delete of global JNI handle");
 *((oop*)handle) = NULL; // Mark the handle as deleted, allocate will reuse it
 }
 }
-C2V_VMENTRY(jlongArray, registerNativeMethods, (JNIEnv* env, jobject, jclass mirror))
+static void requireJVMCINativeLibrary(JVMCI_TRAPS) {
 if (!UseJVMCINativeLibrary) {
-JVMCI_THROW_MSG_0(UnsatisfiedLinkError, "JVMCI shared library is not enabled (requires -XX:+UseJVMCINativeLibrary)");
+JVMCI_THROW_MSG(UnsupportedOperationException, "JVMCI shared library is not enabled (requires -XX:+UseJVMCINativeLibrary)");
 }
-if (!JVMCIENV->is_hotspot()) {
+}
-JVMCI_THROW_MSG_0(UnsatisfiedLinkError, "Cannot call registerNativeMethods from JVMCI shared library");
-}
+static JavaVM* requireNativeLibraryJavaVM(const char* caller, JVMCI_TRAPS) {
+JavaVM* javaVM = JVMCIEnv::get_shared_library_javavm();
+if (javaVM == NULL) {
+JVMCI_THROW_MSG_NULL(IllegalStateException, err_msg("Require JVMCI shared library to be initialized in %s", caller));
+}
+return javaVM;
+}
+C2V_VMENTRY_NULL(jlongArray, registerNativeMethods, (JNIEnv* env, jobject, jclass mirror))
+requireJVMCINativeLibrary(JVMCI_CHECK_NULL);
+requireInHotSpot("registerNativeMethods", JVMCI_CHECK_NULL);
 void* shared_library = JVMCIEnv::get_shared_library_handle();
 if (shared_library == NULL) {
 // Ensure the JVMCI shared library runtime is initialized.
-JVMCIEnv __peer_jvmci_env__(false, __FILE__, __LINE__);
+JVMCIEnv __peer_jvmci_env__(thread, false, __FILE__, __LINE__);
 JVMCIEnv* peerEnv = &__peer_jvmci_env__;
 HandleMark hm;
 JVMCIRuntime* runtime = JVMCI::compiler_runtime();
 JVMCIObject receiver = runtime->get_HotSpotJVMCIRuntime(peerEnv);
 if (peerEnv->has_pending_exception()) {
 peerEnv->describe_pending_exception(true);
+}
+shared_library = JVMCIEnv::get_shared_library_handle();
+if (shared_library == NULL) {
 JVMCI_THROW_MSG_0(InternalError, "Error initializing JVMCI runtime");
 }
-shared_library = JVMCIEnv::get_shared_library_handle();
-}
-if (shared_library == NULL) {
-JVMCI_THROW_MSG_0(UnsatisfiedLinkError, "JVMCI shared library is unavailable");
 }
 if (mirror == NULL) {
 JVMCI_THROW_0(NullPointerException);
 }
 char* long_name = NativeLookup::long_jni_name(method);
 os::print_jni_name_prefix_on(&st, args_size);
 st.print_raw(pure_name);
 st.print_raw(long_name);
 os::print_jni_name_suffix_on(&st, args_size);
-jni_name = st.as_string();
+char* jni_long_name = st.as_string();
-entry = (address) os::dll_lookup(shared_library, jni_name);
+entry = (address) os::dll_lookup(shared_library, jni_long_name);
+if (entry == NULL) {
+JVMCI_THROW_MSG_0(UnsatisfiedLinkError, err_msg("%s [neither %s nor %s exist in %s]",
+method->name_and_sig_as_C_string(),
+jni_name, jni_long_name, JVMCIEnv::get_shared_library_path()));
+}
 }
-if (entry == NULL) {
-JVMCI_THROW_MSG_0(UnsatisfiedLinkError, method->name_and_sig_as_C_string());
-}
 if (method->has_native_function() && entry != method->native_function()) {
-JVMCI_THROW_MSG_0(UnsatisfiedLinkError, err_msg("Cannot overwrite existing native implementation for %s",
+JVMCI_THROW_MSG_0(UnsatisfiedLinkError, err_msg("%s [cannot re-link from " PTR_FORMAT " to " PTR_FORMAT "]",
-method->name_and_sig_as_C_string()));
+method->name_and_sig_as_C_string(), p2i(method->native_function()), p2i(entry)));
 }
 method->set_native_function(entry, Method::native_bind_event_is_interesting);
 if (PrintJNIResolving) {
 tty->print_cr("[Dynamic-linking native method %s.%s ... JNI]",
 method->method_holder()->external_name(),
 JVMCIENV->put_long_at(result, 2, (jlong) (address) javaVM->functions->reserved1);
 JVMCIENV->put_long_at(result, 3, (jlong) (address) javaVM->functions->reserved2);
 return (jlongArray) JVMCIENV->get_jobject(result);
 }
-C2V_VMENTRY(jlong, translate, (JNIEnv* env, jobject, jobject obj_handle))
+C2V_VMENTRY_PREFIX(jboolean, isCurrentThreadAttached, (JNIEnv* env, jobject c2vm))
+if (base_thread == NULL) {
+// Called from unattached JVMCI shared library thread
+return false;
+}
+JVMCITraceMark jtm("isCurrentThreadAttached");
+assert(base_thread->is_Java_thread(), "just checking");
+JavaThread* thread = (JavaThread*) base_thread;
+if (thread->jni_environment() == env) {
+C2V_BLOCK(jboolean, isCurrentThreadAttached, (JNIEnv* env, jobject))
+requireJVMCINativeLibrary(JVMCI_CHECK_0);
+JavaVM* javaVM = requireNativeLibraryJavaVM("isCurrentThreadAttached", JVMCI_CHECK_0);
+JNIEnv* peerEnv;
+return javaVM->GetEnv((void**)&peerEnv, JNI_VERSION_1_2) == JNI_OK;
+}
+return true;
+C2V_END
+C2V_VMENTRY_PREFIX(jboolean, attachCurrentThread, (JNIEnv* env, jobject c2vm, jboolean as_daemon))
+if (base_thread == NULL) {
+// Called from unattached JVMCI shared library thread
+extern struct JavaVM_ main_vm;
+JNIEnv* hotspotEnv;
+jint res = as_daemon ? main_vm.AttachCurrentThreadAsDaemon((void**)&hotspotEnv, NULL) :
+main_vm.AttachCurrentThread((void**)&hotspotEnv, NULL);
+if (res != JNI_OK) {
+JNI_THROW_("attachCurrentThread", InternalError, err_msg("Trying to attach thread returned %d", res), false);
+}
+return true;
+}
+JVMCITraceMark jtm("attachCurrentThread");
+assert(base_thread->is_Java_thread(), "just checking");\
+JavaThread* thread = (JavaThread*) base_thread;
+if (thread->jni_environment() == env) {
+// Called from HotSpot
+C2V_BLOCK(jboolean, attachCurrentThread, (JNIEnv* env, jobject, jboolean))
+requireJVMCINativeLibrary(JVMCI_CHECK_0);
+JavaVM* javaVM = requireNativeLibraryJavaVM("attachCurrentThread", JVMCI_CHECK_0);
+JavaVMAttachArgs attach_args;
+attach_args.version = JNI_VERSION_1_2;
+attach_args.name = thread->name();
+attach_args.group = NULL;
+JNIEnv* peerEnv;
+if (javaVM->GetEnv((void**)&peerEnv, JNI_VERSION_1_2) == JNI_OK) {
+return false;
+}
+jint res = as_daemon ? javaVM->AttachCurrentThreadAsDaemon((void**)&peerEnv, &attach_args) :
+javaVM->AttachCurrentThread((void**)&peerEnv, &attach_args);
+if (res == JNI_OK) {
+guarantee(peerEnv != NULL, "must be");
+return true;
+}
+JVMCI_THROW_MSG_0(InternalError, err_msg("Error %d while attaching %s", res, attach_args.name));
+}
+// Called from JVMCI shared library
+return false;
+C2V_END
+C2V_VMENTRY_PREFIX(void, detachCurrentThread, (JNIEnv* env, jobject c2vm))
+if (base_thread == NULL) {
+// Called from unattached JVMCI shared library thread
+JNI_THROW("detachCurrentThread", IllegalStateException, err_msg("Cannot detach non-attached thread"));
+}
+JVMCITraceMark jtm("detachCurrentThread");
+assert(base_thread->is_Java_thread(), "just checking");\
+JavaThread* thread = (JavaThread*) base_thread;
+if (thread->jni_environment() == env) {
+// Called from HotSpot
+C2V_BLOCK(void, detachCurrentThread, (JNIEnv* env, jobject))
+requireJVMCINativeLibrary(JVMCI_CHECK);
+requireInHotSpot("detachCurrentThread", JVMCI_CHECK);
+JavaVM* javaVM = requireNativeLibraryJavaVM("detachCurrentThread", JVMCI_CHECK);
+JNIEnv* peerEnv;
+if (javaVM->GetEnv((void**)&peerEnv, JNI_VERSION_1_2) != JNI_OK) {
+JVMCI_THROW_MSG(IllegalStateException, err_msg("Cannot detach non-attached thread: %s", thread->name()));
+}
+jint res = javaVM->DetachCurrentThread();
+if (res != JNI_OK) {
+JVMCI_THROW_MSG(InternalError, err_msg("Error %d while attaching %s", res, thread->name()));
+}
+} else {
+// Called from attached JVMCI shared library thread
+extern struct JavaVM_ main_vm;
+jint res = main_vm.DetachCurrentThread();
+if (res != JNI_OK) {
+JNI_THROW("detachCurrentThread", InternalError, err_msg("Cannot detach non-attached thread"));
+}
+}
+C2V_END
+C2V_VMENTRY_0(jlong, translate, (JNIEnv* env, jobject, jobject obj_handle))
+requireJVMCINativeLibrary(JVMCI_CHECK_0);
 if (obj_handle == NULL) {
 return 0L;
 }
-JVMCIEnv __peer_jvmci_env__(!JVMCIENV->is_hotspot(), __FILE__, __LINE__);
+JVMCIEnv __peer_jvmci_env__(thread, !JVMCIENV->is_hotspot(), __FILE__, __LINE__);
 JVMCIEnv* peerEnv = &__peer_jvmci_env__;
 JVMCIEnv* thisEnv = JVMCIENV;
 JVMCIObject obj = thisEnv->wrap(obj_handle);
 JVMCIObject result;
 err_msg("Cannot translate object of type: %s", thisEnv->klass_name(obj)));
 }
 return (jlong) peerEnv->make_global(result).as_jobject();
 }
-C2V_VMENTRY(jobject, unhand, (JNIEnv* env, jobject, jlong obj_handle))
+C2V_VMENTRY_NULL(jobject, unhand, (JNIEnv* env, jobject, jlong obj_handle))
+requireJVMCINativeLibrary(JVMCI_CHECK_NULL);
 if (obj_handle == 0L) {
 return NULL;
 }
 jobject global_handle = (jobject) obj_handle;
 JVMCIObject global_handle_obj = JVMCIENV->wrap((jobject) obj_handle);
 JVMCIObject code = JVMCIENV->wrap(code_handle);
 // Execute this operation for the side effect of updating the InstalledCode state
 JVMCIENV->asNmethod(code);
 }
-C2V_VMENTRY(jbyteArray, getCode, (JNIEnv* env, jobject, jobject code_handle))
+C2V_VMENTRY_NULL(jbyteArray, getCode, (JNIEnv* env, jobject, jobject code_handle))
 JVMCIObject code = JVMCIENV->wrap(code_handle);
 CodeBlob* cb = JVMCIENV->asCodeBlob(code);
 if (cb == NULL) {
 return NULL;
 }
 JVMCIPrimitiveArray result = JVMCIENV->new_byteArray(code_size, JVMCI_CHECK_NULL);
 JVMCIENV->copy_bytes_from((jbyte*) cb->code_begin(), result, 0, code_size);
 return JVMCIENV->get_jbyteArray(result);
 }
-C2V_VMENTRY(jobject, asReflectionExecutable, (JNIEnv* env, jobject, jobject jvmci_method))
+C2V_VMENTRY_NULL(jobject, asReflectionExecutable, (JNIEnv* env, jobject, jobject jvmci_method))
-if (env != JavaThread::current()->jni_environment()) {
+requireInHotSpot("asReflectionExecutable", JVMCI_CHECK_NULL);
-JVMCI_THROW_MSG_NULL(InternalError, "Only supported when running in HotSpot");
-}
 methodHandle m = JVMCIENV->asMethod(jvmci_method);
 oop executable;
 if (m->is_initializer()) {
 if (m->is_static_initializer()) {
 JVMCI_THROW_MSG_NULL(IllegalArgumentException,
 executable = Reflection::new_method(m, false, CHECK_NULL);
 }
 return JNIHandles::make_local(THREAD, executable);
 }
-C2V_VMENTRY(jobject, asReflectionField, (JNIEnv* env, jobject, jobject jvmci_type, jint index))
+C2V_VMENTRY_NULL(jobject, asReflectionField, (JNIEnv* env, jobject, jobject jvmci_type, jint index))
-if (env != JavaThread::current()->jni_environment()) {
+requireInHotSpot("asReflectionField", JVMCI_CHECK_NULL);
-JVMCI_THROW_MSG_NULL(InternalError, "Only supported when running in HotSpot");
-}
 Klass* klass = JVMCIENV->asKlass(jvmci_type);
 if (!klass->is_instance_klass()) {
 JVMCI_THROW_MSG_NULL(IllegalArgumentException,
 err_msg("Expected non-primitive type, got %s", klass->external_name()));
 }
 fieldDescriptor fd(iklass, index);
 oop reflected = Reflection::new_field(&fd, CHECK_NULL);
 return JNIHandles::make_local(env, reflected);
 }
-C2V_VMENTRY(jobjectArray, getFailedSpeculations, (JNIEnv* env, jobject, jlong failed_speculations_address, jobjectArray current))
+C2V_VMENTRY_NULL(jobjectArray, getFailedSpeculations, (JNIEnv* env, jobject, jlong failed_speculations_address, jobjectArray current))
 FailedSpeculation* head = *((FailedSpeculation**)(address) failed_speculations_address);
 int result_length = 0;
 for (FailedSpeculation* fs = head; fs != NULL; fs = fs->next()) {
 result_length++;
 }
 JVMCIENV->put_object_at(result, result_index++, entry);
 }
 return JVMCIENV->get_jobjectArray(result);
 }
-C2V_VMENTRY(jlong, getFailedSpeculationsAddress, (JNIEnv* env, jobject, jobject jvmci_method))
+C2V_VMENTRY_0(jlong, getFailedSpeculationsAddress, (JNIEnv* env, jobject, jobject jvmci_method))
 methodHandle method = JVMCIENV->asMethod(jvmci_method);
 MethodData* method_data = method->method_data();
 if (method_data == NULL) {
 ClassLoaderData* loader_data = method->method_holder()->class_loader_data();
 method_data = MethodData::allocate(loader_data, method, CHECK_0);
 C2V_VMENTRY(void, releaseFailedSpeculations, (JNIEnv* env, jobject, jlong failed_speculations_address))
 FailedSpeculation::free_failed_speculations((FailedSpeculation**)(address) failed_speculations_address);
 }
-C2V_VMENTRY(bool, addFailedSpeculation, (JNIEnv* env, jobject, jlong failed_speculations_address, jbyteArray speculation_obj))
+C2V_VMENTRY_0(bool, addFailedSpeculation, (JNIEnv* env, jobject, jlong failed_speculations_address, jbyteArray speculation_obj))
 JVMCIPrimitiveArray speculation_handle = JVMCIENV->wrap(speculation_obj);
 int speculation_len = JVMCIENV->get_length(speculation_handle);
 char* speculation = NEW_RESOURCE_ARRAY(char, speculation_len);
 JVMCIENV->copy_bytes_to(speculation_handle, (jbyte*) speculation, 0, speculation_len);
 return FailedSpeculation::add_failed_speculation(NULL, (FailedSpeculation**)(address) failed_speculations_address, (address) speculation, speculation_len);
 {CC "hasCompiledCodeForOSR",                        CC "(" HS_RESOLVED_METHOD "II)Z",                                                     FN_PTR(hasCompiledCodeForOSR)},
 {CC "getSymbol",                                    CC "(J)" STRING,                                                                      FN_PTR(getSymbol)},
 {CC "iterateFrames",                                CC "([" RESOLVED_METHOD "[" RESOLVED_METHOD "I" INSPECTED_FRAME_VISITOR ")" OBJECT,   FN_PTR(iterateFrames)},
 {CC "materializeVirtualObjects",                    CC "(" HS_STACK_FRAME_REF "Z)V",                                                      FN_PTR(materializeVirtualObjects)},
 {CC "shouldDebugNonSafepoints",                     CC "()Z",                                                                             FN_PTR(shouldDebugNonSafepoints)},
-{CC "writeDebugOutput",                             CC "([BII)V",                                                                         FN_PTR(writeDebugOutput)},
+{CC "writeDebugOutput",                             CC "([BIIZZ)I",                                                                       FN_PTR(writeDebugOutput)},
 {CC "flushDebugOutput",                             CC "()V",                                                                             FN_PTR(flushDebugOutput)},
 {CC "methodDataProfileDataSize",                    CC "(JI)I",                                                                           FN_PTR(methodDataProfileDataSize)},
 {CC "getFingerprint",                               CC "(J)J",                                                                            FN_PTR(getFingerprint)},
 {CC "getHostClass",                                 CC "(" HS_RESOLVED_KLASS ")" HS_RESOLVED_KLASS,                                       FN_PTR(getHostClass)},
 {CC "interpreterFrameSize",                         CC "(" BYTECODE_FRAME ")I",                                                           FN_PTR(interpreterFrameSize)},
 {CC "getInt",                                       CC "(" OBJECTCONSTANT "J)I",                                                          FN_PTR(getInt)},
 {CC "getLong",                                      CC "(" OBJECTCONSTANT "J)J",                                                          FN_PTR(getLong)},
 {CC "getObject",                                    CC "(" OBJECTCONSTANT "J)" OBJECTCONSTANT,                                            FN_PTR(getObject)},
 {CC "deleteGlobalHandle",                           CC "(J)V",                                                                            FN_PTR(deleteGlobalHandle)},
 {CC "registerNativeMethods",                        CC "(" CLASS ")[J",                                                                   FN_PTR(registerNativeMethods)},
+{CC "isCurrentThreadAttached",                      CC "()Z",                                                                             FN_PTR(isCurrentThreadAttached)},
+{CC "attachCurrentThread",                          CC "(Z)Z",                                                                            FN_PTR(attachCurrentThread)},
+{CC "detachCurrentThread",                          CC "()V",                                                                             FN_PTR(detachCurrentThread)},
 {CC "translate",                                    CC "(" OBJECT ")J",                                                                   FN_PTR(translate)},
 {CC "unhand",                                       CC "(J)" OBJECT,                                                                      FN_PTR(unhand)},
 {CC "updateHotSpotNmethod",                         CC "(" HS_NMETHOD ")V",                                                               FN_PTR(updateHotSpotNmethod)},
 {CC "getCode",                                      CC "(" HS_INSTALLED_CODE ")[B",                                                       FN_PTR(getCode)},
 {CC "asReflectionExecutable",                       CC "(" HS_RESOLVED_METHOD ")" REFLECTION_EXECUTABLE,                                  FN_PTR(asReflectionExecutable)},

changeset 54732	2d012a75d35c
parent 54708	b7e6fc77c2f3
child 54786	ebf733a324d4