--- old/src/hotspot/share/jvmci/jvmciCompilerToVM.cpp 2019-05-04 16:22:13.665494183 -0700 +++ new/src/hotspot/share/jvmci/jvmciCompilerToVM.cpp 2019-05-04 16:22:12.408492309 -0700 @@ -62,12 +62,17 @@ return *this; } -void JNIHandleMark::push_jni_handle_block() { - JavaThread* thread = JavaThread::current(); +static void requireInHotSpot(const char* caller, JVMCI_TRAPS) { + 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); @@ -75,8 +80,7 @@ } } -void JNIHandleMark::pop_jni_handle_block() { - JavaThread* thread = JavaThread::current(); +void JNIHandleMark::pop_jni_handle_block(JavaThread* thread) { if (thread != NULL) { // Release our JNI handle block JNIHandleBlock* compile_handles = thread->active_handles(); @@ -111,25 +115,88 @@ 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); \ + C2V_BLOCK(result_type, name, signature) + +#define C2V_VMENTRY_(result_type, name, signature, result) \ + 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); \ - TRACE_CALL(result_type, jvmci_ ## name signature) \ - JVMCI_VM_ENTRY_MARK; \ - ResourceMark rm; \ - JNI_JVMCIENV(env); + 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); @@ -170,10 +237,8 @@ #undef RETURN_BOXED_DOUBLE C2V_END -C2V_VMENTRY(jobject, getObjectAtAddress, (JNIEnv* env, jobject c2vm, jlong oop_address)) - if (env != JavaThread::current()->jni_environment()) { - JVMCI_THROW_MSG_NULL(InternalError, "Only supported when running in HotSpot"); - } +C2V_VMENTRY_NULL(jobject, getObjectAtAddress, (JNIEnv* env, jobject c2vm, jlong oop_address)) + requireInHotSpot("getObjectAtAddress", JVMCI_CHECK_NULL); if (oop_address == 0) { JVMCI_THROW_MSG_NULL(InternalError, "Handle must be non-zero"); } @@ -184,7 +249,7 @@ 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(); @@ -262,12 +327,12 @@ 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; @@ -275,11 +340,8 @@ return (jlong) (address) method->exception_table_start(); C2V_END -C2V_VMENTRY(jobject, asResolvedJavaMethod, (JNIEnv* env, jobject, jobject executable_handle)) - if (env != JavaThread::current()->jni_environment()) { - JVMCI_THROW_MSG_NULL(InternalError, "Only supported when running in HotSpot"); - } - +C2V_VMENTRY_NULL(jobject, asResolvedJavaMethod, (JNIEnv* env, jobject, jobject executable_handle)) + requireInHotSpot("asResolvedJavaMethod", JVMCI_CHECK_NULL); oop executable = JNIHandles::resolve(executable_handle); oop mirror = NULL; int slot = 0; @@ -298,7 +360,7 @@ 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()) { @@ -321,7 +383,7 @@ 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()) { @@ -341,7 +403,7 @@ 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; @@ -384,7 +446,7 @@ 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()) { @@ -400,7 +462,7 @@ 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(), @@ -417,12 +479,12 @@ 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"); @@ -430,17 +492,17 @@ 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); @@ -465,6 +527,9 @@ 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) == ';') { @@ -483,7 +548,6 @@ 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, @@ -502,10 +566,8 @@ return JVMCIENV->get_jobject(result); C2V_END -C2V_VMENTRY(jobject, lookupClass, (JNIEnv* env, jobject, jclass mirror)) - if (env != JavaThread::current()->jni_environment()) { - JVMCI_THROW_MSG_NULL(InternalError, "Only supported when running in HotSpot"); - } +C2V_VMENTRY_NULL(jobject, lookupClass, (JNIEnv* env, jobject, jclass mirror)) + requireInHotSpot("lookupClass", JVMCI_CHECK_NULL); if (mirror == NULL) { return NULL; } @@ -518,55 +580,56 @@ 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); - if (!linked) { - return NULL; + InstanceKlass::cast(resolved_klass())->link_class(CHECK_NULL); + if (!InstanceKlass::cast(resolved_klass())->is_linked()) { + // 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; @@ -594,13 +657,13 @@ 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); @@ -609,12 +672,12 @@ 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; @@ -632,7 +695,7 @@ 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()) { @@ -650,7 +713,7 @@ 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); @@ -697,13 +760,13 @@ 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; @@ -713,7 +776,7 @@ 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)); @@ -730,10 +793,10 @@ 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); @@ -791,7 +854,7 @@ 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"); @@ -872,7 +935,7 @@ 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) { @@ -909,7 +972,7 @@ 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); @@ -917,12 +980,10 @@ return JVMCIENV->get_jobject(element); C2V_END -C2V_VMENTRY(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 - // and the return value would have to be wrapped as a JavaConstant. - JVMCI_THROW_MSG_NULL(InternalError, "Wrapping of arguments is currently unsupported"); - } +C2V_VMENTRY_NULL(jobject, executeHotSpotNmethod, (JNIEnv* env, jobject, jobject args, jobject hs_nmethod)) + // 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. + requireInHotSpot("executeHotSpotNmethod", JVMCI_CHECK_NULL); HandleMark hm; @@ -968,7 +1029,7 @@ } 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; @@ -995,7 +1056,7 @@ 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; @@ -1003,7 +1064,7 @@ 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 @@ -1037,18 +1098,23 @@ 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); @@ -1061,17 +1127,17 @@ 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 @@ -1102,16 +1168,14 @@ 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()) { - JVMCI_THROW_MSG_NULL(InternalError, "getNextStackFrame is only supported for HotSpot stack walking"); - } + requireInHotSpot("iterateFrames", JVMCI_CHECK_NULL); HotSpotJVMCI::HotSpotStackFrameReference::klass()->initialize(CHECK_NULL); Handle frame_reference = HotSpotJVMCI::HotSpotStackFrameReference::klass()->allocate_instance_handle(CHECK_NULL); @@ -1283,7 +1347,7 @@ } 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)) { @@ -1324,7 +1388,7 @@ 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); @@ -1333,7 +1397,7 @@ 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; @@ -1348,9 +1412,7 @@ JVMCI_THROW_MSG(NullPointerException, "stack frame is null"); } - if (env != JavaThread::current()->jni_environment()) { - JVMCI_THROW_MSG(InternalError, "getNextStackFrame is only supported for HotSpot stack walking"); - } + requireInHotSpot("materializeVirtualObjects", JVMCI_CHECK); JVMCIENV->HotSpotStackFrameReference_initialize(JVMCI_CHECK); @@ -1465,20 +1527,76 @@ 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) { @@ -1488,13 +1606,17 @@ 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)) { @@ -1512,7 +1634,7 @@ 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()) { @@ -1525,7 +1647,7 @@ #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); @@ -1533,7 +1655,7 @@ 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); } @@ -1560,7 +1682,7 @@ 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); } @@ -1600,7 +1722,7 @@ } 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); } @@ -1648,12 +1770,12 @@ } 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; @@ -1664,7 +1786,7 @@ 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); } @@ -1678,7 +1800,7 @@ 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); } @@ -1722,7 +1844,7 @@ 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); } @@ -1751,7 +1873,7 @@ 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); } @@ -1780,7 +1902,7 @@ 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); } @@ -1848,7 +1970,7 @@ 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); } @@ -1857,7 +1979,7 @@ 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); } @@ -1866,7 +1988,7 @@ 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); } @@ -1877,7 +1999,7 @@ 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); } @@ -1897,7 +2019,7 @@ 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); } @@ -1908,14 +2030,14 @@ 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); } @@ -1934,7 +2056,7 @@ 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); } @@ -1946,7 +2068,7 @@ 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); } @@ -1986,7 +2108,7 @@ 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); } @@ -1994,7 +2116,7 @@ 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); } @@ -2002,7 +2124,7 @@ 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); } @@ -2010,7 +2132,7 @@ 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); } @@ -2018,7 +2140,7 @@ 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); } @@ -2026,7 +2148,7 @@ 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); } @@ -2034,7 +2156,7 @@ 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); } @@ -2052,30 +2174,38 @@ } } -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); - 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 (shared_library == NULL) { + JVMCI_THROW_MSG_0(InternalError, "Error initializing JVMCI runtime"); + } } if (mirror == NULL) { @@ -2113,15 +2243,18 @@ st.print_raw(pure_name); st.print_raw(long_name); os::print_jni_name_suffix_on(&st, args_size); - jni_name = st.as_string(); - entry = (address) os::dll_lookup(shared_library, jni_name); - } - if (entry == NULL) { - JVMCI_THROW_MSG_0(UnsatisfiedLinkError, method->name_and_sig_as_C_string()); + char* jni_long_name = st.as_string(); + 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 (method->has_native_function() && entry != method->native_function()) { - JVMCI_THROW_MSG_0(UnsatisfiedLinkError, err_msg("Cannot overwrite existing native implementation for %s", - method->name_and_sig_as_C_string())); + JVMCI_THROW_MSG_0(UnsatisfiedLinkError, err_msg("%s [cannot re-link from " PTR_FORMAT " to " PTR_FORMAT "]", + 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) { @@ -2141,11 +2274,102 @@ 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; @@ -2216,7 +2440,8 @@ 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; } @@ -2234,7 +2459,7 @@ 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) { @@ -2246,10 +2471,8 @@ return JVMCIENV->get_jbyteArray(result); } -C2V_VMENTRY(jobject, asReflectionExecutable, (JNIEnv* env, jobject, jobject jvmci_method)) - if (env != JavaThread::current()->jni_environment()) { - JVMCI_THROW_MSG_NULL(InternalError, "Only supported when running in HotSpot"); - } +C2V_VMENTRY_NULL(jobject, asReflectionExecutable, (JNIEnv* env, jobject, jobject jvmci_method)) + requireInHotSpot("asReflectionExecutable", JVMCI_CHECK_NULL); methodHandle m = JVMCIENV->asMethod(jvmci_method); oop executable; if (m->is_initializer()) { @@ -2264,10 +2487,8 @@ return JNIHandles::make_local(THREAD, executable); } -C2V_VMENTRY(jobject, asReflectionField, (JNIEnv* env, jobject, jobject jvmci_type, jint index)) - if (env != JavaThread::current()->jni_environment()) { - JVMCI_THROW_MSG_NULL(InternalError, "Only supported when running in HotSpot"); - } +C2V_VMENTRY_NULL(jobject, asReflectionField, (JNIEnv* env, jobject, jobject jvmci_type, jint index)) + requireInHotSpot("asReflectionField", JVMCI_CHECK_NULL); Klass* klass = JVMCIENV->asKlass(jvmci_type); if (!klass->is_instance_klass()) { JVMCI_THROW_MSG_NULL(IllegalArgumentException, @@ -2284,7 +2505,7 @@ 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()) { @@ -2316,7 +2537,7 @@ 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) { @@ -2331,7 +2552,7 @@ 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); @@ -2431,7 +2652,7 @@ {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)}, @@ -2469,6 +2690,9 @@ {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)},