src/share/vm/prims/jni.cpp
Print this page
rev 5893 : 8034080: Remove the USDT1 dtrace code from Hotspot
*** 112,148 ****
// DT_RETURN_MARK(SomeFunc, int, (const int&)return_value);
// foo(CHECK_0)
// return_value = 5;
// return return_value;
// JNI_END
- #ifndef USDT2
- #define DT_RETURN_MARK_DECL(name, type) \
- HS_DTRACE_PROBE_DECL1(hotspot_jni, name##__return, type); \
- DTRACE_ONLY( \
- class DTraceReturnProbeMark_##name { \
- public: \
- const type& _ret_ref; \
- DTraceReturnProbeMark_##name(const type& v) : _ret_ref(v) {} \
- ~DTraceReturnProbeMark_##name() { \
- HS_DTRACE_PROBE1(hotspot_jni, name##__return, _ret_ref); \
- } \
- } \
- )
- // Void functions are simpler since there's no return value
- #define DT_VOID_RETURN_MARK_DECL(name) \
- HS_DTRACE_PROBE_DECL0(hotspot_jni, name##__return); \
- DTRACE_ONLY( \
- class DTraceReturnProbeMark_##name { \
- public: \
- ~DTraceReturnProbeMark_##name() { \
- HS_DTRACE_PROBE0(hotspot_jni, name##__return); \
- } \
- } \
- )
-
- #else /* USDT2 */
-
#define DT_RETURN_MARK_DECL(name, type, probe) \
DTRACE_ONLY( \
class DTraceReturnProbeMark_##name { \
public: \
const type& _ret_ref; \
--- 112,121 ----
*** 160,170 ****
~DTraceReturnProbeMark_##name() { \
probe; \
} \
} \
)
- #endif /* USDT2 */
// Place these macros in the function to mark the return. Non-void
// functions need the type and address of the return value.
#define DT_RETURN_MARK(name, type, ref) \
DTRACE_ONLY( DTraceReturnProbeMark_##name dtrace_return_mark(ref) )
--- 133,142 ----
*** 189,207 ****
#define COMMA ,
// Choose DT_RETURN_MARK macros based on the type: float/double -> void
// (dtrace doesn't do FP yet)
- #ifndef USDT2
- #define DT_RETURN_MARK_DECL_FOR(TypeName, name, type) \
- FP_SELECT(TypeName, \
- DT_RETURN_MARK_DECL(name, type), DT_VOID_RETURN_MARK_DECL(name) )
- #else /* USDT2 */
#define DT_RETURN_MARK_DECL_FOR(TypeName, name, type, probe) \
FP_SELECT(TypeName, \
DT_RETURN_MARK_DECL(name, type, probe), DT_VOID_RETURN_MARK_DECL(name, probe) )
- #endif /* USDT2 */
#define DT_RETURN_MARK_FOR(TypeName, name, type, ref) \
FP_SELECT(TypeName, \
DT_RETURN_MARK(name, type, ref), DT_VOID_RETURN_MARK(name) )
--- 161,173 ----
*** 356,383 ****
#endif
// Implementation of JNI entries
- #ifndef USDT2
- DT_RETURN_MARK_DECL(DefineClass, jclass);
- #else /* USDT2 */
DT_RETURN_MARK_DECL(DefineClass, jclass
, HOTSPOT_JNI_DEFINECLASS_RETURN(_ret_ref));
- #endif /* USDT2 */
JNI_ENTRY(jclass, jni_DefineClass(JNIEnv *env, const char *name, jobject loaderRef,
const jbyte *buf, jsize bufLen))
JNIWrapper("DefineClass");
- #ifndef USDT2
- DTRACE_PROBE5(hotspot_jni, DefineClass__entry,
- env, name, loaderRef, buf, bufLen);
- #else /* USDT2 */
HOTSPOT_JNI_DEFINECLASS_ENTRY(
env, (char*) name, loaderRef, (char*) buf, bufLen);
! #endif /* USDT2 */
jclass cls = NULL;
DT_RETURN_MARK(DefineClass, jclass, (const jclass&)cls);
TempNewSymbol class_name = NULL;
// Since exceptions can be thrown, class initialization can take place
--- 322,341 ----
#endif
// Implementation of JNI entries
DT_RETURN_MARK_DECL(DefineClass, jclass
, HOTSPOT_JNI_DEFINECLASS_RETURN(_ret_ref));
JNI_ENTRY(jclass, jni_DefineClass(JNIEnv *env, const char *name, jobject loaderRef,
const jbyte *buf, jsize bufLen))
JNIWrapper("DefineClass");
HOTSPOT_JNI_DEFINECLASS_ENTRY(
env, (char*) name, loaderRef, (char*) buf, bufLen);
!
jclass cls = NULL;
DT_RETURN_MARK(DefineClass, jclass, (const jclass&)cls);
TempNewSymbol class_name = NULL;
// Since exceptions can be thrown, class initialization can take place
*** 419,442 ****
static bool first_time_FindClass = true;
- #ifndef USDT2
- DT_RETURN_MARK_DECL(FindClass, jclass);
- #else /* USDT2 */
DT_RETURN_MARK_DECL(FindClass, jclass
, HOTSPOT_JNI_FINDCLASS_RETURN(_ret_ref));
- #endif /* USDT2 */
JNI_ENTRY(jclass, jni_FindClass(JNIEnv *env, const char *name))
JNIWrapper("FindClass");
! #ifndef USDT2
! DTRACE_PROBE2(hotspot_jni, FindClass__entry, env, name);
! #else /* USDT2 */
HOTSPOT_JNI_FINDCLASS_ENTRY(env, (char *)name);
- #endif /* USDT2 */
jclass result = NULL;
DT_RETURN_MARK(FindClass, jclass, (const jclass&)result);
// Remember if we are the first invocation of jni_FindClass
--- 377,393 ----
static bool first_time_FindClass = true;
DT_RETURN_MARK_DECL(FindClass, jclass
, HOTSPOT_JNI_FINDCLASS_RETURN(_ret_ref));
JNI_ENTRY(jclass, jni_FindClass(JNIEnv *env, const char *name))
JNIWrapper("FindClass");
!
HOTSPOT_JNI_FINDCLASS_ENTRY(env, (char *)name);
jclass result = NULL;
DT_RETURN_MARK(FindClass, jclass, (const jclass&)result);
// Remember if we are the first invocation of jni_FindClass
*** 496,519 ****
CompilationPolicy::completed_vm_startup();
return result;
JNI_END
- #ifndef USDT2
- DT_RETURN_MARK_DECL(FromReflectedMethod, jmethodID);
- #else /* USDT2 */
DT_RETURN_MARK_DECL(FromReflectedMethod, jmethodID
, HOTSPOT_JNI_FROMREFLECTEDMETHOD_RETURN((uintptr_t)_ret_ref));
- #endif /* USDT2 */
JNI_ENTRY(jmethodID, jni_FromReflectedMethod(JNIEnv *env, jobject method))
JNIWrapper("FromReflectedMethod");
! #ifndef USDT2
! DTRACE_PROBE2(hotspot_jni, FromReflectedMethod__entry, env, method);
! #else /* USDT2 */
HOTSPOT_JNI_FROMREFLECTEDMETHOD_ENTRY(env, method);
! #endif /* USDT2 */
jmethodID ret = NULL;
DT_RETURN_MARK(FromReflectedMethod, jmethodID, (const jmethodID&)ret);
// method is a handle to a java.lang.reflect.Method object
oop reflected = JNIHandles::resolve_non_null(method);
--- 447,464 ----
CompilationPolicy::completed_vm_startup();
return result;
JNI_END
DT_RETURN_MARK_DECL(FromReflectedMethod, jmethodID
, HOTSPOT_JNI_FROMREFLECTEDMETHOD_RETURN((uintptr_t)_ret_ref));
JNI_ENTRY(jmethodID, jni_FromReflectedMethod(JNIEnv *env, jobject method))
JNIWrapper("FromReflectedMethod");
!
HOTSPOT_JNI_FROMREFLECTEDMETHOD_ENTRY(env, method);
!
jmethodID ret = NULL;
DT_RETURN_MARK(FromReflectedMethod, jmethodID, (const jmethodID&)ret);
// method is a handle to a java.lang.reflect.Method object
oop reflected = JNIHandles::resolve_non_null(method);
*** 536,559 ****
Method* m = InstanceKlass::cast(k1())->method_with_idnum(slot);
ret = m==NULL? NULL : m->jmethod_id(); // return NULL if reflected method deleted
return ret;
JNI_END
- #ifndef USDT2
- DT_RETURN_MARK_DECL(FromReflectedField, jfieldID);
- #else /* USDT2 */
DT_RETURN_MARK_DECL(FromReflectedField, jfieldID
, HOTSPOT_JNI_FROMREFLECTEDFIELD_RETURN((uintptr_t)_ret_ref));
- #endif /* USDT2 */
JNI_ENTRY(jfieldID, jni_FromReflectedField(JNIEnv *env, jobject field))
JNIWrapper("FromReflectedField");
! #ifndef USDT2
! DTRACE_PROBE2(hotspot_jni, FromReflectedField__entry, env, field);
! #else /* USDT2 */
HOTSPOT_JNI_FROMREFLECTEDFIELD_ENTRY(env, field);
! #endif /* USDT2 */
jfieldID ret = NULL;
DT_RETURN_MARK(FromReflectedField, jfieldID, (const jfieldID&)ret);
// field is a handle to a java.lang.reflect.Field object
oop reflected = JNIHandles::resolve_non_null(field);
--- 481,498 ----
Method* m = InstanceKlass::cast(k1())->method_with_idnum(slot);
ret = m==NULL? NULL : m->jmethod_id(); // return NULL if reflected method deleted
return ret;
JNI_END
DT_RETURN_MARK_DECL(FromReflectedField, jfieldID
, HOTSPOT_JNI_FROMREFLECTEDFIELD_RETURN((uintptr_t)_ret_ref));
JNI_ENTRY(jfieldID, jni_FromReflectedField(JNIEnv *env, jobject field))
JNIWrapper("FromReflectedField");
!
HOTSPOT_JNI_FROMREFLECTEDFIELD_ENTRY(env, field);
!
jfieldID ret = NULL;
DT_RETURN_MARK(FromReflectedField, jfieldID, (const jfieldID&)ret);
// field is a handle to a java.lang.reflect.Field object
oop reflected = JNIHandles::resolve_non_null(field);
*** 584,607 ****
assert(InstanceKlass::cast(k1())->contains_field_offset(offset), "stay within object");
ret = jfieldIDWorkaround::to_instance_jfieldID(k1(), offset);
return ret;
JNI_END
! #ifndef USDT2
! DT_RETURN_MARK_DECL(ToReflectedMethod, jobject);
! #else /* USDT2 */
DT_RETURN_MARK_DECL(ToReflectedMethod, jobject
, HOTSPOT_JNI_TOREFLECTEDMETHOD_RETURN(_ret_ref));
- #endif /* USDT2 */
JNI_ENTRY(jobject, jni_ToReflectedMethod(JNIEnv *env, jclass cls, jmethodID method_id, jboolean isStatic))
JNIWrapper("ToReflectedMethod");
! #ifndef USDT2
! DTRACE_PROBE4(hotspot_jni, ToReflectedMethod__entry, env, cls, method_id, isStatic);
! #else /* USDT2 */
HOTSPOT_JNI_TOREFLECTEDMETHOD_ENTRY(env, cls, (uintptr_t) method_id, isStatic);
! #endif /* USDT2 */
jobject ret = NULL;
DT_RETURN_MARK(ToReflectedMethod, jobject, (const jobject&)ret);
methodHandle m (THREAD, Method::resolve_jmethod_id(method_id));
assert(m->is_static() == (isStatic != 0), "jni_ToReflectedMethod access flags doesn't match");
--- 523,541 ----
assert(InstanceKlass::cast(k1())->contains_field_offset(offset), "stay within object");
ret = jfieldIDWorkaround::to_instance_jfieldID(k1(), offset);
return ret;
JNI_END
!
DT_RETURN_MARK_DECL(ToReflectedMethod, jobject
, HOTSPOT_JNI_TOREFLECTEDMETHOD_RETURN(_ret_ref));
JNI_ENTRY(jobject, jni_ToReflectedMethod(JNIEnv *env, jclass cls, jmethodID method_id, jboolean isStatic))
JNIWrapper("ToReflectedMethod");
!
HOTSPOT_JNI_TOREFLECTEDMETHOD_ENTRY(env, cls, (uintptr_t) method_id, isStatic);
!
jobject ret = NULL;
DT_RETURN_MARK(ToReflectedMethod, jobject, (const jobject&)ret);
methodHandle m (THREAD, Method::resolve_jmethod_id(method_id));
assert(m->is_static() == (isStatic != 0), "jni_ToReflectedMethod access flags doesn't match");
*** 613,636 ****
}
ret = JNIHandles::make_local(env, reflection_method);
return ret;
JNI_END
- #ifndef USDT2
- DT_RETURN_MARK_DECL(GetSuperclass, jclass);
- #else /* USDT2 */
DT_RETURN_MARK_DECL(GetSuperclass, jclass
, HOTSPOT_JNI_GETSUPERCLASS_RETURN(_ret_ref));
- #endif /* USDT2 */
JNI_ENTRY(jclass, jni_GetSuperclass(JNIEnv *env, jclass sub))
JNIWrapper("GetSuperclass");
! #ifndef USDT2
! DTRACE_PROBE2(hotspot_jni, GetSuperclass__entry, env, sub);
! #else /* USDT2 */
HOTSPOT_JNI_GETSUPERCLASS_ENTRY(env, sub);
! #endif /* USDT2 */
jclass obj = NULL;
DT_RETURN_MARK(GetSuperclass, jclass, (const jclass&)obj);
oop mirror = JNIHandles::resolve_non_null(sub);
// primitive classes return NULL
--- 547,564 ----
}
ret = JNIHandles::make_local(env, reflection_method);
return ret;
JNI_END
DT_RETURN_MARK_DECL(GetSuperclass, jclass
, HOTSPOT_JNI_GETSUPERCLASS_RETURN(_ret_ref));
JNI_ENTRY(jclass, jni_GetSuperclass(JNIEnv *env, jclass sub))
JNIWrapper("GetSuperclass");
!
HOTSPOT_JNI_GETSUPERCLASS_ENTRY(env, sub);
!
jclass obj = NULL;
DT_RETURN_MARK(GetSuperclass, jclass, (const jclass&)obj);
oop mirror = JNIHandles::resolve_non_null(sub);
// primitive classes return NULL
*** 655,729 ****
return obj;
JNI_END
JNI_QUICK_ENTRY(jboolean, jni_IsAssignableFrom(JNIEnv *env, jclass sub, jclass super))
JNIWrapper("IsSubclassOf");
! #ifndef USDT2
! DTRACE_PROBE3(hotspot_jni, IsAssignableFrom__entry, env, sub, super);
! #else /* USDT2 */
HOTSPOT_JNI_ISASSIGNABLEFROM_ENTRY(env, sub, super);
! #endif /* USDT2 */
oop sub_mirror = JNIHandles::resolve_non_null(sub);
oop super_mirror = JNIHandles::resolve_non_null(super);
if (java_lang_Class::is_primitive(sub_mirror) ||
java_lang_Class::is_primitive(super_mirror)) {
jboolean ret = (sub_mirror == super_mirror);
! #ifndef USDT2
! DTRACE_PROBE1(hotspot_jni, IsAssignableFrom__return, ret);
! #else /* USDT2 */
HOTSPOT_JNI_ISASSIGNABLEFROM_RETURN(ret);
- #endif /* USDT2 */
return ret;
}
Klass* sub_klass = java_lang_Class::as_Klass(sub_mirror);
Klass* super_klass = java_lang_Class::as_Klass(super_mirror);
assert(sub_klass != NULL && super_klass != NULL, "invalid arguments to jni_IsAssignableFrom");
jboolean ret = sub_klass->is_subtype_of(super_klass) ?
JNI_TRUE : JNI_FALSE;
! #ifndef USDT2
! DTRACE_PROBE1(hotspot_jni, IsAssignableFrom__return, ret);
! #else /* USDT2 */
HOTSPOT_JNI_ISASSIGNABLEFROM_RETURN(ret);
- #endif /* USDT2 */
return ret;
JNI_END
! #ifndef USDT2
! DT_RETURN_MARK_DECL(Throw, jint);
! #else /* USDT2 */
DT_RETURN_MARK_DECL(Throw, jint
, HOTSPOT_JNI_THROW_RETURN(_ret_ref));
- #endif /* USDT2 */
JNI_ENTRY(jint, jni_Throw(JNIEnv *env, jthrowable obj))
JNIWrapper("Throw");
! #ifndef USDT2
! DTRACE_PROBE2(hotspot_jni, Throw__entry, env, obj);
! #else /* USDT2 */
HOTSPOT_JNI_THROW_ENTRY(env, obj);
! #endif /* USDT2 */
jint ret = JNI_OK;
DT_RETURN_MARK(Throw, jint, (const jint&)ret);
THROW_OOP_(JNIHandles::resolve(obj), JNI_OK);
ShouldNotReachHere();
JNI_END
! #ifndef USDT2
! DT_RETURN_MARK_DECL(ThrowNew, jint);
! #else /* USDT2 */
DT_RETURN_MARK_DECL(ThrowNew, jint
, HOTSPOT_JNI_THROWNEW_RETURN(_ret_ref));
- #endif /* USDT2 */
JNI_ENTRY(jint, jni_ThrowNew(JNIEnv *env, jclass clazz, const char *message))
JNIWrapper("ThrowNew");
! #ifndef USDT2
! DTRACE_PROBE3(hotspot_jni, ThrowNew__entry, env, clazz, message);
! #else /* USDT2 */
HOTSPOT_JNI_THROWNEW_ENTRY(env, clazz, (char *) message);
! #endif /* USDT2 */
jint ret = JNI_OK;
DT_RETURN_MARK(ThrowNew, jint, (const jint&)ret);
InstanceKlass* k = InstanceKlass::cast(java_lang_Class::as_Klass(JNIHandles::resolve_non_null(clazz)));
Symbol* name = k->name();
--- 583,639 ----
return obj;
JNI_END
JNI_QUICK_ENTRY(jboolean, jni_IsAssignableFrom(JNIEnv *env, jclass sub, jclass super))
JNIWrapper("IsSubclassOf");
!
HOTSPOT_JNI_ISASSIGNABLEFROM_ENTRY(env, sub, super);
!
oop sub_mirror = JNIHandles::resolve_non_null(sub);
oop super_mirror = JNIHandles::resolve_non_null(super);
if (java_lang_Class::is_primitive(sub_mirror) ||
java_lang_Class::is_primitive(super_mirror)) {
jboolean ret = (sub_mirror == super_mirror);
!
HOTSPOT_JNI_ISASSIGNABLEFROM_RETURN(ret);
return ret;
}
Klass* sub_klass = java_lang_Class::as_Klass(sub_mirror);
Klass* super_klass = java_lang_Class::as_Klass(super_mirror);
assert(sub_klass != NULL && super_klass != NULL, "invalid arguments to jni_IsAssignableFrom");
jboolean ret = sub_klass->is_subtype_of(super_klass) ?
JNI_TRUE : JNI_FALSE;
!
HOTSPOT_JNI_ISASSIGNABLEFROM_RETURN(ret);
return ret;
JNI_END
!
DT_RETURN_MARK_DECL(Throw, jint
, HOTSPOT_JNI_THROW_RETURN(_ret_ref));
JNI_ENTRY(jint, jni_Throw(JNIEnv *env, jthrowable obj))
JNIWrapper("Throw");
!
HOTSPOT_JNI_THROW_ENTRY(env, obj);
!
jint ret = JNI_OK;
DT_RETURN_MARK(Throw, jint, (const jint&)ret);
THROW_OOP_(JNIHandles::resolve(obj), JNI_OK);
ShouldNotReachHere();
JNI_END
!
DT_RETURN_MARK_DECL(ThrowNew, jint
, HOTSPOT_JNI_THROWNEW_RETURN(_ret_ref));
JNI_ENTRY(jint, jni_ThrowNew(JNIEnv *env, jclass clazz, const char *message))
JNIWrapper("ThrowNew");
!
HOTSPOT_JNI_THROWNEW_ENTRY(env, clazz, (char *) message);
!
jint ret = JNI_OK;
DT_RETURN_MARK(ThrowNew, jint, (const jint&)ret);
InstanceKlass* k = InstanceKlass::cast(java_lang_Class::as_Klass(JNIHandles::resolve_non_null(clazz)));
Symbol* name = k->name();
*** 748,781 ****
thread->check_and_handle_async_exceptions();
}
JNI_ENTRY_NO_PRESERVE(jthrowable, jni_ExceptionOccurred(JNIEnv *env))
JNIWrapper("ExceptionOccurred");
! #ifndef USDT2
! DTRACE_PROBE1(hotspot_jni, ExceptionOccurred__entry, env);
! #else /* USDT2 */
HOTSPOT_JNI_EXCEPTIONOCCURRED_ENTRY(env);
! #endif /* USDT2 */
jni_check_async_exceptions(thread);
oop exception = thread->pending_exception();
jthrowable ret = (jthrowable) JNIHandles::make_local(env, exception);
! #ifndef USDT2
! DTRACE_PROBE1(hotspot_jni, ExceptionOccurred__return, ret);
! #else /* USDT2 */
HOTSPOT_JNI_EXCEPTIONOCCURRED_RETURN(ret);
- #endif /* USDT2 */
return ret;
JNI_END
JNI_ENTRY_NO_PRESERVE(void, jni_ExceptionDescribe(JNIEnv *env))
JNIWrapper("ExceptionDescribe");
! #ifndef USDT2
! DTRACE_PROBE1(hotspot_jni, ExceptionDescribe__entry, env);
! #else /* USDT2 */
HOTSPOT_JNI_EXCEPTIONDESCRIBE_ENTRY(env);
! #endif /* USDT2 */
if (thread->has_pending_exception()) {
Handle ex(thread, thread->pending_exception());
thread->clear_pending_exception();
if (ex->is_a(SystemDictionary::ThreadDeath_klass())) {
// Don't print anything if we are being killed.
--- 658,684 ----
thread->check_and_handle_async_exceptions();
}
JNI_ENTRY_NO_PRESERVE(jthrowable, jni_ExceptionOccurred(JNIEnv *env))
JNIWrapper("ExceptionOccurred");
!
HOTSPOT_JNI_EXCEPTIONOCCURRED_ENTRY(env);
!
jni_check_async_exceptions(thread);
oop exception = thread->pending_exception();
jthrowable ret = (jthrowable) JNIHandles::make_local(env, exception);
!
HOTSPOT_JNI_EXCEPTIONOCCURRED_RETURN(ret);
return ret;
JNI_END
JNI_ENTRY_NO_PRESERVE(void, jni_ExceptionDescribe(JNIEnv *env))
JNIWrapper("ExceptionDescribe");
!
HOTSPOT_JNI_EXCEPTIONDESCRIBE_ENTRY(env);
!
if (thread->has_pending_exception()) {
Handle ex(thread, thread->pending_exception());
thread->clear_pending_exception();
if (ex->is_a(SystemDictionary::ThreadDeath_klass())) {
// Don't print anything if we are being killed.
*** 807,898 ****
". Uncaught exception of type %s.",
ex->klass()->external_name());
}
}
}
! #ifndef USDT2
! DTRACE_PROBE(hotspot_jni, ExceptionDescribe__return);
! #else /* USDT2 */
HOTSPOT_JNI_EXCEPTIONDESCRIBE_RETURN();
- #endif /* USDT2 */
JNI_END
JNI_QUICK_ENTRY(void, jni_ExceptionClear(JNIEnv *env))
JNIWrapper("ExceptionClear");
! #ifndef USDT2
! DTRACE_PROBE1(hotspot_jni, ExceptionClear__entry, env);
! #else /* USDT2 */
HOTSPOT_JNI_EXCEPTIONCLEAR_ENTRY(env);
- #endif /* USDT2 */
// The jni code might be using this API to clear java thrown exception.
// So just mark jvmti thread exception state as exception caught.
JvmtiThreadState *state = JavaThread::current()->jvmti_thread_state();
if (state != NULL && state->is_exception_detected()) {
state->set_exception_caught();
}
thread->clear_pending_exception();
! #ifndef USDT2
! DTRACE_PROBE(hotspot_jni, ExceptionClear__return);
! #else /* USDT2 */
HOTSPOT_JNI_EXCEPTIONCLEAR_RETURN();
- #endif /* USDT2 */
JNI_END
JNI_ENTRY(void, jni_FatalError(JNIEnv *env, const char *msg))
JNIWrapper("FatalError");
! #ifndef USDT2
! DTRACE_PROBE2(hotspot_jni, FatalError__entry, env, msg);
! #else /* USDT2 */
HOTSPOT_JNI_FATALERROR_ENTRY(env, (char *) msg);
! #endif /* USDT2 */
tty->print_cr("FATAL ERROR in native method: %s", msg);
thread->print_stack();
os::abort(); // Dump core and abort
JNI_END
JNI_ENTRY(jint, jni_PushLocalFrame(JNIEnv *env, jint capacity))
JNIWrapper("PushLocalFrame");
! #ifndef USDT2
! DTRACE_PROBE2(hotspot_jni, PushLocalFrame__entry, env, capacity);
! #else /* USDT2 */
HOTSPOT_JNI_PUSHLOCALFRAME_ENTRY(env, capacity);
! #endif /* USDT2 */
//%note jni_11
if (capacity < 0 || capacity > MAX_REASONABLE_LOCAL_CAPACITY) {
- #ifndef USDT2
- DTRACE_PROBE1(hotspot_jni, PushLocalFrame__return, JNI_ERR);
- #else /* USDT2 */
HOTSPOT_JNI_PUSHLOCALFRAME_RETURN((uint32_t)JNI_ERR);
- #endif /* USDT2 */
return JNI_ERR;
}
JNIHandleBlock* old_handles = thread->active_handles();
JNIHandleBlock* new_handles = JNIHandleBlock::allocate_block(thread);
assert(new_handles != NULL, "should not be NULL");
new_handles->set_pop_frame_link(old_handles);
thread->set_active_handles(new_handles);
jint ret = JNI_OK;
- #ifndef USDT2
- DTRACE_PROBE1(hotspot_jni, PushLocalFrame__return, ret);
- #else /* USDT2 */
HOTSPOT_JNI_PUSHLOCALFRAME_RETURN(ret);
- #endif /* USDT2 */
return ret;
JNI_END
JNI_ENTRY(jobject, jni_PopLocalFrame(JNIEnv *env, jobject result))
JNIWrapper("PopLocalFrame");
! #ifndef USDT2
! DTRACE_PROBE2(hotspot_jni, PopLocalFrame__entry, env, result);
! #else /* USDT2 */
HOTSPOT_JNI_POPLOCALFRAME_ENTRY(env, result);
! #endif /* USDT2 */
//%note jni_11
Handle result_handle(thread, JNIHandles::resolve(result));
JNIHandleBlock* old_handles = thread->active_handles();
JNIHandleBlock* new_handles = old_handles->pop_frame_link();
if (new_handles != NULL) {
--- 710,778 ----
". Uncaught exception of type %s.",
ex->klass()->external_name());
}
}
}
!
HOTSPOT_JNI_EXCEPTIONDESCRIBE_RETURN();
JNI_END
JNI_QUICK_ENTRY(void, jni_ExceptionClear(JNIEnv *env))
JNIWrapper("ExceptionClear");
!
HOTSPOT_JNI_EXCEPTIONCLEAR_ENTRY(env);
// The jni code might be using this API to clear java thrown exception.
// So just mark jvmti thread exception state as exception caught.
JvmtiThreadState *state = JavaThread::current()->jvmti_thread_state();
if (state != NULL && state->is_exception_detected()) {
state->set_exception_caught();
}
thread->clear_pending_exception();
!
HOTSPOT_JNI_EXCEPTIONCLEAR_RETURN();
JNI_END
JNI_ENTRY(void, jni_FatalError(JNIEnv *env, const char *msg))
JNIWrapper("FatalError");
!
HOTSPOT_JNI_FATALERROR_ENTRY(env, (char *) msg);
!
tty->print_cr("FATAL ERROR in native method: %s", msg);
thread->print_stack();
os::abort(); // Dump core and abort
JNI_END
JNI_ENTRY(jint, jni_PushLocalFrame(JNIEnv *env, jint capacity))
JNIWrapper("PushLocalFrame");
!
HOTSPOT_JNI_PUSHLOCALFRAME_ENTRY(env, capacity);
!
//%note jni_11
if (capacity < 0 || capacity > MAX_REASONABLE_LOCAL_CAPACITY) {
HOTSPOT_JNI_PUSHLOCALFRAME_RETURN((uint32_t)JNI_ERR);
return JNI_ERR;
}
JNIHandleBlock* old_handles = thread->active_handles();
JNIHandleBlock* new_handles = JNIHandleBlock::allocate_block(thread);
assert(new_handles != NULL, "should not be NULL");
new_handles->set_pop_frame_link(old_handles);
thread->set_active_handles(new_handles);
jint ret = JNI_OK;
HOTSPOT_JNI_PUSHLOCALFRAME_RETURN(ret);
return ret;
JNI_END
JNI_ENTRY(jobject, jni_PopLocalFrame(JNIEnv *env, jobject result))
JNIWrapper("PopLocalFrame");
!
HOTSPOT_JNI_POPLOCALFRAME_ENTRY(env, result);
!
//%note jni_11
Handle result_handle(thread, JNIHandles::resolve(result));
JNIHandleBlock* old_handles = thread->active_handles();
JNIHandleBlock* new_handles = old_handles->pop_frame_link();
if (new_handles != NULL) {
*** 903,1048 ****
thread->set_active_handles(new_handles);
old_handles->set_pop_frame_link(NULL); // clear link we won't release new_handles below
JNIHandleBlock::release_block(old_handles, thread); // may block
result = JNIHandles::make_local(thread, result_handle());
}
- #ifndef USDT2
- DTRACE_PROBE1(hotspot_jni, PopLocalFrame__return, result);
- #else /* USDT2 */
HOTSPOT_JNI_POPLOCALFRAME_RETURN(result);
- #endif /* USDT2 */
return result;
JNI_END
JNI_ENTRY(jobject, jni_NewGlobalRef(JNIEnv *env, jobject ref))
JNIWrapper("NewGlobalRef");
! #ifndef USDT2
! DTRACE_PROBE2(hotspot_jni, NewGlobalRef__entry, env, ref);
! #else /* USDT2 */
HOTSPOT_JNI_NEWGLOBALREF_ENTRY(env, ref);
! #endif /* USDT2 */
Handle ref_handle(thread, JNIHandles::resolve(ref));
jobject ret = JNIHandles::make_global(ref_handle);
! #ifndef USDT2
! DTRACE_PROBE1(hotspot_jni, NewGlobalRef__return, ret);
! #else /* USDT2 */
HOTSPOT_JNI_NEWGLOBALREF_RETURN(ret);
- #endif /* USDT2 */
return ret;
JNI_END
// Must be JNI_ENTRY (with HandleMark)
JNI_ENTRY_NO_PRESERVE(void, jni_DeleteGlobalRef(JNIEnv *env, jobject ref))
JNIWrapper("DeleteGlobalRef");
! #ifndef USDT2
! DTRACE_PROBE2(hotspot_jni, DeleteGlobalRef__entry, env, ref);
! #else /* USDT2 */
HOTSPOT_JNI_DELETEGLOBALREF_ENTRY(env, ref);
! #endif /* USDT2 */
JNIHandles::destroy_global(ref);
! #ifndef USDT2
! DTRACE_PROBE(hotspot_jni, DeleteGlobalRef__return);
! #else /* USDT2 */
HOTSPOT_JNI_DELETEGLOBALREF_RETURN();
- #endif /* USDT2 */
JNI_END
JNI_QUICK_ENTRY(void, jni_DeleteLocalRef(JNIEnv *env, jobject obj))
JNIWrapper("DeleteLocalRef");
! #ifndef USDT2
! DTRACE_PROBE2(hotspot_jni, DeleteLocalRef__entry, env, obj);
! #else /* USDT2 */
HOTSPOT_JNI_DELETELOCALREF_ENTRY(env, obj);
! #endif /* USDT2 */
JNIHandles::destroy_local(obj);
! #ifndef USDT2
! DTRACE_PROBE(hotspot_jni, DeleteLocalRef__return);
! #else /* USDT2 */
HOTSPOT_JNI_DELETELOCALREF_RETURN();
- #endif /* USDT2 */
JNI_END
JNI_QUICK_ENTRY(jboolean, jni_IsSameObject(JNIEnv *env, jobject r1, jobject r2))
JNIWrapper("IsSameObject");
! #ifndef USDT2
! DTRACE_PROBE3(hotspot_jni, IsSameObject__entry, env, r1, r2);
! #else /* USDT2 */
HOTSPOT_JNI_ISSAMEOBJECT_ENTRY(env, r1, r2);
! #endif /* USDT2 */
oop a = JNIHandles::resolve(r1);
oop b = JNIHandles::resolve(r2);
jboolean ret = (a == b) ? JNI_TRUE : JNI_FALSE;
! #ifndef USDT2
! DTRACE_PROBE1(hotspot_jni, IsSameObject__return, ret);
! #else /* USDT2 */
HOTSPOT_JNI_ISSAMEOBJECT_RETURN(ret);
- #endif /* USDT2 */
return ret;
JNI_END
JNI_ENTRY(jobject, jni_NewLocalRef(JNIEnv *env, jobject ref))
JNIWrapper("NewLocalRef");
! #ifndef USDT2
! DTRACE_PROBE2(hotspot_jni, NewLocalRef__entry, env, ref);
! #else /* USDT2 */
HOTSPOT_JNI_NEWLOCALREF_ENTRY(env, ref);
! #endif /* USDT2 */
jobject ret = JNIHandles::make_local(env, JNIHandles::resolve(ref));
! #ifndef USDT2
! DTRACE_PROBE1(hotspot_jni, NewLocalRef__return, ret);
! #else /* USDT2 */
HOTSPOT_JNI_NEWLOCALREF_RETURN(ret);
- #endif /* USDT2 */
return ret;
JNI_END
JNI_LEAF(jint, jni_EnsureLocalCapacity(JNIEnv *env, jint capacity))
JNIWrapper("EnsureLocalCapacity");
! #ifndef USDT2
! DTRACE_PROBE2(hotspot_jni, EnsureLocalCapacity__entry, env, capacity);
! #else /* USDT2 */
HOTSPOT_JNI_ENSURELOCALCAPACITY_ENTRY(env, capacity);
! #endif /* USDT2 */
jint ret;
if (capacity >= 0 && capacity <= MAX_REASONABLE_LOCAL_CAPACITY) {
ret = JNI_OK;
} else {
ret = JNI_ERR;
}
! #ifndef USDT2
! DTRACE_PROBE1(hotspot_jni, EnsureLocalCapacity__return, ret);
! #else /* USDT2 */
HOTSPOT_JNI_ENSURELOCALCAPACITY_RETURN(ret);
- #endif /* USDT2 */
return ret;
JNI_END
// Return the Handle Type
JNI_LEAF(jobjectRefType, jni_GetObjectRefType(JNIEnv *env, jobject obj))
JNIWrapper("GetObjectRefType");
! #ifndef USDT2
! DTRACE_PROBE2(hotspot_jni, GetObjectRefType__entry, env, obj);
! #else /* USDT2 */
HOTSPOT_JNI_GETOBJECTREFTYPE_ENTRY(env, obj);
! #endif /* USDT2 */
jobjectRefType ret;
if (JNIHandles::is_local_handle(thread, obj) ||
JNIHandles::is_frame_handle(thread, obj))
ret = JNILocalRefType;
else if (JNIHandles::is_global_handle(obj))
ret = JNIGlobalRefType;
else if (JNIHandles::is_weak_global_handle(obj))
ret = JNIWeakGlobalRefType;
else
ret = JNIInvalidRefType;
! #ifndef USDT2
! DTRACE_PROBE1(hotspot_jni, GetObjectRefType__return, ret);
! #else /* USDT2 */
HOTSPOT_JNI_GETOBJECTREFTYPE_RETURN((void *) ret);
- #endif /* USDT2 */
return ret;
JNI_END
class JNI_ArgumentPusher : public SignatureIterator {
--- 783,889 ----
thread->set_active_handles(new_handles);
old_handles->set_pop_frame_link(NULL); // clear link we won't release new_handles below
JNIHandleBlock::release_block(old_handles, thread); // may block
result = JNIHandles::make_local(thread, result_handle());
}
HOTSPOT_JNI_POPLOCALFRAME_RETURN(result);
return result;
JNI_END
JNI_ENTRY(jobject, jni_NewGlobalRef(JNIEnv *env, jobject ref))
JNIWrapper("NewGlobalRef");
!
HOTSPOT_JNI_NEWGLOBALREF_ENTRY(env, ref);
!
Handle ref_handle(thread, JNIHandles::resolve(ref));
jobject ret = JNIHandles::make_global(ref_handle);
!
HOTSPOT_JNI_NEWGLOBALREF_RETURN(ret);
return ret;
JNI_END
// Must be JNI_ENTRY (with HandleMark)
JNI_ENTRY_NO_PRESERVE(void, jni_DeleteGlobalRef(JNIEnv *env, jobject ref))
JNIWrapper("DeleteGlobalRef");
!
HOTSPOT_JNI_DELETEGLOBALREF_ENTRY(env, ref);
!
JNIHandles::destroy_global(ref);
!
HOTSPOT_JNI_DELETEGLOBALREF_RETURN();
JNI_END
JNI_QUICK_ENTRY(void, jni_DeleteLocalRef(JNIEnv *env, jobject obj))
JNIWrapper("DeleteLocalRef");
!
HOTSPOT_JNI_DELETELOCALREF_ENTRY(env, obj);
!
JNIHandles::destroy_local(obj);
!
HOTSPOT_JNI_DELETELOCALREF_RETURN();
JNI_END
JNI_QUICK_ENTRY(jboolean, jni_IsSameObject(JNIEnv *env, jobject r1, jobject r2))
JNIWrapper("IsSameObject");
!
HOTSPOT_JNI_ISSAMEOBJECT_ENTRY(env, r1, r2);
!
oop a = JNIHandles::resolve(r1);
oop b = JNIHandles::resolve(r2);
jboolean ret = (a == b) ? JNI_TRUE : JNI_FALSE;
!
HOTSPOT_JNI_ISSAMEOBJECT_RETURN(ret);
return ret;
JNI_END
JNI_ENTRY(jobject, jni_NewLocalRef(JNIEnv *env, jobject ref))
JNIWrapper("NewLocalRef");
!
HOTSPOT_JNI_NEWLOCALREF_ENTRY(env, ref);
!
jobject ret = JNIHandles::make_local(env, JNIHandles::resolve(ref));
!
HOTSPOT_JNI_NEWLOCALREF_RETURN(ret);
return ret;
JNI_END
JNI_LEAF(jint, jni_EnsureLocalCapacity(JNIEnv *env, jint capacity))
JNIWrapper("EnsureLocalCapacity");
!
HOTSPOT_JNI_ENSURELOCALCAPACITY_ENTRY(env, capacity);
!
jint ret;
if (capacity >= 0 && capacity <= MAX_REASONABLE_LOCAL_CAPACITY) {
ret = JNI_OK;
} else {
ret = JNI_ERR;
}
!
HOTSPOT_JNI_ENSURELOCALCAPACITY_RETURN(ret);
return ret;
JNI_END
// Return the Handle Type
JNI_LEAF(jobjectRefType, jni_GetObjectRefType(JNIEnv *env, jobject obj))
JNIWrapper("GetObjectRefType");
!
HOTSPOT_JNI_GETOBJECTREFTYPE_ENTRY(env, obj);
!
jobjectRefType ret;
if (JNIHandles::is_local_handle(thread, obj) ||
JNIHandles::is_frame_handle(thread, obj))
ret = JNILocalRefType;
else if (JNIHandles::is_global_handle(obj))
ret = JNIGlobalRefType;
else if (JNIHandles::is_weak_global_handle(obj))
ret = JNIWeakGlobalRefType;
else
ret = JNIInvalidRefType;
!
HOTSPOT_JNI_GETOBJECTREFTYPE_RETURN((void *) ret);
return ret;
JNI_END
class JNI_ArgumentPusher : public SignatureIterator {
*** 1367,1413 ****
InstanceKlass::cast(k())->initialize(CHECK_NULL);
instanceOop ih = InstanceKlass::cast(k())->allocate_instance(THREAD);
return ih;
}
- #ifndef USDT2
- DT_RETURN_MARK_DECL(AllocObject, jobject);
- #else /* USDT2 */
DT_RETURN_MARK_DECL(AllocObject, jobject
, HOTSPOT_JNI_ALLOCOBJECT_RETURN(_ret_ref));
- #endif /* USDT2 */
JNI_ENTRY(jobject, jni_AllocObject(JNIEnv *env, jclass clazz))
JNIWrapper("AllocObject");
- #ifndef USDT2
- DTRACE_PROBE2(hotspot_jni, AllocObject__entry, env, clazz);
- #else /* USDT2 */
HOTSPOT_JNI_ALLOCOBJECT_ENTRY(env, clazz);
! #endif /* USDT2 */
jobject ret = NULL;
DT_RETURN_MARK(AllocObject, jobject, (const jobject&)ret);
instanceOop i = alloc_object(clazz, CHECK_NULL);
ret = JNIHandles::make_local(env, i);
return ret;
JNI_END
- #ifndef USDT2
- DT_RETURN_MARK_DECL(NewObjectA, jobject);
- #else /* USDT2 */
DT_RETURN_MARK_DECL(NewObjectA, jobject
, HOTSPOT_JNI_NEWOBJECTA_RETURN(_ret_ref));
- #endif /* USDT2 */
JNI_ENTRY(jobject, jni_NewObjectA(JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args))
JNIWrapper("NewObjectA");
! #ifndef USDT2
! DTRACE_PROBE3(hotspot_jni, NewObjectA__entry, env, clazz, methodID);
! #else /* USDT2 */
HOTSPOT_JNI_NEWOBJECTA_ENTRY(env, clazz, (uintptr_t) methodID);
! #endif /* USDT2 */
jobject obj = NULL;
DT_RETURN_MARK(NewObjectA, jobject, (const jobject)obj);
instanceOop i = alloc_object(clazz, CHECK_NULL);
obj = JNIHandles::make_local(env, i);
--- 1208,1241 ----
InstanceKlass::cast(k())->initialize(CHECK_NULL);
instanceOop ih = InstanceKlass::cast(k())->allocate_instance(THREAD);
return ih;
}
DT_RETURN_MARK_DECL(AllocObject, jobject
, HOTSPOT_JNI_ALLOCOBJECT_RETURN(_ret_ref));
JNI_ENTRY(jobject, jni_AllocObject(JNIEnv *env, jclass clazz))
JNIWrapper("AllocObject");
HOTSPOT_JNI_ALLOCOBJECT_ENTRY(env, clazz);
!
jobject ret = NULL;
DT_RETURN_MARK(AllocObject, jobject, (const jobject&)ret);
instanceOop i = alloc_object(clazz, CHECK_NULL);
ret = JNIHandles::make_local(env, i);
return ret;
JNI_END
DT_RETURN_MARK_DECL(NewObjectA, jobject
, HOTSPOT_JNI_NEWOBJECTA_RETURN(_ret_ref));
JNI_ENTRY(jobject, jni_NewObjectA(JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args))
JNIWrapper("NewObjectA");
!
HOTSPOT_JNI_NEWOBJECTA_ENTRY(env, clazz, (uintptr_t) methodID);
!
jobject obj = NULL;
DT_RETURN_MARK(NewObjectA, jobject, (const jobject)obj);
instanceOop i = alloc_object(clazz, CHECK_NULL);
obj = JNIHandles::make_local(env, i);
*** 1415,1438 ****
JNI_ArgumentPusherArray ap(methodID, args);
jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK_NULL);
return obj;
JNI_END
! #ifndef USDT2
! DT_RETURN_MARK_DECL(NewObjectV, jobject);
! #else /* USDT2 */
DT_RETURN_MARK_DECL(NewObjectV, jobject
, HOTSPOT_JNI_NEWOBJECTV_RETURN(_ret_ref));
- #endif /* USDT2 */
JNI_ENTRY(jobject, jni_NewObjectV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args))
JNIWrapper("NewObjectV");
! #ifndef USDT2
! DTRACE_PROBE3(hotspot_jni, NewObjectV__entry, env, clazz, methodID);
! #else /* USDT2 */
HOTSPOT_JNI_NEWOBJECTV_ENTRY(env, clazz, (uintptr_t) methodID);
! #endif /* USDT2 */
jobject obj = NULL;
DT_RETURN_MARK(NewObjectV, jobject, (const jobject&)obj);
instanceOop i = alloc_object(clazz, CHECK_NULL);
obj = JNIHandles::make_local(env, i);
--- 1243,1261 ----
JNI_ArgumentPusherArray ap(methodID, args);
jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK_NULL);
return obj;
JNI_END
!
DT_RETURN_MARK_DECL(NewObjectV, jobject
, HOTSPOT_JNI_NEWOBJECTV_RETURN(_ret_ref));
JNI_ENTRY(jobject, jni_NewObjectV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args))
JNIWrapper("NewObjectV");
!
HOTSPOT_JNI_NEWOBJECTV_ENTRY(env, clazz, (uintptr_t) methodID);
!
jobject obj = NULL;
DT_RETURN_MARK(NewObjectV, jobject, (const jobject&)obj);
instanceOop i = alloc_object(clazz, CHECK_NULL);
obj = JNIHandles::make_local(env, i);
*** 1440,1463 ****
JNI_ArgumentPusherVaArg ap(methodID, args);
jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK_NULL);
return obj;
JNI_END
! #ifndef USDT2
! DT_RETURN_MARK_DECL(NewObject, jobject);
! #else /* USDT2 */
DT_RETURN_MARK_DECL(NewObject, jobject
, HOTSPOT_JNI_NEWOBJECT_RETURN(_ret_ref));
- #endif /* USDT2 */
JNI_ENTRY(jobject, jni_NewObject(JNIEnv *env, jclass clazz, jmethodID methodID, ...))
JNIWrapper("NewObject");
! #ifndef USDT2
! DTRACE_PROBE3(hotspot_jni, NewObject__entry, env, clazz, methodID);
! #else /* USDT2 */
HOTSPOT_JNI_NEWOBJECT_ENTRY(env, clazz, (uintptr_t) methodID);
! #endif /* USDT2 */
jobject obj = NULL;
DT_RETURN_MARK(NewObject, jobject, (const jobject&)obj);
instanceOop i = alloc_object(clazz, CHECK_NULL);
obj = JNIHandles::make_local(env, i);
--- 1263,1281 ----
JNI_ArgumentPusherVaArg ap(methodID, args);
jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK_NULL);
return obj;
JNI_END
!
DT_RETURN_MARK_DECL(NewObject, jobject
, HOTSPOT_JNI_NEWOBJECT_RETURN(_ret_ref));
JNI_ENTRY(jobject, jni_NewObject(JNIEnv *env, jclass clazz, jmethodID methodID, ...))
JNIWrapper("NewObject");
!
HOTSPOT_JNI_NEWOBJECT_ENTRY(env, clazz, (uintptr_t) methodID);
!
jobject obj = NULL;
DT_RETURN_MARK(NewObject, jobject, (const jobject&)obj);
instanceOop i = alloc_object(clazz, CHECK_NULL);
obj = JNIHandles::make_local(env, i);
*** 1471,1517 ****
JNI_END
JNI_ENTRY(jclass, jni_GetObjectClass(JNIEnv *env, jobject obj))
JNIWrapper("GetObjectClass");
! #ifndef USDT2
! DTRACE_PROBE2(hotspot_jni, GetObjectClass__entry, env, obj);
! #else /* USDT2 */
HOTSPOT_JNI_GETOBJECTCLASS_ENTRY(env, obj);
! #endif /* USDT2 */
Klass* k = JNIHandles::resolve_non_null(obj)->klass();
jclass ret =
(jclass) JNIHandles::make_local(env, k->java_mirror());
! #ifndef USDT2
! DTRACE_PROBE1(hotspot_jni, GetObjectClass__return, ret);
! #else /* USDT2 */
HOTSPOT_JNI_GETOBJECTCLASS_RETURN(ret);
- #endif /* USDT2 */
return ret;
JNI_END
JNI_QUICK_ENTRY(jboolean, jni_IsInstanceOf(JNIEnv *env, jobject obj, jclass clazz))
JNIWrapper("IsInstanceOf");
! #ifndef USDT2
! DTRACE_PROBE3(hotspot_jni, IsInstanceOf__entry, env, obj, clazz);
! #else /* USDT2 */
HOTSPOT_JNI_ISINSTANCEOF_ENTRY(env, obj, clazz);
! #endif /* USDT2 */
jboolean ret = JNI_TRUE;
if (obj != NULL) {
ret = JNI_FALSE;
Klass* k = java_lang_Class::as_Klass(
JNIHandles::resolve_non_null(clazz));
if (k != NULL) {
ret = JNIHandles::resolve_non_null(obj)->is_a(k) ? JNI_TRUE : JNI_FALSE;
}
}
! #ifndef USDT2
! DTRACE_PROBE1(hotspot_jni, IsInstanceOf__return, ret);
! #else /* USDT2 */
HOTSPOT_JNI_ISINSTANCEOF_RETURN(ret);
- #endif /* USDT2 */
return ret;
JNI_END
static jmethodID get_method_id(JNIEnv *env, jclass clazz, const char *name_str,
--- 1289,1325 ----
JNI_END
JNI_ENTRY(jclass, jni_GetObjectClass(JNIEnv *env, jobject obj))
JNIWrapper("GetObjectClass");
!
HOTSPOT_JNI_GETOBJECTCLASS_ENTRY(env, obj);
!
Klass* k = JNIHandles::resolve_non_null(obj)->klass();
jclass ret =
(jclass) JNIHandles::make_local(env, k->java_mirror());
!
HOTSPOT_JNI_GETOBJECTCLASS_RETURN(ret);
return ret;
JNI_END
JNI_QUICK_ENTRY(jboolean, jni_IsInstanceOf(JNIEnv *env, jobject obj, jclass clazz))
JNIWrapper("IsInstanceOf");
!
HOTSPOT_JNI_ISINSTANCEOF_ENTRY(env, obj, clazz);
!
jboolean ret = JNI_TRUE;
if (obj != NULL) {
ret = JNI_FALSE;
Klass* k = java_lang_Class::as_Klass(
JNIHandles::resolve_non_null(clazz));
if (k != NULL) {
ret = JNIHandles::resolve_non_null(obj)->is_a(k) ? JNI_TRUE : JNI_FALSE;
}
}
!
HOTSPOT_JNI_ISINSTANCEOF_RETURN(ret);
return ret;
JNI_END
static jmethodID get_method_id(JNIEnv *env, jclass clazz, const char *name_str,
*** 1567,1690 ****
JNI_ENTRY(jmethodID, jni_GetMethodID(JNIEnv *env, jclass clazz,
const char *name, const char *sig))
JNIWrapper("GetMethodID");
- #ifndef USDT2
- DTRACE_PROBE4(hotspot_jni, GetMethodID__entry, env, clazz, name, sig);
- #else /* USDT2 */
HOTSPOT_JNI_GETMETHODID_ENTRY(env, clazz, (char *) name, (char *) sig);
- #endif /* USDT2 */
jmethodID ret = get_method_id(env, clazz, name, sig, false, thread);
- #ifndef USDT2
- DTRACE_PROBE1(hotspot_jni, GetMethodID__return, ret);
- #else /* USDT2 */
HOTSPOT_JNI_GETMETHODID_RETURN((uintptr_t) ret);
- #endif /* USDT2 */
return ret;
JNI_END
JNI_ENTRY(jmethodID, jni_GetStaticMethodID(JNIEnv *env, jclass clazz,
const char *name, const char *sig))
JNIWrapper("GetStaticMethodID");
- #ifndef USDT2
- DTRACE_PROBE4(hotspot_jni, GetStaticMethodID__entry, env, clazz, name, sig);
- #else /* USDT2 */
HOTSPOT_JNI_GETSTATICMETHODID_ENTRY(env, (char *) clazz, (char *) name, (char *)sig);
- #endif /* USDT2 */
jmethodID ret = get_method_id(env, clazz, name, sig, true, thread);
- #ifndef USDT2
- DTRACE_PROBE1(hotspot_jni, GetStaticMethodID__return, ret);
- #else /* USDT2 */
HOTSPOT_JNI_GETSTATICMETHODID_RETURN((uintptr_t) ret);
- #endif /* USDT2 */
return ret;
JNI_END
//
// Calling Methods
//
- #ifndef USDT2
- #define DEFINE_CALLMETHOD(ResultType, Result, Tag) \
- \
- DT_RETURN_MARK_DECL_FOR(Result, Call##Result##Method, ResultType);\
- DT_RETURN_MARK_DECL_FOR(Result, Call##Result##MethodV, ResultType);\
- DT_RETURN_MARK_DECL_FOR(Result, Call##Result##MethodA, ResultType);\
- \
- JNI_ENTRY(ResultType, \
- jni_Call##Result##Method(JNIEnv *env, jobject obj, jmethodID methodID, ...)) \
- JNIWrapper("Call" XSTR(Result) "Method"); \
- \
- DTRACE_PROBE3(hotspot_jni, Call##Result##Method__entry, env, obj, methodID); \
- ResultType ret = 0;\
- DT_RETURN_MARK_FOR(Result, Call##Result##Method, ResultType, \
- (const ResultType&)ret);\
- \
- va_list args; \
- va_start(args, methodID); \
- JavaValue jvalue(Tag); \
- JNI_ArgumentPusherVaArg ap(methodID, args); \
- jni_invoke_nonstatic(env, &jvalue, obj, JNI_VIRTUAL, methodID, &ap, CHECK_0); \
- va_end(args); \
- ret = jvalue.get_##ResultType(); \
- return ret;\
- JNI_END \
- \
- \
- JNI_ENTRY(ResultType, \
- jni_Call##Result##MethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)) \
- JNIWrapper("Call" XSTR(Result) "MethodV"); \
- \
- DTRACE_PROBE3(hotspot_jni, Call##Result##MethodV__entry, env, obj, methodID); \
- ResultType ret = 0;\
- DT_RETURN_MARK_FOR(Result, Call##Result##MethodV, ResultType, \
- (const ResultType&)ret);\
- \
- JavaValue jvalue(Tag); \
- JNI_ArgumentPusherVaArg ap(methodID, args); \
- jni_invoke_nonstatic(env, &jvalue, obj, JNI_VIRTUAL, methodID, &ap, CHECK_0); \
- ret = jvalue.get_##ResultType(); \
- return ret;\
- JNI_END \
- \
- \
- JNI_ENTRY(ResultType, \
- jni_Call##Result##MethodA(JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args)) \
- JNIWrapper("Call" XSTR(Result) "MethodA"); \
- DTRACE_PROBE3(hotspot_jni, Call##Result##MethodA__entry, env, obj, methodID); \
- ResultType ret = 0;\
- DT_RETURN_MARK_FOR(Result, Call##Result##MethodA, ResultType, \
- (const ResultType&)ret);\
- \
- JavaValue jvalue(Tag); \
- JNI_ArgumentPusherArray ap(methodID, args); \
- jni_invoke_nonstatic(env, &jvalue, obj, JNI_VIRTUAL, methodID, &ap, CHECK_0); \
- ret = jvalue.get_##ResultType(); \
- return ret;\
- JNI_END
-
- // the runtime type of subword integral basic types is integer
- DEFINE_CALLMETHOD(jboolean, Boolean, T_BOOLEAN)
- DEFINE_CALLMETHOD(jbyte, Byte, T_BYTE)
- DEFINE_CALLMETHOD(jchar, Char, T_CHAR)
- DEFINE_CALLMETHOD(jshort, Short, T_SHORT)
-
- DEFINE_CALLMETHOD(jobject, Object, T_OBJECT)
- DEFINE_CALLMETHOD(jint, Int, T_INT)
- DEFINE_CALLMETHOD(jlong, Long, T_LONG)
- DEFINE_CALLMETHOD(jfloat, Float, T_FLOAT)
- DEFINE_CALLMETHOD(jdouble, Double, T_DOUBLE)
-
- DT_VOID_RETURN_MARK_DECL(CallVoidMethod);
- DT_VOID_RETURN_MARK_DECL(CallVoidMethodV);
- DT_VOID_RETURN_MARK_DECL(CallVoidMethodA);
-
- #else /* USDT2 */
#define DEFINE_CALLMETHOD(ResultType, Result, Tag \
, EntryProbe, ReturnProbe) \
\
DT_RETURN_MARK_DECL_FOR(Result, Call##Result##Method, ResultType \
--- 1375,1406 ----
*** 1847,1865 ****
DT_VOID_RETURN_MARK_DECL(CallVoidMethod, HOTSPOT_JNI_CALLVOIDMETHOD_RETURN());
DT_VOID_RETURN_MARK_DECL(CallVoidMethodV, HOTSPOT_JNI_CALLVOIDMETHODV_RETURN());
DT_VOID_RETURN_MARK_DECL(CallVoidMethodA, HOTSPOT_JNI_CALLVOIDMETHODA_RETURN());
- #endif /* USDT2 */
JNI_ENTRY(void, jni_CallVoidMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...))
JNIWrapper("CallVoidMethod");
- #ifndef USDT2
- DTRACE_PROBE3(hotspot_jni, CallVoidMethod__entry, env, obj, methodID);
- #else /* USDT2 */
HOTSPOT_JNI_CALLVOIDMETHOD_ENTRY(env, obj, (uintptr_t) methodID);
- #endif /* USDT2 */
DT_VOID_RETURN_MARK(CallVoidMethod);
va_list args;
va_start(args, methodID);
JavaValue jvalue(T_VOID);
--- 1563,1576 ----
*** 1869,1980 ****
JNI_END
JNI_ENTRY(void, jni_CallVoidMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args))
JNIWrapper("CallVoidMethodV");
- #ifndef USDT2
- DTRACE_PROBE3(hotspot_jni, CallVoidMethodV__entry, env, obj, methodID);
- #else /* USDT2 */
HOTSPOT_JNI_CALLVOIDMETHODV_ENTRY(env, obj, (uintptr_t) methodID);
- #endif /* USDT2 */
DT_VOID_RETURN_MARK(CallVoidMethodV);
JavaValue jvalue(T_VOID);
JNI_ArgumentPusherVaArg ap(methodID, args);
jni_invoke_nonstatic(env, &jvalue, obj, JNI_VIRTUAL, methodID, &ap, CHECK);
JNI_END
JNI_ENTRY(void, jni_CallVoidMethodA(JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args))
JNIWrapper("CallVoidMethodA");
- #ifndef USDT2
- DTRACE_PROBE3(hotspot_jni, CallVoidMethodA__entry, env, obj, methodID);
- #else /* USDT2 */
HOTSPOT_JNI_CALLVOIDMETHODA_ENTRY(env, obj, (uintptr_t) methodID);
- #endif /* USDT2 */
DT_VOID_RETURN_MARK(CallVoidMethodA);
JavaValue jvalue(T_VOID);
JNI_ArgumentPusherArray ap(methodID, args);
jni_invoke_nonstatic(env, &jvalue, obj, JNI_VIRTUAL, methodID, &ap, CHECK);
JNI_END
- #ifndef USDT2
- #define DEFINE_CALLNONVIRTUALMETHOD(ResultType, Result, Tag) \
- \
- DT_RETURN_MARK_DECL_FOR(Result, CallNonvirtual##Result##Method, ResultType);\
- DT_RETURN_MARK_DECL_FOR(Result, CallNonvirtual##Result##MethodV, ResultType);\
- DT_RETURN_MARK_DECL_FOR(Result, CallNonvirtual##Result##MethodA, ResultType);\
- \
- JNI_ENTRY(ResultType, \
- jni_CallNonvirtual##Result##Method(JNIEnv *env, jobject obj, jclass cls, jmethodID methodID, ...)) \
- JNIWrapper("CallNonvitual" XSTR(Result) "Method"); \
- \
- DTRACE_PROBE4(hotspot_jni, CallNonvirtual##Result##Method__entry, env, obj, cls, methodID);\
- ResultType ret;\
- DT_RETURN_MARK_FOR(Result, CallNonvirtual##Result##Method, ResultType, \
- (const ResultType&)ret);\
- \
- va_list args; \
- va_start(args, methodID); \
- JavaValue jvalue(Tag); \
- JNI_ArgumentPusherVaArg ap(methodID, args); \
- jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK_0); \
- va_end(args); \
- ret = jvalue.get_##ResultType(); \
- return ret;\
- JNI_END \
- \
- JNI_ENTRY(ResultType, \
- jni_CallNonvirtual##Result##MethodV(JNIEnv *env, jobject obj, jclass cls, jmethodID methodID, va_list args)) \
- JNIWrapper("CallNonvitual" XSTR(Result) "#MethodV"); \
- DTRACE_PROBE4(hotspot_jni, CallNonvirtual##Result##MethodV__entry, env, obj, cls, methodID);\
- ResultType ret;\
- DT_RETURN_MARK_FOR(Result, CallNonvirtual##Result##MethodV, ResultType, \
- (const ResultType&)ret);\
- \
- JavaValue jvalue(Tag); \
- JNI_ArgumentPusherVaArg ap(methodID, args); \
- jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK_0); \
- ret = jvalue.get_##ResultType(); \
- return ret;\
- JNI_END \
- \
- JNI_ENTRY(ResultType, \
- jni_CallNonvirtual##Result##MethodA(JNIEnv *env, jobject obj, jclass cls, jmethodID methodID, const jvalue *args)) \
- JNIWrapper("CallNonvitual" XSTR(Result) "MethodA"); \
- DTRACE_PROBE4(hotspot_jni, CallNonvirtual##Result##MethodA__entry, env, obj, cls, methodID);\
- ResultType ret;\
- DT_RETURN_MARK_FOR(Result, CallNonvirtual##Result##MethodA, ResultType, \
- (const ResultType&)ret);\
- \
- JavaValue jvalue(Tag); \
- JNI_ArgumentPusherArray ap(methodID, args); \
- jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK_0); \
- ret = jvalue.get_##ResultType(); \
- return ret;\
- JNI_END
-
- // the runtime type of subword integral basic types is integer
- DEFINE_CALLNONVIRTUALMETHOD(jboolean, Boolean, T_BOOLEAN)
- DEFINE_CALLNONVIRTUALMETHOD(jbyte, Byte, T_BYTE)
- DEFINE_CALLNONVIRTUALMETHOD(jchar, Char, T_CHAR)
- DEFINE_CALLNONVIRTUALMETHOD(jshort, Short, T_SHORT)
-
- DEFINE_CALLNONVIRTUALMETHOD(jobject, Object, T_OBJECT)
- DEFINE_CALLNONVIRTUALMETHOD(jint, Int, T_INT)
- DEFINE_CALLNONVIRTUALMETHOD(jlong, Long, T_LONG)
- DEFINE_CALLNONVIRTUALMETHOD(jfloat, Float, T_FLOAT)
- DEFINE_CALLNONVIRTUALMETHOD(jdouble, Double, T_DOUBLE)
-
-
- DT_VOID_RETURN_MARK_DECL(CallNonvirtualVoidMethod);
- DT_VOID_RETURN_MARK_DECL(CallNonvirtualVoidMethodV);
- DT_VOID_RETURN_MARK_DECL(CallNonvirtualVoidMethodA);
-
- #else /* USDT2 */
#define DEFINE_CALLNONVIRTUALMETHOD(ResultType, Result, Tag \
, EntryProbe, ReturnProbe) \
\
DT_RETURN_MARK_DECL_FOR(Result, CallNonvirtual##Result##Method, ResultType \
--- 1580,1609 ----
*** 2140,2160 ****
, HOTSPOT_JNI_CALLNONVIRTUALVOIDMETHOD_RETURN());
DT_VOID_RETURN_MARK_DECL(CallNonvirtualVoidMethodV
, HOTSPOT_JNI_CALLNONVIRTUALVOIDMETHODV_RETURN());
DT_VOID_RETURN_MARK_DECL(CallNonvirtualVoidMethodA
, HOTSPOT_JNI_CALLNONVIRTUALVOIDMETHODA_RETURN());
- #endif /* USDT2 */
JNI_ENTRY(void, jni_CallNonvirtualVoidMethod(JNIEnv *env, jobject obj, jclass cls, jmethodID methodID, ...))
JNIWrapper("CallNonvirtualVoidMethod");
- #ifndef USDT2
- DTRACE_PROBE4(hotspot_jni, CallNonvirtualVoidMethod__entry,
- env, obj, cls, methodID);
- #else /* USDT2 */
HOTSPOT_JNI_CALLNONVIRTUALVOIDMETHOD_ENTRY(env, obj, cls, (uintptr_t) methodID);
- #endif /* USDT2 */
DT_VOID_RETURN_MARK(CallNonvirtualVoidMethod);
va_list args;
va_start(args, methodID);
JavaValue jvalue(T_VOID);
--- 1769,1783 ----
*** 2165,2279 ****
JNI_ENTRY(void, jni_CallNonvirtualVoidMethodV(JNIEnv *env, jobject obj, jclass cls, jmethodID methodID, va_list args))
JNIWrapper("CallNonvirtualVoidMethodV");
- #ifndef USDT2
- DTRACE_PROBE4(hotspot_jni, CallNonvirtualVoidMethodV__entry,
- env, obj, cls, methodID);
- #else /* USDT2 */
HOTSPOT_JNI_CALLNONVIRTUALVOIDMETHODV_ENTRY(
env, obj, cls, (uintptr_t) methodID);
- #endif /* USDT2 */
DT_VOID_RETURN_MARK(CallNonvirtualVoidMethodV);
JavaValue jvalue(T_VOID);
JNI_ArgumentPusherVaArg ap(methodID, args);
jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK);
JNI_END
JNI_ENTRY(void, jni_CallNonvirtualVoidMethodA(JNIEnv *env, jobject obj, jclass cls, jmethodID methodID, const jvalue *args))
JNIWrapper("CallNonvirtualVoidMethodA");
- #ifndef USDT2
- DTRACE_PROBE4(hotspot_jni, CallNonvirtualVoidMethodA__entry,
- env, obj, cls, methodID);
- #else /* USDT2 */
HOTSPOT_JNI_CALLNONVIRTUALVOIDMETHODA_ENTRY(
env, obj, cls, (uintptr_t) methodID);
- #endif /* USDT2 */
DT_VOID_RETURN_MARK(CallNonvirtualVoidMethodA);
JavaValue jvalue(T_VOID);
JNI_ArgumentPusherArray ap(methodID, args);
jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK);
JNI_END
- #ifndef USDT2
- #define DEFINE_CALLSTATICMETHOD(ResultType, Result, Tag) \
- \
- DT_RETURN_MARK_DECL_FOR(Result, CallStatic##Result##Method, ResultType);\
- DT_RETURN_MARK_DECL_FOR(Result, CallStatic##Result##MethodV, ResultType);\
- DT_RETURN_MARK_DECL_FOR(Result, CallStatic##Result##MethodA, ResultType);\
- \
- JNI_ENTRY(ResultType, \
- jni_CallStatic##Result##Method(JNIEnv *env, jclass cls, jmethodID methodID, ...)) \
- JNIWrapper("CallStatic" XSTR(Result) "Method"); \
- \
- DTRACE_PROBE3(hotspot_jni, CallStatic##Result##Method__entry, env, cls, methodID);\
- ResultType ret = 0;\
- DT_RETURN_MARK_FOR(Result, CallStatic##Result##Method, ResultType, \
- (const ResultType&)ret);\
- \
- va_list args; \
- va_start(args, methodID); \
- JavaValue jvalue(Tag); \
- JNI_ArgumentPusherVaArg ap(methodID, args); \
- jni_invoke_static(env, &jvalue, NULL, JNI_STATIC, methodID, &ap, CHECK_0); \
- va_end(args); \
- ret = jvalue.get_##ResultType(); \
- return ret;\
- JNI_END \
- \
- JNI_ENTRY(ResultType, \
- jni_CallStatic##Result##MethodV(JNIEnv *env, jclass cls, jmethodID methodID, va_list args)) \
- JNIWrapper("CallStatic" XSTR(Result) "MethodV"); \
- DTRACE_PROBE3(hotspot_jni, CallStatic##Result##MethodV__entry, env, cls, methodID);\
- ResultType ret = 0;\
- DT_RETURN_MARK_FOR(Result, CallStatic##Result##MethodV, ResultType, \
- (const ResultType&)ret);\
- \
- JavaValue jvalue(Tag); \
- JNI_ArgumentPusherVaArg ap(methodID, args); \
- jni_invoke_static(env, &jvalue, NULL, JNI_STATIC, methodID, &ap, CHECK_0); \
- ret = jvalue.get_##ResultType(); \
- return ret;\
- JNI_END \
- \
- JNI_ENTRY(ResultType, \
- jni_CallStatic##Result##MethodA(JNIEnv *env, jclass cls, jmethodID methodID, const jvalue *args)) \
- JNIWrapper("CallStatic" XSTR(Result) "MethodA"); \
- DTRACE_PROBE3(hotspot_jni, CallStatic##Result##MethodA__entry, env, cls, methodID);\
- ResultType ret = 0;\
- DT_RETURN_MARK_FOR(Result, CallStatic##Result##MethodA, ResultType, \
- (const ResultType&)ret);\
- \
- JavaValue jvalue(Tag); \
- JNI_ArgumentPusherArray ap(methodID, args); \
- jni_invoke_static(env, &jvalue, NULL, JNI_STATIC, methodID, &ap, CHECK_0); \
- ret = jvalue.get_##ResultType(); \
- return ret;\
- JNI_END
-
- // the runtime type of subword integral basic types is integer
- DEFINE_CALLSTATICMETHOD(jboolean, Boolean, T_BOOLEAN)
- DEFINE_CALLSTATICMETHOD(jbyte, Byte, T_BYTE)
- DEFINE_CALLSTATICMETHOD(jchar, Char, T_CHAR)
- DEFINE_CALLSTATICMETHOD(jshort, Short, T_SHORT)
-
- DEFINE_CALLSTATICMETHOD(jobject, Object, T_OBJECT)
- DEFINE_CALLSTATICMETHOD(jint, Int, T_INT)
- DEFINE_CALLSTATICMETHOD(jlong, Long, T_LONG)
- DEFINE_CALLSTATICMETHOD(jfloat, Float, T_FLOAT)
- DEFINE_CALLSTATICMETHOD(jdouble, Double, T_DOUBLE)
-
-
- DT_VOID_RETURN_MARK_DECL(CallStaticVoidMethod);
- DT_VOID_RETURN_MARK_DECL(CallStaticVoidMethodV);
- DT_VOID_RETURN_MARK_DECL(CallStaticVoidMethodA);
-
- #else /* USDT2 */
#define DEFINE_CALLSTATICMETHOD(ResultType, Result, Tag \
, EntryProbe, ResultProbe) \
\
DT_RETURN_MARK_DECL_FOR(Result, CallStatic##Result##Method, ResultType \
--- 1788,1818 ----
*** 2443,2461 ****
, HOTSPOT_JNI_CALLSTATICVOIDMETHOD_RETURN());
DT_VOID_RETURN_MARK_DECL(CallStaticVoidMethodV
, HOTSPOT_JNI_CALLSTATICVOIDMETHODV_RETURN());
DT_VOID_RETURN_MARK_DECL(CallStaticVoidMethodA
, HOTSPOT_JNI_CALLSTATICVOIDMETHODA_RETURN());
- #endif /* USDT2 */
JNI_ENTRY(void, jni_CallStaticVoidMethod(JNIEnv *env, jclass cls, jmethodID methodID, ...))
JNIWrapper("CallStaticVoidMethod");
- #ifndef USDT2
- DTRACE_PROBE3(hotspot_jni, CallStaticVoidMethod__entry, env, cls, methodID);
- #else /* USDT2 */
HOTSPOT_JNI_CALLSTATICVOIDMETHOD_ENTRY(env, cls, (uintptr_t) methodID);
- #endif /* USDT2 */
DT_VOID_RETURN_MARK(CallStaticVoidMethod);
va_list args;
va_start(args, methodID);
JavaValue jvalue(T_VOID);
--- 1982,1995 ----
*** 2465,2494 ****
JNI_END
JNI_ENTRY(void, jni_CallStaticVoidMethodV(JNIEnv *env, jclass cls, jmethodID methodID, va_list args))
JNIWrapper("CallStaticVoidMethodV");
- #ifndef USDT2
- DTRACE_PROBE3(hotspot_jni, CallStaticVoidMethodV__entry, env, cls, methodID);
- #else /* USDT2 */
HOTSPOT_JNI_CALLSTATICVOIDMETHODV_ENTRY(env, cls, (uintptr_t) methodID);
- #endif /* USDT2 */
DT_VOID_RETURN_MARK(CallStaticVoidMethodV);
JavaValue jvalue(T_VOID);
JNI_ArgumentPusherVaArg ap(methodID, args);
jni_invoke_static(env, &jvalue, NULL, JNI_STATIC, methodID, &ap, CHECK);
JNI_END
JNI_ENTRY(void, jni_CallStaticVoidMethodA(JNIEnv *env, jclass cls, jmethodID methodID, const jvalue *args))
JNIWrapper("CallStaticVoidMethodA");
- #ifndef USDT2
- DTRACE_PROBE3(hotspot_jni, CallStaticVoidMethodA__entry, env, cls, methodID);
- #else /* USDT2 */
HOTSPOT_JNI_CALLSTATICVOIDMETHODA_ENTRY(env, cls, (uintptr_t) methodID);
- #endif /* USDT2 */
DT_VOID_RETURN_MARK(CallStaticVoidMethodA);
JavaValue jvalue(T_VOID);
JNI_ArgumentPusherArray ap(methodID, args);
jni_invoke_static(env, &jvalue, NULL, JNI_STATIC, methodID, &ap, CHECK);
--- 1999,2020 ----
*** 2498,2522 ****
//
// Accessing Fields
//
- #ifndef USDT2
- DT_RETURN_MARK_DECL(GetFieldID, jfieldID);
- #else /* USDT2 */
DT_RETURN_MARK_DECL(GetFieldID, jfieldID
, HOTSPOT_JNI_GETFIELDID_RETURN((uintptr_t)_ret_ref));
- #endif /* USDT2 */
JNI_ENTRY(jfieldID, jni_GetFieldID(JNIEnv *env, jclass clazz,
const char *name, const char *sig))
JNIWrapper("GetFieldID");
- #ifndef USDT2
- DTRACE_PROBE4(hotspot_jni, GetFieldID__entry, env, clazz, name, sig);
- #else /* USDT2 */
HOTSPOT_JNI_GETFIELDID_ENTRY(env, clazz, (char *) name, (char *) sig);
- #endif /* USDT2 */
jfieldID ret = 0;
DT_RETURN_MARK(GetFieldID, jfieldID, (const jfieldID&)ret);
// The class should have been loaded (we have an instance of the class
// passed in) so the field and signature should already be in the symbol
--- 2024,2040 ----
*** 2544,2558 ****
JNI_END
JNI_ENTRY(jobject, jni_GetObjectField(JNIEnv *env, jobject obj, jfieldID fieldID))
JNIWrapper("GetObjectField");
- #ifndef USDT2
- DTRACE_PROBE3(hotspot_jni, GetObjectField__entry, env, obj, fieldID);
- #else /* USDT2 */
HOTSPOT_JNI_GETOBJECTFIELD_ENTRY(env, obj, (uintptr_t) fieldID);
- #endif /* USDT2 */
oop o = JNIHandles::resolve_non_null(obj);
Klass* k = o->klass();
int offset = jfieldIDWorkaround::from_instance_jfieldID(k, fieldID);
// Keep JVMTI addition small and only check enabled flag here.
// jni_GetField_probe() assumes that is okay to create handles.
--- 2062,2072 ----
*** 2578,2631 ****
oop referent = JNIHandles::resolve(ret);
G1SATBCardTableModRefBS::enqueue(referent);
}
}
#endif // INCLUDE_ALL_GCS
- #ifndef USDT2
- DTRACE_PROBE1(hotspot_jni, GetObjectField__return, ret);
- #else /* USDT2 */
HOTSPOT_JNI_GETOBJECTFIELD_RETURN(ret);
- #endif /* USDT2 */
return ret;
JNI_END
- #ifndef USDT2
- #define DEFINE_GETFIELD(Return,Fieldname,Result) \
- \
- DT_RETURN_MARK_DECL_FOR(Result, Get##Result##Field, Return);\
- \
- JNI_QUICK_ENTRY(Return, jni_Get##Result##Field(JNIEnv *env, jobject obj, jfieldID fieldID)) \
- JNIWrapper("Get" XSTR(Result) "Field"); \
- \
- DTRACE_PROBE3(hotspot_jni, Get##Result##Field__entry, env, obj, fieldID);\
- Return ret = 0;\
- DT_RETURN_MARK_FOR(Result, Get##Result##Field, Return, (const Return&)ret);\
- \
- oop o = JNIHandles::resolve_non_null(obj); \
- Klass* k = o->klass(); \
- int offset = jfieldIDWorkaround::from_instance_jfieldID(k, fieldID); \
- /* Keep JVMTI addition small and only check enabled flag here. */ \
- /* jni_GetField_probe_nh() assumes that is not okay to create handles */ \
- /* and creates a ResetNoHandleMark. */ \
- if (JvmtiExport::should_post_field_access()) { \
- o = JvmtiExport::jni_GetField_probe_nh(thread, obj, o, k, fieldID, false); \
- } \
- ret = o->Fieldname##_field(offset); \
- return ret; \
- JNI_END
-
- DEFINE_GETFIELD(jboolean, bool, Boolean)
- DEFINE_GETFIELD(jbyte, byte, Byte)
- DEFINE_GETFIELD(jchar, char, Char)
- DEFINE_GETFIELD(jshort, short, Short)
- DEFINE_GETFIELD(jint, int, Int)
- DEFINE_GETFIELD(jlong, long, Long)
- DEFINE_GETFIELD(jfloat, float, Float)
- DEFINE_GETFIELD(jdouble, double, Double)
-
- #else /* USDT2 */
#define DEFINE_GETFIELD(Return,Fieldname,Result \
, EntryProbe, ReturnProbe) \
\
DT_RETURN_MARK_DECL_FOR(Result, Get##Result##Field, Return \
--- 2092,2106 ----
*** 2674,2684 ****
, HOTSPOT_JNI_GETFLOATFIELD_ENTRY(env, obj, (uintptr_t)fieldID),
HOTSPOT_JNI_GETFLOATFIELD_RETURN())
DEFINE_GETFIELD(jdouble, double, Double
, HOTSPOT_JNI_GETDOUBLEFIELD_ENTRY(env, obj, (uintptr_t)fieldID),
HOTSPOT_JNI_GETDOUBLEFIELD_RETURN())
- #endif /* USDT2 */
address jni_GetBooleanField_addr() {
return (address)jni_GetBooleanField;
}
address jni_GetByteField_addr() {
--- 2149,2158 ----
*** 2703,2717 ****
return (address)jni_GetDoubleField;
}
JNI_QUICK_ENTRY(void, jni_SetObjectField(JNIEnv *env, jobject obj, jfieldID fieldID, jobject value))
JNIWrapper("SetObjectField");
- #ifndef USDT2
- DTRACE_PROBE4(hotspot_jni, SetObjectField__entry, env, obj, fieldID, value);
- #else /* USDT2 */
HOTSPOT_JNI_SETOBJECTFIELD_ENTRY(env, obj, (uintptr_t) fieldID, value);
- #endif /* USDT2 */
oop o = JNIHandles::resolve_non_null(obj);
Klass* k = o->klass();
int offset = jfieldIDWorkaround::from_instance_jfieldID(k, fieldID);
// Keep JVMTI addition small and only check enabled flag here.
// jni_SetField_probe_nh() assumes that is not okay to create handles
--- 2177,2187 ----
*** 2720,2771 ****
jvalue field_value;
field_value.l = value;
o = JvmtiExport::jni_SetField_probe_nh(thread, obj, o, k, fieldID, false, 'L', (jvalue *)&field_value);
}
o->obj_field_put(offset, JNIHandles::resolve(value));
- #ifndef USDT2
- DTRACE_PROBE(hotspot_jni, SetObjectField__return);
- #else /* USDT2 */
HOTSPOT_JNI_SETOBJECTFIELD_RETURN();
- #endif /* USDT2 */
- JNI_END
-
- #ifndef USDT2
- #define DEFINE_SETFIELD(Argument,Fieldname,Result,SigType,unionType) \
- \
- JNI_QUICK_ENTRY(void, jni_Set##Result##Field(JNIEnv *env, jobject obj, jfieldID fieldID, Argument value)) \
- JNIWrapper("Set" XSTR(Result) "Field"); \
- \
- FP_SELECT_##Result( \
- DTRACE_PROBE4(hotspot_jni, Set##Result##Field__entry, env, obj, fieldID, value), \
- DTRACE_PROBE3(hotspot_jni, Set##Result##Field__entry, env, obj, fieldID)); \
- \
- oop o = JNIHandles::resolve_non_null(obj); \
- Klass* k = o->klass(); \
- int offset = jfieldIDWorkaround::from_instance_jfieldID(k, fieldID); \
- /* Keep JVMTI addition small and only check enabled flag here. */ \
- /* jni_SetField_probe_nh() assumes that is not okay to create handles */ \
- /* and creates a ResetNoHandleMark. */ \
- if (JvmtiExport::should_post_field_modification()) { \
- jvalue field_value; \
- field_value.unionType = value; \
- o = JvmtiExport::jni_SetField_probe_nh(thread, obj, o, k, fieldID, false, SigType, (jvalue *)&field_value); \
- } \
- o->Fieldname##_field_put(offset, value); \
- DTRACE_PROBE(hotspot_jni, Set##Result##Field__return);\
JNI_END
- DEFINE_SETFIELD(jboolean, bool, Boolean, 'Z', z)
- DEFINE_SETFIELD(jbyte, byte, Byte, 'B', b)
- DEFINE_SETFIELD(jchar, char, Char, 'C', c)
- DEFINE_SETFIELD(jshort, short, Short, 'S', s)
- DEFINE_SETFIELD(jint, int, Int, 'I', i)
- DEFINE_SETFIELD(jlong, long, Long, 'J', j)
- DEFINE_SETFIELD(jfloat, float, Float, 'F', f)
- DEFINE_SETFIELD(jdouble, double, Double, 'D', d)
-
- #else /* USDT2 */
#define DEFINE_SETFIELD(Argument,Fieldname,Result,SigType,unionType \
, EntryProbe, ReturnProbe) \
\
JNI_QUICK_ENTRY(void, jni_Set##Result##Field(JNIEnv *env, jobject obj, jfieldID fieldID, Argument value)) \
--- 2190,2202 ----
*** 2811,2837 ****
, HOTSPOT_JNI_SETFLOATFIELD_ENTRY(env, obj, (uintptr_t)fieldID),
HOTSPOT_JNI_SETFLOATFIELD_RETURN())
DEFINE_SETFIELD(jdouble, double, Double, 'D', d
, HOTSPOT_JNI_SETDOUBLEFIELD_ENTRY(env, obj, (uintptr_t)fieldID),
HOTSPOT_JNI_SETDOUBLEFIELD_RETURN())
- #endif /* USDT2 */
- #ifndef USDT2
- DT_RETURN_MARK_DECL(ToReflectedField, jobject);
- #else /* USDT2 */
DT_RETURN_MARK_DECL(ToReflectedField, jobject
, HOTSPOT_JNI_TOREFLECTEDFIELD_RETURN(_ret_ref));
- #endif /* USDT2 */
JNI_ENTRY(jobject, jni_ToReflectedField(JNIEnv *env, jclass cls, jfieldID fieldID, jboolean isStatic))
JNIWrapper("ToReflectedField");
- #ifndef USDT2
- DTRACE_PROBE4(hotspot_jni, ToReflectedField__entry,
- env, cls, fieldID, isStatic);
- #else /* USDT2 */
HOTSPOT_JNI_TOREFLECTEDFIELD_ENTRY(env, cls, (uintptr_t) fieldID, isStatic);
- #endif /* USDT2 */
jobject ret = NULL;
DT_RETURN_MARK(ToReflectedField, jobject, (const jobject&)ret);
fieldDescriptor fd;
bool found = false;
--- 2242,2258 ----
*** 2857,2881 ****
//
// Accessing Static Fields
//
- #ifndef USDT2
- DT_RETURN_MARK_DECL(GetStaticFieldID, jfieldID);
- #else /* USDT2 */
DT_RETURN_MARK_DECL(GetStaticFieldID, jfieldID
, HOTSPOT_JNI_GETSTATICFIELDID_RETURN((uintptr_t)_ret_ref));
- #endif /* USDT2 */
JNI_ENTRY(jfieldID, jni_GetStaticFieldID(JNIEnv *env, jclass clazz,
const char *name, const char *sig))
JNIWrapper("GetStaticFieldID");
- #ifndef USDT2
- DTRACE_PROBE4(hotspot_jni, GetStaticFieldID__entry, env, clazz, name, sig);
- #else /* USDT2 */
HOTSPOT_JNI_GETSTATICFIELDID_ENTRY(env, clazz, (char *) name, (char *) sig);
- #endif /* USDT2 */
jfieldID ret = NULL;
DT_RETURN_MARK(GetStaticFieldID, jfieldID, (const jfieldID&)ret);
// The class should have been loaded (we have an instance of the class
// passed in) so the field and signature should already be in the symbol
--- 2278,2294 ----
*** 2907,2921 ****
JNI_END
JNI_ENTRY(jobject, jni_GetStaticObjectField(JNIEnv *env, jclass clazz, jfieldID fieldID))
JNIWrapper("GetStaticObjectField");
- #ifndef USDT2
- DTRACE_PROBE3(hotspot_jni, GetStaticObjectField__entry, env, clazz, fieldID);
- #else /* USDT2 */
HOTSPOT_JNI_GETSTATICOBJECTFIELD_ENTRY(env, clazz, (uintptr_t) fieldID);
- #endif /* USDT2 */
#if INCLUDE_JNI_CHECK
DEBUG_ONLY(Klass* param_k = jniCheck::validate_class(thread, clazz);)
#endif // INCLUDE_JNI_CHECK
JNIid* id = jfieldIDWorkaround::from_static_jfieldID(fieldID);
assert(id->is_static_field_id(), "invalid static field id");
--- 2320,2330 ----
*** 2923,2972 ****
// jni_GetField_probe() assumes that is okay to create handles.
if (JvmtiExport::should_post_field_access()) {
JvmtiExport::jni_GetField_probe(thread, NULL, NULL, id->holder(), fieldID, true);
}
jobject ret = JNIHandles::make_local(id->holder()->java_mirror()->obj_field(id->offset()));
- #ifndef USDT2
- DTRACE_PROBE1(hotspot_jni, GetStaticObjectField__return, ret);
- #else /* USDT2 */
HOTSPOT_JNI_GETSTATICOBJECTFIELD_RETURN(ret);
- #endif /* USDT2 */
return ret;
JNI_END
- #ifndef USDT2
- #define DEFINE_GETSTATICFIELD(Return,Fieldname,Result) \
- \
- DT_RETURN_MARK_DECL_FOR(Result, GetStatic##Result##Field, Return);\
- \
- JNI_ENTRY(Return, jni_GetStatic##Result##Field(JNIEnv *env, jclass clazz, jfieldID fieldID)) \
- JNIWrapper("GetStatic" XSTR(Result) "Field"); \
- DTRACE_PROBE3(hotspot_jni, GetStatic##Result##Field__entry, env, clazz, fieldID);\
- Return ret = 0;\
- DT_RETURN_MARK_FOR(Result, GetStatic##Result##Field, Return, \
- (const Return&)ret);\
- JNIid* id = jfieldIDWorkaround::from_static_jfieldID(fieldID); \
- assert(id->is_static_field_id(), "invalid static field id"); \
- /* Keep JVMTI addition small and only check enabled flag here. */ \
- /* jni_GetField_probe() assumes that is okay to create handles. */ \
- if (JvmtiExport::should_post_field_access()) { \
- JvmtiExport::jni_GetField_probe(thread, NULL, NULL, id->holder(), fieldID, true); \
- } \
- ret = id->holder()->java_mirror()-> Fieldname##_field (id->offset()); \
- return ret;\
- JNI_END
-
- DEFINE_GETSTATICFIELD(jboolean, bool, Boolean)
- DEFINE_GETSTATICFIELD(jbyte, byte, Byte)
- DEFINE_GETSTATICFIELD(jchar, char, Char)
- DEFINE_GETSTATICFIELD(jshort, short, Short)
- DEFINE_GETSTATICFIELD(jint, int, Int)
- DEFINE_GETSTATICFIELD(jlong, long, Long)
- DEFINE_GETSTATICFIELD(jfloat, float, Float)
- DEFINE_GETSTATICFIELD(jdouble, double, Double)
-
- #else /* USDT2 */
#define DEFINE_GETSTATICFIELD(Return,Fieldname,Result \
, EntryProbe, ReturnProbe) \
\
DT_RETURN_MARK_DECL_FOR(Result, GetStatic##Result##Field, Return \
--- 2332,2345 ----
*** 3004,3072 ****
// Float and double probes don't return value because dtrace doesn't currently support it
DEFINE_GETSTATICFIELD(jfloat, float, Float
, HOTSPOT_JNI_GETSTATICFLOATFIELD_ENTRY(env, clazz, (uintptr_t) fieldID), HOTSPOT_JNI_GETSTATICFLOATFIELD_RETURN() )
DEFINE_GETSTATICFIELD(jdouble, double, Double
, HOTSPOT_JNI_GETSTATICDOUBLEFIELD_ENTRY(env, clazz, (uintptr_t) fieldID), HOTSPOT_JNI_GETSTATICDOUBLEFIELD_RETURN() )
- #endif /* USDT2 */
JNI_ENTRY(void, jni_SetStaticObjectField(JNIEnv *env, jclass clazz, jfieldID fieldID, jobject value))
JNIWrapper("SetStaticObjectField");
- #ifndef USDT2
- DTRACE_PROBE4(hotspot_jni, SetStaticObjectField__entry, env, clazz, fieldID, value);
- #else /* USDT2 */
HOTSPOT_JNI_SETSTATICOBJECTFIELD_ENTRY(env, clazz, (uintptr_t) fieldID, value);
- #endif /* USDT2 */
JNIid* id = jfieldIDWorkaround::from_static_jfieldID(fieldID);
assert(id->is_static_field_id(), "invalid static field id");
// Keep JVMTI addition small and only check enabled flag here.
// jni_SetField_probe() assumes that is okay to create handles.
if (JvmtiExport::should_post_field_modification()) {
jvalue field_value;
field_value.l = value;
JvmtiExport::jni_SetField_probe(thread, NULL, NULL, id->holder(), fieldID, true, 'L', (jvalue *)&field_value);
}
id->holder()->java_mirror()->obj_field_put(id->offset(), JNIHandles::resolve(value));
- #ifndef USDT2
- DTRACE_PROBE(hotspot_jni, SetStaticObjectField__return);
- #else /* USDT2 */
HOTSPOT_JNI_SETSTATICOBJECTFIELD_RETURN();
- #endif /* USDT2 */
- JNI_END
-
-
- #ifndef USDT2
- #define DEFINE_SETSTATICFIELD(Argument,Fieldname,Result,SigType,unionType) \
- \
- JNI_ENTRY(void, jni_SetStatic##Result##Field(JNIEnv *env, jclass clazz, jfieldID fieldID, Argument value)) \
- JNIWrapper("SetStatic" XSTR(Result) "Field"); \
- FP_SELECT_##Result( \
- DTRACE_PROBE4(hotspot_jni, SetStatic##Result##Field__entry, env, clazz, fieldID, value), \
- DTRACE_PROBE3(hotspot_jni, SetStatic##Result##Field__entry, env, clazz, fieldID)); \
- \
- JNIid* id = jfieldIDWorkaround::from_static_jfieldID(fieldID); \
- assert(id->is_static_field_id(), "invalid static field id"); \
- /* Keep JVMTI addition small and only check enabled flag here. */ \
- /* jni_SetField_probe() assumes that is okay to create handles. */ \
- if (JvmtiExport::should_post_field_modification()) { \
- jvalue field_value; \
- field_value.unionType = value; \
- JvmtiExport::jni_SetField_probe(thread, NULL, NULL, id->holder(), fieldID, true, SigType, (jvalue *)&field_value); \
- } \
- id->holder()->java_mirror()-> Fieldname##_field_put (id->offset(), value); \
- DTRACE_PROBE(hotspot_jni, SetStatic##Result##Field__return);\
JNI_END
- DEFINE_SETSTATICFIELD(jboolean, bool, Boolean, 'Z', z)
- DEFINE_SETSTATICFIELD(jbyte, byte, Byte, 'B', b)
- DEFINE_SETSTATICFIELD(jchar, char, Char, 'C', c)
- DEFINE_SETSTATICFIELD(jshort, short, Short, 'S', s)
- DEFINE_SETSTATICFIELD(jint, int, Int, 'I', i)
- DEFINE_SETSTATICFIELD(jlong, long, Long, 'J', j)
- DEFINE_SETSTATICFIELD(jfloat, float, Float, 'F', f)
- DEFINE_SETSTATICFIELD(jdouble, double, Double, 'D', d)
- #else /* USDT2 */
#define DEFINE_SETSTATICFIELD(Argument,Fieldname,Result,SigType,unionType \
, EntryProbe, ReturnProbe) \
\
JNI_ENTRY(void, jni_SetStatic##Result##Field(JNIEnv *env, jclass clazz, jfieldID fieldID, Argument value)) \
--- 2377,2404 ----
*** 3109,3177 ****
, HOTSPOT_JNI_SETSTATICFLOATFIELD_ENTRY(env, clazz, (uintptr_t) fieldID),
HOTSPOT_JNI_SETSTATICFLOATFIELD_RETURN())
DEFINE_SETSTATICFIELD(jdouble, double, Double, 'D', d
, HOTSPOT_JNI_SETSTATICDOUBLEFIELD_ENTRY(env, clazz, (uintptr_t) fieldID),
HOTSPOT_JNI_SETSTATICDOUBLEFIELD_RETURN())
- #endif /* USDT2 */
//
// String Operations
//
// Unicode Interface
- #ifndef USDT2
- DT_RETURN_MARK_DECL(NewString, jstring);
- #else /* USDT2 */
DT_RETURN_MARK_DECL(NewString, jstring
, HOTSPOT_JNI_NEWSTRING_RETURN(_ret_ref));
- #endif /* USDT2 */
JNI_ENTRY(jstring, jni_NewString(JNIEnv *env, const jchar *unicodeChars, jsize len))
JNIWrapper("NewString");
- #ifndef USDT2
- DTRACE_PROBE3(hotspot_jni, NewString__entry, env, unicodeChars, len);
- #else /* USDT2 */
HOTSPOT_JNI_NEWSTRING_ENTRY(env, (uint16_t *) unicodeChars, len);
- #endif /* USDT2 */
jstring ret = NULL;
DT_RETURN_MARK(NewString, jstring, (const jstring&)ret);
oop string=java_lang_String::create_oop_from_unicode((jchar*) unicodeChars, len, CHECK_NULL);
ret = (jstring) JNIHandles::make_local(env, string);
return ret;
JNI_END
JNI_QUICK_ENTRY(jsize, jni_GetStringLength(JNIEnv *env, jstring string))
JNIWrapper("GetStringLength");
- #ifndef USDT2
- DTRACE_PROBE2(hotspot_jni, GetStringLength__entry, env, string);
- #else /* USDT2 */
HOTSPOT_JNI_GETSTRINGLENGTH_ENTRY(env, string);
- #endif /* USDT2 */
jsize ret = 0;
oop s = JNIHandles::resolve_non_null(string);
if (java_lang_String::value(s) != NULL) {
ret = java_lang_String::length(s);
}
- #ifndef USDT2
- DTRACE_PROBE1(hotspot_jni, GetStringLength__return, ret);
- #else /* USDT2 */
HOTSPOT_JNI_GETSTRINGLENGTH_RETURN(ret);
- #endif /* USDT2 */
return ret;
JNI_END
JNI_QUICK_ENTRY(const jchar*, jni_GetStringChars(
JNIEnv *env, jstring string, jboolean *isCopy))
JNIWrapper("GetStringChars");
- #ifndef USDT2
- DTRACE_PROBE3(hotspot_jni, GetStringChars__entry, env, string, isCopy);
- #else /* USDT2 */
HOTSPOT_JNI_GETSTRINGCHARS_ENTRY(env, string, (uintptr_t *) isCopy);
- #endif /* USDT2 */
jchar* buf = NULL;
oop s = JNIHandles::resolve_non_null(string);
typeArrayOop s_value = java_lang_String::value(s);
if (s_value != NULL) {
int s_len = java_lang_String::length(s);
--- 2441,2488 ----
*** 3187,3242 ****
if (isCopy != NULL) {
*isCopy = JNI_TRUE;
}
}
}
- #ifndef USDT2
- DTRACE_PROBE1(hotspot_jni, GetStringChars__return, buf);
- #else /* USDT2 */
HOTSPOT_JNI_GETSTRINGCHARS_RETURN(buf);
- #endif /* USDT2 */
return buf;
JNI_END
JNI_QUICK_ENTRY(void, jni_ReleaseStringChars(JNIEnv *env, jstring str, const jchar *chars))
JNIWrapper("ReleaseStringChars");
- #ifndef USDT2
- DTRACE_PROBE3(hotspot_jni, ReleaseStringChars__entry, env, str, chars);
- #else /* USDT2 */
HOTSPOT_JNI_RELEASESTRINGCHARS_ENTRY(env, str, (uint16_t *) chars);
- #endif /* USDT2 */
//%note jni_6
if (chars != NULL) {
// Since String objects are supposed to be immutable, don't copy any
// new data back. A bad user will have to go after the char array.
FreeHeap((void*) chars);
}
- #ifndef USDT2
- DTRACE_PROBE(hotspot_jni, ReleaseStringChars__return);
- #else /* USDT2 */
HOTSPOT_JNI_RELEASESTRINGCHARS_RETURN();
- #endif /* USDT2 */
JNI_END
// UTF Interface
- #ifndef USDT2
- DT_RETURN_MARK_DECL(NewStringUTF, jstring);
- #else /* USDT2 */
DT_RETURN_MARK_DECL(NewStringUTF, jstring
, HOTSPOT_JNI_NEWSTRINGUTF_RETURN(_ret_ref));
- #endif /* USDT2 */
JNI_ENTRY(jstring, jni_NewStringUTF(JNIEnv *env, const char *bytes))
JNIWrapper("NewStringUTF");
- #ifndef USDT2
- DTRACE_PROBE2(hotspot_jni, NewStringUTF__entry, env, bytes);
- #else /* USDT2 */
HOTSPOT_JNI_NEWSTRINGUTF_ENTRY(env, (char *) bytes);
- #endif /* USDT2 */
jstring ret;
DT_RETURN_MARK(NewStringUTF, jstring, (const jstring&)ret);
oop result = java_lang_String::create_oop_from_str((char*) bytes, CHECK_NULL);
ret = (jstring) JNIHandles::make_local(env, result);
--- 2498,2533 ----
*** 3244,3279 ****
JNI_END
JNI_ENTRY(jsize, jni_GetStringUTFLength(JNIEnv *env, jstring string))
JNIWrapper("GetStringUTFLength");
- #ifndef USDT2
- DTRACE_PROBE2(hotspot_jni, GetStringUTFLength__entry, env, string);
- #else /* USDT2 */
HOTSPOT_JNI_GETSTRINGUTFLENGTH_ENTRY(env, string);
- #endif /* USDT2 */
jsize ret = 0;
oop java_string = JNIHandles::resolve_non_null(string);
if (java_lang_String::value(java_string) != NULL) {
ret = java_lang_String::utf8_length(java_string);
}
- #ifndef USDT2
- DTRACE_PROBE1(hotspot_jni, GetStringUTFLength__return, ret);
- #else /* USDT2 */
HOTSPOT_JNI_GETSTRINGUTFLENGTH_RETURN(ret);
- #endif /* USDT2 */
return ret;
JNI_END
JNI_ENTRY(const char*, jni_GetStringUTFChars(JNIEnv *env, jstring string, jboolean *isCopy))
JNIWrapper("GetStringUTFChars");
- #ifndef USDT2
- DTRACE_PROBE3(hotspot_jni, GetStringUTFChars__entry, env, string, isCopy);
- #else /* USDT2 */
HOTSPOT_JNI_GETSTRINGUTFCHARS_ENTRY(env, string, (uintptr_t *) isCopy);
- #endif /* USDT2 */
char* result = NULL;
oop java_string = JNIHandles::resolve_non_null(string);
if (java_lang_String::value(java_string) != NULL) {
size_t length = java_lang_String::utf8_length(java_string);
/* JNI Specification states return NULL on OOM */
--- 2535,2558 ----
*** 3283,3356 ****
if (isCopy != NULL) {
*isCopy = JNI_TRUE;
}
}
}
- #ifndef USDT2
- DTRACE_PROBE1(hotspot_jni, GetStringUTFChars__return, result);
- #else /* USDT2 */
HOTSPOT_JNI_GETSTRINGUTFCHARS_RETURN(result);
- #endif /* USDT2 */
return result;
JNI_END
JNI_LEAF(void, jni_ReleaseStringUTFChars(JNIEnv *env, jstring str, const char *chars))
JNIWrapper("ReleaseStringUTFChars");
- #ifndef USDT2
- DTRACE_PROBE3(hotspot_jni, ReleaseStringUTFChars__entry, env, str, chars);
- #else /* USDT2 */
HOTSPOT_JNI_RELEASESTRINGUTFCHARS_ENTRY(env, str, (char *) chars);
- #endif /* USDT2 */
if (chars != NULL) {
FreeHeap((char*) chars);
}
- #ifndef USDT2
- DTRACE_PROBE(hotspot_jni, ReleaseStringUTFChars__return);
- #else /* USDT2 */
HOTSPOT_JNI_RELEASESTRINGUTFCHARS_RETURN();
- #endif /* USDT2 */
JNI_END
JNI_QUICK_ENTRY(jsize, jni_GetArrayLength(JNIEnv *env, jarray array))
JNIWrapper("GetArrayLength");
- #ifndef USDT2
- DTRACE_PROBE2(hotspot_jni, GetArrayLength__entry, env, array);
- #else /* USDT2 */
HOTSPOT_JNI_GETARRAYLENGTH_ENTRY(env, array);
- #endif /* USDT2 */
arrayOop a = arrayOop(JNIHandles::resolve_non_null(array));
assert(a->is_array(), "must be array");
jsize ret = a->length();
- #ifndef USDT2
- DTRACE_PROBE1(hotspot_jni, GetArrayLength__return, ret);
- #else /* USDT2 */
HOTSPOT_JNI_GETARRAYLENGTH_RETURN(ret);
- #endif /* USDT2 */
return ret;
JNI_END
//
// Object Array Operations
//
- #ifndef USDT2
- DT_RETURN_MARK_DECL(NewObjectArray, jobjectArray);
- #else /* USDT2 */
DT_RETURN_MARK_DECL(NewObjectArray, jobjectArray
, HOTSPOT_JNI_NEWOBJECTARRAY_RETURN(_ret_ref));
- #endif /* USDT2 */
JNI_ENTRY(jobjectArray, jni_NewObjectArray(JNIEnv *env, jsize length, jclass elementClass, jobject initialElement))
JNIWrapper("NewObjectArray");
- #ifndef USDT2
- DTRACE_PROBE4(hotspot_jni, NewObjectArray__entry, env, length, elementClass, initialElement);
- #else /* USDT2 */
HOTSPOT_JNI_NEWOBJECTARRAY_ENTRY(env, length, elementClass, initialElement);
- #endif /* USDT2 */
jobjectArray ret = NULL;
DT_RETURN_MARK(NewObjectArray, jobjectArray, (const jobjectArray&)ret);
KlassHandle ek(THREAD, java_lang_Class::as_Klass(JNIHandles::resolve_non_null(elementClass)));
Klass* ako = ek()->array_klass(CHECK_NULL);
KlassHandle ak = KlassHandle(THREAD, ako);
--- 2562,2607 ----
*** 3364,3387 ****
}
ret = (jobjectArray) JNIHandles::make_local(env, result);
return ret;
JNI_END
- #ifndef USDT2
- DT_RETURN_MARK_DECL(GetObjectArrayElement, jobject);
- #else /* USDT2 */
DT_RETURN_MARK_DECL(GetObjectArrayElement, jobject
, HOTSPOT_JNI_GETOBJECTARRAYELEMENT_RETURN(_ret_ref));
- #endif /* USDT2 */
JNI_ENTRY(jobject, jni_GetObjectArrayElement(JNIEnv *env, jobjectArray array, jsize index))
JNIWrapper("GetObjectArrayElement");
- #ifndef USDT2
- DTRACE_PROBE3(hotspot_jni, GetObjectArrayElement__entry, env, array, index);
- #else /* USDT2 */
HOTSPOT_JNI_GETOBJECTARRAYELEMENT_ENTRY(env, array, index);
- #endif /* USDT2 */
jobject ret = NULL;
DT_RETURN_MARK(GetObjectArrayElement, jobject, (const jobject&)ret);
objArrayOop a = objArrayOop(JNIHandles::resolve_non_null(array));
if (a->is_within_bounds(index)) {
ret = JNIHandles::make_local(env, a->obj_at(index));
--- 2615,2630 ----
*** 3391,3414 ****
sprintf(buf, "%d", index);
THROW_MSG_0(vmSymbols::java_lang_ArrayIndexOutOfBoundsException(), buf);
}
JNI_END
- #ifndef USDT2
- DT_VOID_RETURN_MARK_DECL(SetObjectArrayElement);
- #else /* USDT2 */
DT_VOID_RETURN_MARK_DECL(SetObjectArrayElement
, HOTSPOT_JNI_SETOBJECTARRAYELEMENT_RETURN());
- #endif /* USDT2 */
JNI_ENTRY(void, jni_SetObjectArrayElement(JNIEnv *env, jobjectArray array, jsize index, jobject value))
JNIWrapper("SetObjectArrayElement");
- #ifndef USDT2
- DTRACE_PROBE4(hotspot_jni, SetObjectArrayElement__entry, env, array, index, value);
- #else /* USDT2 */
HOTSPOT_JNI_SETOBJECTARRAYELEMENT_ENTRY(env, array, index, value);
- #endif /* USDT2 */
DT_VOID_RETURN_MARK(SetObjectArrayElement);
objArrayOop a = objArrayOop(JNIHandles::resolve_non_null(array));
oop v = JNIHandles::resolve(value);
if (a->is_within_bounds(index)) {
--- 2634,2649 ----
*** 3423,3459 ****
THROW_MSG(vmSymbols::java_lang_ArrayIndexOutOfBoundsException(), buf);
}
JNI_END
- #ifndef USDT2
- #define DEFINE_NEWSCALARARRAY(Return,Allocator,Result) \
- \
- DT_RETURN_MARK_DECL(New##Result##Array, Return); \
- \
- JNI_ENTRY(Return, \
- jni_New##Result##Array(JNIEnv *env, jsize len)) \
- JNIWrapper("New" XSTR(Result) "Array"); \
- DTRACE_PROBE2(hotspot_jni, New##Result##Array__entry, env, len);\
- Return ret = NULL;\
- DT_RETURN_MARK(New##Result##Array, Return, (const Return&)ret);\
- \
- oop obj= oopFactory::Allocator(len, CHECK_0); \
- ret = (Return) JNIHandles::make_local(env, obj); \
- return ret;\
- JNI_END
-
- DEFINE_NEWSCALARARRAY(jbooleanArray, new_boolArray, Boolean)
- DEFINE_NEWSCALARARRAY(jbyteArray, new_byteArray, Byte)
- DEFINE_NEWSCALARARRAY(jshortArray, new_shortArray, Short)
- DEFINE_NEWSCALARARRAY(jcharArray, new_charArray, Char)
- DEFINE_NEWSCALARARRAY(jintArray, new_intArray, Int)
- DEFINE_NEWSCALARARRAY(jlongArray, new_longArray, Long)
- DEFINE_NEWSCALARARRAY(jfloatArray, new_singleArray, Float)
- DEFINE_NEWSCALARARRAY(jdoubleArray, new_doubleArray, Double)
-
- #else /* USDT2 */
#define DEFINE_NEWSCALARARRAY(Return,Allocator,Result \
,EntryProbe,ReturnProbe) \
\
DT_RETURN_MARK_DECL(New##Result##Array, Return \
--- 2658,2667 ----
*** 3493,3503 ****
HOTSPOT_JNI_NEWFLOATARRAY_ENTRY(env, len),
HOTSPOT_JNI_NEWFLOATARRAY_RETURN(_ret_ref))
DEFINE_NEWSCALARARRAY(jdoubleArray, new_doubleArray, Double,
HOTSPOT_JNI_NEWDOUBLEARRAY_ENTRY(env, len),
HOTSPOT_JNI_NEWDOUBLEARRAY_RETURN(_ret_ref))
- #endif /* USDT2 */
// Return an address which will fault if the caller writes to it.
static char* get_bad_address() {
static char* bad_address = NULL;
--- 2701,2710 ----
*** 3511,3561 ****
}
return bad_address;
}
- #ifndef USDT2
- #define DEFINE_GETSCALARARRAYELEMENTS(ElementTag,ElementType,Result, Tag) \
- \
- JNI_QUICK_ENTRY(ElementType*, \
- jni_Get##Result##ArrayElements(JNIEnv *env, ElementType##Array array, jboolean *isCopy)) \
- JNIWrapper("Get" XSTR(Result) "ArrayElements"); \
- DTRACE_PROBE3(hotspot_jni, Get##Result##ArrayElements__entry, env, array, isCopy);\
- /* allocate an chunk of memory in c land */ \
- typeArrayOop a = typeArrayOop(JNIHandles::resolve_non_null(array)); \
- ElementType* result; \
- int len = a->length(); \
- if (len == 0) { \
- /* Empty array: legal but useless, can't return NULL. \
- * Return a pointer to something useless. \
- * Avoid asserts in typeArrayOop. */ \
- result = (ElementType*)get_bad_address(); \
- } else { \
- /* JNI Specification states return NULL on OOM */ \
- result = NEW_C_HEAP_ARRAY_RETURN_NULL(ElementType, len, mtInternal); \
- if (result != NULL) { \
- /* copy the array to the c chunk */ \
- memcpy(result, a->Tag##_at_addr(0), sizeof(ElementType)*len); \
- if (isCopy) { \
- *isCopy = JNI_TRUE; \
- } \
- } \
- } \
- DTRACE_PROBE1(hotspot_jni, Get##Result##ArrayElements__return, result);\
- return result; \
- JNI_END
-
- DEFINE_GETSCALARARRAYELEMENTS(T_BOOLEAN, jboolean, Boolean, bool)
- DEFINE_GETSCALARARRAYELEMENTS(T_BYTE, jbyte, Byte, byte)
- DEFINE_GETSCALARARRAYELEMENTS(T_SHORT, jshort, Short, short)
- DEFINE_GETSCALARARRAYELEMENTS(T_CHAR, jchar, Char, char)
- DEFINE_GETSCALARARRAYELEMENTS(T_INT, jint, Int, int)
- DEFINE_GETSCALARARRAYELEMENTS(T_LONG, jlong, Long, long)
- DEFINE_GETSCALARARRAYELEMENTS(T_FLOAT, jfloat, Float, float)
- DEFINE_GETSCALARARRAYELEMENTS(T_DOUBLE, jdouble, Double, double)
-
- #else /* USDT2 */
#define DEFINE_GETSCALARARRAYELEMENTS(ElementTag,ElementType,Result, Tag \
, EntryProbe, ReturnProbe) \
\
JNI_QUICK_ENTRY(ElementType*, \
--- 2718,2727 ----
*** 3609,3651 ****
, HOTSPOT_JNI_GETFLOATARRAYELEMENTS_ENTRY(env, array, (uintptr_t *) isCopy),
HOTSPOT_JNI_GETFLOATARRAYELEMENTS_RETURN(result))
DEFINE_GETSCALARARRAYELEMENTS(T_DOUBLE, jdouble, Double, double
, HOTSPOT_JNI_GETDOUBLEARRAYELEMENTS_ENTRY(env, array, (uintptr_t *) isCopy),
HOTSPOT_JNI_GETDOUBLEARRAYELEMENTS_RETURN(result))
- #endif /* USDT2 */
-
- #ifndef USDT2
- #define DEFINE_RELEASESCALARARRAYELEMENTS(ElementTag,ElementType,Result,Tag) \
- \
- JNI_QUICK_ENTRY(void, \
- jni_Release##Result##ArrayElements(JNIEnv *env, ElementType##Array array, \
- ElementType *buf, jint mode)) \
- JNIWrapper("Release" XSTR(Result) "ArrayElements"); \
- DTRACE_PROBE4(hotspot_jni, Release##Result##ArrayElements__entry, env, array, buf, mode);\
- typeArrayOop a = typeArrayOop(JNIHandles::resolve_non_null(array)); \
- int len = a->length(); \
- if (len != 0) { /* Empty array: nothing to free or copy. */ \
- if ((mode == 0) || (mode == JNI_COMMIT)) { \
- memcpy(a->Tag##_at_addr(0), buf, sizeof(ElementType)*len); \
- } \
- if ((mode == 0) || (mode == JNI_ABORT)) { \
- FreeHeap(buf); \
- } \
- } \
- DTRACE_PROBE(hotspot_jni, Release##Result##ArrayElements__return);\
- JNI_END
-
- DEFINE_RELEASESCALARARRAYELEMENTS(T_BOOLEAN, jboolean, Boolean, bool)
- DEFINE_RELEASESCALARARRAYELEMENTS(T_BYTE, jbyte, Byte, byte)
- DEFINE_RELEASESCALARARRAYELEMENTS(T_SHORT, jshort, Short, short)
- DEFINE_RELEASESCALARARRAYELEMENTS(T_CHAR, jchar, Char, char)
- DEFINE_RELEASESCALARARRAYELEMENTS(T_INT, jint, Int, int)
- DEFINE_RELEASESCALARARRAYELEMENTS(T_LONG, jlong, Long, long)
- DEFINE_RELEASESCALARARRAYELEMENTS(T_FLOAT, jfloat, Float, float)
- DEFINE_RELEASESCALARARRAYELEMENTS(T_DOUBLE, jdouble, Double, double)
- #else /* USDT2 */
#define DEFINE_RELEASESCALARARRAYELEMENTS(ElementTag,ElementType,Result,Tag \
, EntryProbe, ReturnProbe);\
\
JNI_QUICK_ENTRY(void, \
--- 2775,2785 ----
*** 3688,3732 ****
, HOTSPOT_JNI_RELEASEFLOATARRAYELEMENTS_ENTRY(env, array, (float *) buf, mode),
HOTSPOT_JNI_RELEASEFLOATARRAYELEMENTS_RETURN())
DEFINE_RELEASESCALARARRAYELEMENTS(T_DOUBLE, jdouble, Double, double
, HOTSPOT_JNI_RELEASEDOUBLEARRAYELEMENTS_ENTRY(env, array, (double *) buf, mode),
HOTSPOT_JNI_RELEASEDOUBLEARRAYELEMENTS_RETURN())
- #endif /* USDT2 */
-
- #ifndef USDT2
- #define DEFINE_GETSCALARARRAYREGION(ElementTag,ElementType,Result, Tag) \
- DT_VOID_RETURN_MARK_DECL(Get##Result##ArrayRegion);\
- \
- JNI_ENTRY(void, \
- jni_Get##Result##ArrayRegion(JNIEnv *env, ElementType##Array array, jsize start, \
- jsize len, ElementType *buf)) \
- JNIWrapper("Get" XSTR(Result) "ArrayRegion"); \
- DTRACE_PROBE5(hotspot_jni, Get##Result##ArrayRegion__entry, env, array, start, len, buf);\
- DT_VOID_RETURN_MARK(Get##Result##ArrayRegion); \
- typeArrayOop src = typeArrayOop(JNIHandles::resolve_non_null(array)); \
- if (start < 0 || len < 0 || ((unsigned int)start + (unsigned int)len > (unsigned int)src->length())) { \
- THROW(vmSymbols::java_lang_ArrayIndexOutOfBoundsException()); \
- } else { \
- if (len > 0) { \
- int sc = TypeArrayKlass::cast(src->klass())->log2_element_size(); \
- memcpy((u_char*) buf, \
- (u_char*) src->Tag##_at_addr(start), \
- len << sc); \
- } \
- } \
- JNI_END
-
- DEFINE_GETSCALARARRAYREGION(T_BOOLEAN, jboolean,Boolean, bool)
- DEFINE_GETSCALARARRAYREGION(T_BYTE, jbyte, Byte, byte)
- DEFINE_GETSCALARARRAYREGION(T_SHORT, jshort, Short, short)
- DEFINE_GETSCALARARRAYREGION(T_CHAR, jchar, Char, char)
- DEFINE_GETSCALARARRAYREGION(T_INT, jint, Int, int)
- DEFINE_GETSCALARARRAYREGION(T_LONG, jlong, Long, long)
- DEFINE_GETSCALARARRAYREGION(T_FLOAT, jfloat, Float, float)
- DEFINE_GETSCALARARRAYREGION(T_DOUBLE, jdouble, Double, double)
- #else /* USDT2 */
#define DEFINE_GETSCALARARRAYREGION(ElementTag,ElementType,Result, Tag \
, EntryProbe, ReturnProbe); \
DT_VOID_RETURN_MARK_DECL(Get##Result##ArrayRegion \
, ReturnProbe); \
--- 2822,2832 ----
*** 3772,3816 ****
, HOTSPOT_JNI_GETFLOATARRAYREGION_ENTRY(env, array, start, len, (float *) buf),
HOTSPOT_JNI_GETFLOATARRAYREGION_RETURN());
DEFINE_GETSCALARARRAYREGION(T_DOUBLE, jdouble, Double, double
, HOTSPOT_JNI_GETDOUBLEARRAYREGION_ENTRY(env, array, start, len, (double *) buf),
HOTSPOT_JNI_GETDOUBLEARRAYREGION_RETURN());
- #endif /* USDT2 */
-
- #ifndef USDT2
- #define DEFINE_SETSCALARARRAYREGION(ElementTag,ElementType,Result, Tag) \
- DT_VOID_RETURN_MARK_DECL(Set##Result##ArrayRegion);\
- \
- JNI_ENTRY(void, \
- jni_Set##Result##ArrayRegion(JNIEnv *env, ElementType##Array array, jsize start, \
- jsize len, const ElementType *buf)) \
- JNIWrapper("Set" XSTR(Result) "ArrayRegion"); \
- DTRACE_PROBE5(hotspot_jni, Set##Result##ArrayRegion__entry, env, array, start, len, buf);\
- DT_VOID_RETURN_MARK(Set##Result##ArrayRegion); \
- typeArrayOop dst = typeArrayOop(JNIHandles::resolve_non_null(array)); \
- if (start < 0 || len < 0 || ((unsigned int)start + (unsigned int)len > (unsigned int)dst->length())) { \
- THROW(vmSymbols::java_lang_ArrayIndexOutOfBoundsException()); \
- } else { \
- if (len > 0) { \
- int sc = TypeArrayKlass::cast(dst->klass())->log2_element_size(); \
- memcpy((u_char*) dst->Tag##_at_addr(start), \
- (u_char*) buf, \
- len << sc); \
- } \
- } \
- JNI_END
- DEFINE_SETSCALARARRAYREGION(T_BOOLEAN, jboolean, Boolean, bool)
- DEFINE_SETSCALARARRAYREGION(T_BYTE, jbyte, Byte, byte)
- DEFINE_SETSCALARARRAYREGION(T_SHORT, jshort, Short, short)
- DEFINE_SETSCALARARRAYREGION(T_CHAR, jchar, Char, char)
- DEFINE_SETSCALARARRAYREGION(T_INT, jint, Int, int)
- DEFINE_SETSCALARARRAYREGION(T_LONG, jlong, Long, long)
- DEFINE_SETSCALARARRAYREGION(T_FLOAT, jfloat, Float, float)
- DEFINE_SETSCALARARRAYREGION(T_DOUBLE, jdouble, Double, double)
-
- #else /* USDT2 */
#define DEFINE_SETSCALARARRAYREGION(ElementTag,ElementType,Result, Tag \
, EntryProbe, ReturnProbe); \
DT_VOID_RETURN_MARK_DECL(Set##Result##ArrayRegion \
,ReturnProbe); \
--- 2872,2882 ----
*** 3856,3866 ****
, HOTSPOT_JNI_SETFLOATARRAYREGION_ENTRY(env, array, start, len, (float *) buf),
HOTSPOT_JNI_SETFLOATARRAYREGION_RETURN())
DEFINE_SETSCALARARRAYREGION(T_DOUBLE, jdouble, Double, double
, HOTSPOT_JNI_SETDOUBLEARRAYREGION_ENTRY(env, array, start, len, (double *) buf),
HOTSPOT_JNI_SETDOUBLEARRAYREGION_RETURN())
- #endif /* USDT2 */
//
// Interception of natives
//
--- 2922,2931 ----
*** 3941,3966 ****
method->name()->as_C_string());
}
return true;
}
- #ifndef USDT2
- DT_RETURN_MARK_DECL(RegisterNatives, jint);
- #else /* USDT2 */
DT_RETURN_MARK_DECL(RegisterNatives, jint
, HOTSPOT_JNI_REGISTERNATIVES_RETURN(_ret_ref));
- #endif /* USDT2 */
JNI_ENTRY(jint, jni_RegisterNatives(JNIEnv *env, jclass clazz,
const JNINativeMethod *methods,
jint nMethods))
JNIWrapper("RegisterNatives");
- #ifndef USDT2
- DTRACE_PROBE4(hotspot_jni, RegisterNatives__entry, env, clazz, methods, nMethods);
- #else /* USDT2 */
HOTSPOT_JNI_REGISTERNATIVES_ENTRY(env, clazz, (void *) methods, nMethods);
- #endif /* USDT2 */
jint ret = 0;
DT_RETURN_MARK(RegisterNatives, jint, (const jint&)ret);
KlassHandle h_k(thread, java_lang_Class::as_Klass(JNIHandles::resolve_non_null(clazz)));
--- 3006,3023 ----
*** 3994,4008 ****
JNI_END
JNI_ENTRY(jint, jni_UnregisterNatives(JNIEnv *env, jclass clazz))
JNIWrapper("UnregisterNatives");
- #ifndef USDT2
- DTRACE_PROBE2(hotspot_jni, UnregisterNatives__entry, env, clazz);
- #else /* USDT2 */
HOTSPOT_JNI_UNREGISTERNATIVES_ENTRY(env, clazz);
- #endif /* USDT2 */
Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(clazz));
//%note jni_2
if (k->oop_is_instance()) {
for (int index = 0; index < InstanceKlass::cast(k)->methods()->length(); index++) {
Method* m = InstanceKlass::cast(k)->methods()->at(index);
--- 3051,3061 ----
*** 4010,4044 ****
m->clear_native_function();
m->set_signature_handler(NULL);
}
}
}
- #ifndef USDT2
- DTRACE_PROBE1(hotspot_jni, UnregisterNatives__return, 0);
- #else /* USDT2 */
HOTSPOT_JNI_UNREGISTERNATIVES_RETURN(0);
- #endif /* USDT2 */
return 0;
JNI_END
//
// Monitor functions
//
- #ifndef USDT2
- DT_RETURN_MARK_DECL(MonitorEnter, jint);
- #else /* USDT2 */
DT_RETURN_MARK_DECL(MonitorEnter, jint
, HOTSPOT_JNI_MONITORENTER_RETURN(_ret_ref));
- #endif /* USDT2 */
JNI_ENTRY(jint, jni_MonitorEnter(JNIEnv *env, jobject jobj))
- #ifndef USDT2
- DTRACE_PROBE2(hotspot_jni, MonitorEnter__entry, env, jobj);
- #else /* USDT2 */
HOTSPOT_JNI_MONITORENTER_ENTRY(env, jobj);
- #endif /* USDT2 */
jint ret = JNI_ERR;
DT_RETURN_MARK(MonitorEnter, jint, (const jint&)ret);
// If the object is null, we can't do anything with it
if (jobj == NULL) {
--- 3063,3085 ----
*** 4049,4071 ****
ObjectSynchronizer::jni_enter(obj, CHECK_(JNI_ERR));
ret = JNI_OK;
return ret;
JNI_END
- #ifndef USDT2
- DT_RETURN_MARK_DECL(MonitorExit, jint);
- #else /* USDT2 */
DT_RETURN_MARK_DECL(MonitorExit, jint
, HOTSPOT_JNI_MONITOREXIT_RETURN(_ret_ref));
- #endif /* USDT2 */
JNI_ENTRY(jint, jni_MonitorExit(JNIEnv *env, jobject jobj))
- #ifndef USDT2
- DTRACE_PROBE2(hotspot_jni, MonitorExit__entry, env, jobj);
- #else /* USDT2 */
HOTSPOT_JNI_MONITOREXIT_ENTRY(env, jobj);
- #endif /* USDT2 */
jint ret = JNI_ERR;
DT_RETURN_MARK(MonitorExit, jint, (const jint&)ret);
// Don't do anything with a null object
if (jobj == NULL) {
--- 3090,3104 ----
*** 4081,4104 ****
//
// Extensions
//
- #ifndef USDT2
- DT_VOID_RETURN_MARK_DECL(GetStringRegion);
- #else /* USDT2 */
DT_VOID_RETURN_MARK_DECL(GetStringRegion
, HOTSPOT_JNI_GETSTRINGREGION_RETURN());
- #endif /* USDT2 */
JNI_ENTRY(void, jni_GetStringRegion(JNIEnv *env, jstring string, jsize start, jsize len, jchar *buf))
JNIWrapper("GetStringRegion");
- #ifndef USDT2
- DTRACE_PROBE5(hotspot_jni, GetStringRegion__entry, env, string, start, len, buf);
- #else /* USDT2 */
HOTSPOT_JNI_GETSTRINGREGION_ENTRY(env, string, start, len, buf);
- #endif /* USDT2 */
DT_VOID_RETURN_MARK(GetStringRegion);
oop s = JNIHandles::resolve_non_null(string);
int s_len = java_lang_String::length(s);
if (start < 0 || len < 0 || start + len > s_len) {
THROW(vmSymbols::java_lang_StringIndexOutOfBoundsException());
--- 3114,3129 ----
*** 4109,4132 ****
memcpy(buf, s_value->char_at_addr(s_offset+start), sizeof(jchar)*len);
}
}
JNI_END
- #ifndef USDT2
- DT_VOID_RETURN_MARK_DECL(GetStringUTFRegion);
- #else /* USDT2 */
DT_VOID_RETURN_MARK_DECL(GetStringUTFRegion
, HOTSPOT_JNI_GETSTRINGUTFREGION_RETURN());
- #endif /* USDT2 */
JNI_ENTRY(void, jni_GetStringUTFRegion(JNIEnv *env, jstring string, jsize start, jsize len, char *buf))
JNIWrapper("GetStringUTFRegion");
- #ifndef USDT2
- DTRACE_PROBE5(hotspot_jni, GetStringUTFRegion__entry, env, string, start, len, buf);
- #else /* USDT2 */
HOTSPOT_JNI_GETSTRINGUTFREGION_ENTRY(env, string, start, len, buf);
- #endif /* USDT2 */
DT_VOID_RETURN_MARK(GetStringUTFRegion);
oop s = JNIHandles::resolve_non_null(string);
int s_len = java_lang_String::length(s);
if (start < 0 || len < 0 || start + len > s_len) {
THROW(vmSymbols::java_lang_StringIndexOutOfBoundsException());
--- 3134,3149 ----
*** 4148,4162 ****
JNI_END
JNI_ENTRY(void*, jni_GetPrimitiveArrayCritical(JNIEnv *env, jarray array, jboolean *isCopy))
JNIWrapper("GetPrimitiveArrayCritical");
- #ifndef USDT2
- DTRACE_PROBE3(hotspot_jni, GetPrimitiveArrayCritical__entry, env, array, isCopy);
- #else /* USDT2 */
HOTSPOT_JNI_GETPRIMITIVEARRAYCRITICAL_ENTRY(env, array, (uintptr_t *) isCopy);
- #endif /* USDT2 */
GC_locker::lock_critical(thread);
if (isCopy != NULL) {
*isCopy = JNI_FALSE;
}
oop a = JNIHandles::resolve_non_null(array);
--- 3165,3175 ----
*** 4166,4208 ****
type = T_OBJECT;
} else {
type = TypeArrayKlass::cast(a->klass())->element_type();
}
void* ret = arrayOop(a)->base(type);
- #ifndef USDT2
- DTRACE_PROBE1(hotspot_jni, GetPrimitiveArrayCritical__return, ret);
- #else /* USDT2 */
HOTSPOT_JNI_GETPRIMITIVEARRAYCRITICAL_RETURN(ret);
- #endif /* USDT2 */
return ret;
JNI_END
JNI_ENTRY(void, jni_ReleasePrimitiveArrayCritical(JNIEnv *env, jarray array, void *carray, jint mode))
JNIWrapper("ReleasePrimitiveArrayCritical");
- #ifndef USDT2
- DTRACE_PROBE4(hotspot_jni, ReleasePrimitiveArrayCritical__entry, env, array, carray, mode);
- #else /* USDT2 */
HOTSPOT_JNI_RELEASEPRIMITIVEARRAYCRITICAL_ENTRY(env, array, carray, mode);
- #endif /* USDT2 */
// The array, carray and mode arguments are ignored
GC_locker::unlock_critical(thread);
- #ifndef USDT2
- DTRACE_PROBE(hotspot_jni, ReleasePrimitiveArrayCritical__return);
- #else /* USDT2 */
HOTSPOT_JNI_RELEASEPRIMITIVEARRAYCRITICAL_RETURN();
- #endif /* USDT2 */
JNI_END
JNI_ENTRY(const jchar*, jni_GetStringCritical(JNIEnv *env, jstring string, jboolean *isCopy))
JNIWrapper("GetStringCritical");
- #ifndef USDT2
- DTRACE_PROBE3(hotspot_jni, GetStringCritical__entry, env, string, isCopy);
- #else /* USDT2 */
HOTSPOT_JNI_GETSTRINGCRITICAL_ENTRY(env, string, (uintptr_t *) isCopy);
- #endif /* USDT2 */
GC_locker::lock_critical(thread);
if (isCopy != NULL) {
*isCopy = JNI_FALSE;
}
oop s = JNIHandles::resolve_non_null(string);
--- 3179,3205 ----
*** 4213,4296 ****
if (s_len > 0) {
ret = s_value->char_at_addr(s_offset);
} else {
ret = (jchar*) s_value->base(T_CHAR);
}
- #ifndef USDT2
- DTRACE_PROBE1(hotspot_jni, GetStringCritical__return, ret);
- #else /* USDT2 */
HOTSPOT_JNI_GETSTRINGCRITICAL_RETURN((uint16_t *) ret);
- #endif /* USDT2 */
return ret;
JNI_END
JNI_ENTRY(void, jni_ReleaseStringCritical(JNIEnv *env, jstring str, const jchar *chars))
JNIWrapper("ReleaseStringCritical");
- #ifndef USDT2
- DTRACE_PROBE3(hotspot_jni, ReleaseStringCritical__entry, env, str, chars);
- #else /* USDT2 */
HOTSPOT_JNI_RELEASESTRINGCRITICAL_ENTRY(env, str, (uint16_t *) chars);
- #endif /* USDT2 */
// The str and chars arguments are ignored
GC_locker::unlock_critical(thread);
- #ifndef USDT2
- DTRACE_PROBE(hotspot_jni, ReleaseStringCritical__return);
- #else /* USDT2 */
HOTSPOT_JNI_RELEASESTRINGCRITICAL_RETURN();
- #endif /* USDT2 */
JNI_END
JNI_ENTRY(jweak, jni_NewWeakGlobalRef(JNIEnv *env, jobject ref))
JNIWrapper("jni_NewWeakGlobalRef");
- #ifndef USDT2
- DTRACE_PROBE2(hotspot_jni, NewWeakGlobalRef__entry, env, ref);
- #else /* USDT2 */
HOTSPOT_JNI_NEWWEAKGLOBALREF_ENTRY(env, ref);
- #endif /* USDT2 */
Handle ref_handle(thread, JNIHandles::resolve(ref));
jweak ret = JNIHandles::make_weak_global(ref_handle);
- #ifndef USDT2
- DTRACE_PROBE1(hotspot_jni, NewWeakGlobalRef__return, ret);
- #else /* USDT2 */
HOTSPOT_JNI_NEWWEAKGLOBALREF_RETURN(ret);
- #endif /* USDT2 */
return ret;
JNI_END
// Must be JNI_ENTRY (with HandleMark)
JNI_ENTRY(void, jni_DeleteWeakGlobalRef(JNIEnv *env, jweak ref))
JNIWrapper("jni_DeleteWeakGlobalRef");
- #ifndef USDT2
- DTRACE_PROBE2(hotspot_jni, DeleteWeakGlobalRef__entry, env, ref);
- #else /* USDT2 */
HOTSPOT_JNI_DELETEWEAKGLOBALREF_ENTRY(env, ref);
- #endif /* USDT2 */
JNIHandles::destroy_weak_global(ref);
- #ifndef USDT2
- DTRACE_PROBE(hotspot_jni, DeleteWeakGlobalRef__return);
- #else /* USDT2 */
HOTSPOT_JNI_DELETEWEAKGLOBALREF_RETURN();
- #endif /* USDT2 */
JNI_END
JNI_QUICK_ENTRY(jboolean, jni_ExceptionCheck(JNIEnv *env))
JNIWrapper("jni_ExceptionCheck");
- #ifndef USDT2
- DTRACE_PROBE1(hotspot_jni, ExceptionCheck__entry, env);
- #else /* USDT2 */
HOTSPOT_JNI_EXCEPTIONCHECK_ENTRY(env);
- #endif /* USDT2 */
jni_check_async_exceptions(thread);
jboolean ret = (thread->has_pending_exception()) ? JNI_TRUE : JNI_FALSE;
- #ifndef USDT2
- DTRACE_PROBE1(hotspot_jni, ExceptionCheck__return, ret);
- #else /* USDT2 */
HOTSPOT_JNI_EXCEPTIONCHECK_RETURN(ret);
- #endif /* USDT2 */
return ret;
JNI_END
// Initialization state for three routines below relating to
--- 3210,3257 ----
*** 4378,4436 ****
{
// thread_from_jni_environment() will block if VM is gone.
JavaThread* thread = JavaThread::thread_from_jni_environment(env);
JNIWrapper("jni_NewDirectByteBuffer");
- #ifndef USDT2
- DTRACE_PROBE3(hotspot_jni, NewDirectByteBuffer__entry, env, address, capacity);
- #else /* USDT2 */
HOTSPOT_JNI_NEWDIRECTBYTEBUFFER_ENTRY(env, address, capacity);
- #endif /* USDT2 */
if (!directBufferSupportInitializeEnded) {
if (!initializeDirectBufferSupport(env, thread)) {
- #ifndef USDT2
- DTRACE_PROBE1(hotspot_jni, NewDirectByteBuffer__return, NULL);
- #else /* USDT2 */
HOTSPOT_JNI_NEWDIRECTBYTEBUFFER_RETURN(NULL);
- #endif /* USDT2 */
return NULL;
}
}
// Being paranoid about accidental sign extension on address
jlong addr = (jlong) ((uintptr_t) address);
// NOTE that package-private DirectByteBuffer constructor currently
// takes int capacity
jint cap = (jint) capacity;
jobject ret = env->NewObject(directByteBufferClass, directByteBufferConstructor, addr, cap);
- #ifndef USDT2
- DTRACE_PROBE1(hotspot_jni, NewDirectByteBuffer__return, ret);
- #else /* USDT2 */
HOTSPOT_JNI_NEWDIRECTBYTEBUFFER_RETURN(ret);
- #endif /* USDT2 */
return ret;
}
- #ifndef USDT2
- DT_RETURN_MARK_DECL(GetDirectBufferAddress, void*);
- #else /* USDT2 */
DT_RETURN_MARK_DECL(GetDirectBufferAddress, void*
, HOTSPOT_JNI_GETDIRECTBUFFERADDRESS_RETURN((void*) _ret_ref));
- #endif /* USDT2 */
extern "C" void* JNICALL jni_GetDirectBufferAddress(JNIEnv *env, jobject buf)
{
// thread_from_jni_environment() will block if VM is gone.
JavaThread* thread = JavaThread::thread_from_jni_environment(env);
JNIWrapper("jni_GetDirectBufferAddress");
- #ifndef USDT2
- DTRACE_PROBE2(hotspot_jni, GetDirectBufferAddress__entry, env, buf);
- #else /* USDT2 */
HOTSPOT_JNI_GETDIRECTBUFFERADDRESS_ENTRY(env, buf);
- #endif /* USDT2 */
void* ret = NULL;
DT_RETURN_MARK(GetDirectBufferAddress, void*, (const void*&)ret);
if (!directBufferSupportInitializeEnded) {
if (!initializeDirectBufferSupport(env, thread)) {
--- 3339,3377 ----
*** 4444,4471 ****
ret = (void*)(intptr_t)env->GetLongField(buf, directBufferAddressField);
return ret;
}
- #ifndef USDT2
- DT_RETURN_MARK_DECL(GetDirectBufferCapacity, jlong);
- #else /* USDT2 */
DT_RETURN_MARK_DECL(GetDirectBufferCapacity, jlong
, HOTSPOT_JNI_GETDIRECTBUFFERCAPACITY_RETURN(_ret_ref));
- #endif /* USDT2 */
extern "C" jlong JNICALL jni_GetDirectBufferCapacity(JNIEnv *env, jobject buf)
{
// thread_from_jni_environment() will block if VM is gone.
JavaThread* thread = JavaThread::thread_from_jni_environment(env);
JNIWrapper("jni_GetDirectBufferCapacity");
- #ifndef USDT2
- DTRACE_PROBE2(hotspot_jni, GetDirectBufferCapacity__entry, env, buf);
- #else /* USDT2 */
HOTSPOT_JNI_GETDIRECTBUFFERCAPACITY_ENTRY(env, buf);
- #endif /* USDT2 */
jlong ret = -1;
DT_RETURN_MARK(GetDirectBufferCapacity, jlong, (const jlong&)ret);
if (!directBufferSupportInitializeEnded) {
if (!initializeDirectBufferSupport(env, thread)) {
--- 3385,3404 ----
*** 4488,4525 ****
}
JNI_LEAF(jint, jni_GetVersion(JNIEnv *env))
JNIWrapper("GetVersion");
- #ifndef USDT2
- DTRACE_PROBE1(hotspot_jni, GetVersion__entry, env);
- #else /* USDT2 */
HOTSPOT_JNI_GETVERSION_ENTRY(env);
- #endif /* USDT2 */
- #ifndef USDT2
- DTRACE_PROBE1(hotspot_jni, GetVersion__return, CurrentVersion);
- #else /* USDT2 */
HOTSPOT_JNI_GETVERSION_RETURN(CurrentVersion);
- #endif /* USDT2 */
return CurrentVersion;
JNI_END
extern struct JavaVM_ main_vm;
JNI_LEAF(jint, jni_GetJavaVM(JNIEnv *env, JavaVM **vm))
JNIWrapper("jni_GetJavaVM");
- #ifndef USDT2
- DTRACE_PROBE2(hotspot_jni, GetJavaVM__entry, env, vm);
- #else /* USDT2 */
HOTSPOT_JNI_GETJAVAVM_ENTRY(env, (void **) vm);
- #endif /* USDT2 */
*vm = (JavaVM *)(&main_vm);
- #ifndef USDT2
- DTRACE_PROBE1(hotspot_jni, GetJavaVM__return, JNI_OK);
- #else /* USDT2 */
HOTSPOT_JNI_GETJAVAVM_RETURN(JNI_OK);
- #endif /* USDT2 */
return JNI_OK;
JNI_END
// Structure containing all jni functions
struct JNINativeInterface_ jni_NativeInterface = {
--- 3421,3442 ----
*** 4893,4916 ****
#define JAVASTACKSIZE (400 * 1024) /* Default size of a thread java stack */
enum { VERIFY_NONE, VERIFY_REMOTE, VERIFY_ALL };
- #ifndef USDT2
- HS_DTRACE_PROBE_DECL1(hotspot_jni, GetDefaultJavaVMInitArgs__entry, void*);
- DT_RETURN_MARK_DECL(GetDefaultJavaVMInitArgs, jint);
- #else /* USDT2 */
DT_RETURN_MARK_DECL(GetDefaultJavaVMInitArgs, jint
, HOTSPOT_JNI_GETDEFAULTJAVAVMINITARGS_RETURN(_ret_ref));
- #endif /* USDT2 */
_JNI_IMPORT_OR_EXPORT_ jint JNICALL JNI_GetDefaultJavaVMInitArgs(void *args_) {
- #ifndef USDT2
- HS_DTRACE_PROBE1(hotspot_jni, GetDefaultJavaVMInitArgs__entry, args_);
- #else /* USDT2 */
HOTSPOT_JNI_GETDEFAULTJAVAVMINITARGS_ENTRY(args_);
- #endif /* USDT2 */
JDK1_1InitArgs *args = (JDK1_1InitArgs *)args_;
jint ret = JNI_ERR;
DT_RETURN_MARK(GetDefaultJavaVMInitArgs, jint, (const jint&)ret);
if (Threads::is_supported_jni_version(args->version)) {
--- 3810,3824 ----
*** 4988,5011 ****
#undef run_unit_test
#endif
- #ifndef USDT2
- HS_DTRACE_PROBE_DECL3(hotspot_jni, CreateJavaVM__entry, vm, penv, args);
- DT_RETURN_MARK_DECL(CreateJavaVM, jint);
- #else /* USDT2 */
DT_RETURN_MARK_DECL(CreateJavaVM, jint
, HOTSPOT_JNI_CREATEJAVAVM_RETURN(_ret_ref));
- #endif /* USDT2 */
_JNI_IMPORT_OR_EXPORT_ jint JNICALL JNI_CreateJavaVM(JavaVM **vm, void **penv, void *args) {
- #ifndef USDT2
- HS_DTRACE_PROBE3(hotspot_jni, CreateJavaVM__entry, vm, penv, args);
- #else /* USDT2 */
HOTSPOT_JNI_CREATEJAVAVM_ENTRY((void **) vm, penv, args);
- #endif /* USDT2 */
jint result = JNI_ERR;
DT_RETURN_MARK(CreateJavaVM, jint, (const jint&)result);
// We're about to use Atomic::xchg for synchronization. Some Zero
--- 3896,3910 ----
*** 5123,5176 ****
}
return result;
}
- #ifndef USDT2
- HS_DTRACE_PROBE_DECL3(hotspot_jni, GetCreatedJavaVMs__entry, \
- JavaVM**, jsize, jsize*);
- HS_DTRACE_PROBE_DECL1(hotspot_jni, GetCreatedJavaVMs__return, jint);
- #endif /* !USDT2 */
_JNI_IMPORT_OR_EXPORT_ jint JNICALL JNI_GetCreatedJavaVMs(JavaVM **vm_buf, jsize bufLen, jsize *numVMs) {
// See bug 4367188, the wrapper can sometimes cause VM crashes
// JNIWrapper("GetCreatedJavaVMs");
! #ifndef USDT2
! HS_DTRACE_PROBE3(hotspot_jni, GetCreatedJavaVMs__entry, \
! vm_buf, bufLen, numVMs);
! #else /* USDT2 */
HOTSPOT_JNI_GETCREATEDJAVAVMS_ENTRY((void **) vm_buf, bufLen, (uintptr_t *) numVMs);
! #endif /* USDT2 */
if (vm_created) {
if (numVMs != NULL) *numVMs = 1;
if (bufLen > 0) *vm_buf = (JavaVM *)(&main_vm);
} else {
if (numVMs != NULL) *numVMs = 0;
}
- #ifndef USDT2
- HS_DTRACE_PROBE1(hotspot_jni, GetCreatedJavaVMs__return, JNI_OK);
- #else /* USDT2 */
HOTSPOT_JNI_GETCREATEDJAVAVMS_RETURN(JNI_OK);
- #endif /* USDT2 */
return JNI_OK;
}
extern "C" {
- #ifndef USDT2
- DT_RETURN_MARK_DECL(DestroyJavaVM, jint);
- #else /* USDT2 */
DT_RETURN_MARK_DECL(DestroyJavaVM, jint
, HOTSPOT_JNI_DESTROYJAVAVM_RETURN(_ret_ref));
- #endif /* USDT2 */
jint JNICALL jni_DestroyJavaVM(JavaVM *vm) {
- #ifndef USDT2
- DTRACE_PROBE1(hotspot_jni, DestroyJavaVM__entry, vm);
- #else /* USDT2 */
HOTSPOT_JNI_DESTROYJAVAVM_ENTRY(vm);
- #endif /* USDT2 */
jint res = JNI_ERR;
DT_RETURN_MARK(DestroyJavaVM, jint, (const jint&)res);
if (!vm_created) {
res = JNI_ERR;
--- 4022,4055 ----
}
return result;
}
_JNI_IMPORT_OR_EXPORT_ jint JNICALL JNI_GetCreatedJavaVMs(JavaVM **vm_buf, jsize bufLen, jsize *numVMs) {
// See bug 4367188, the wrapper can sometimes cause VM crashes
// JNIWrapper("GetCreatedJavaVMs");
!
HOTSPOT_JNI_GETCREATEDJAVAVMS_ENTRY((void **) vm_buf, bufLen, (uintptr_t *) numVMs);
!
if (vm_created) {
if (numVMs != NULL) *numVMs = 1;
if (bufLen > 0) *vm_buf = (JavaVM *)(&main_vm);
} else {
if (numVMs != NULL) *numVMs = 0;
}
HOTSPOT_JNI_GETCREATEDJAVAVMS_RETURN(JNI_OK);
return JNI_OK;
}
extern "C" {
DT_RETURN_MARK_DECL(DestroyJavaVM, jint
, HOTSPOT_JNI_DESTROYJAVAVM_RETURN(_ret_ref));
jint JNICALL jni_DestroyJavaVM(JavaVM *vm) {
HOTSPOT_JNI_DESTROYJAVAVM_ENTRY(vm);
jint res = JNI_ERR;
DT_RETURN_MARK(DestroyJavaVM, jint, (const jint&)res);
if (!vm_created) {
res = JNI_ERR;
*** 5318,5379 ****
return JNI_OK;
}
jint JNICALL jni_AttachCurrentThread(JavaVM *vm, void **penv, void *_args) {
- #ifndef USDT2
- DTRACE_PROBE3(hotspot_jni, AttachCurrentThread__entry, vm, penv, _args);
- #else /* USDT2 */
HOTSPOT_JNI_ATTACHCURRENTTHREAD_ENTRY(vm, penv, _args);
- #endif /* USDT2 */
if (!vm_created) {
- #ifndef USDT2
- DTRACE_PROBE1(hotspot_jni, AttachCurrentThread__return, JNI_ERR);
- #else /* USDT2 */
HOTSPOT_JNI_ATTACHCURRENTTHREAD_RETURN((uint32_t) JNI_ERR);
- #endif /* USDT2 */
return JNI_ERR;
}
JNIWrapper("AttachCurrentThread");
jint ret = attach_current_thread(vm, penv, _args, false);
- #ifndef USDT2
- DTRACE_PROBE1(hotspot_jni, AttachCurrentThread__return, ret);
- #else /* USDT2 */
HOTSPOT_JNI_ATTACHCURRENTTHREAD_RETURN(ret);
- #endif /* USDT2 */
return ret;
}
jint JNICALL jni_DetachCurrentThread(JavaVM *vm) {
- #ifndef USDT2
- DTRACE_PROBE1(hotspot_jni, DetachCurrentThread__entry, vm);
- #else /* USDT2 */
HOTSPOT_JNI_DETACHCURRENTTHREAD_ENTRY(vm);
- #endif /* USDT2 */
VM_Exit::block_if_vm_exited();
JNIWrapper("DetachCurrentThread");
// If the thread has been deattacted the operations is a no-op
if (ThreadLocalStorage::thread() == NULL) {
- #ifndef USDT2
- DTRACE_PROBE1(hotspot_jni, DetachCurrentThread__return, JNI_OK);
- #else /* USDT2 */
HOTSPOT_JNI_DETACHCURRENTTHREAD_RETURN(JNI_OK);
- #endif /* USDT2 */
return JNI_OK;
}
JavaThread* thread = JavaThread::current();
if (thread->has_last_Java_frame()) {
- #ifndef USDT2
- DTRACE_PROBE1(hotspot_jni, DetachCurrentThread__return, JNI_ERR);
- #else /* USDT2 */
HOTSPOT_JNI_DETACHCURRENTTHREAD_RETURN((uint32_t) JNI_ERR);
- #endif /* USDT2 */
// Can't detach a thread that's running java, that can't work.
return JNI_ERR;
}
// Safepoint support. Have to do call-back to safepoint code, if in the
--- 4197,4234 ----
*** 5390,5420 ****
// (platform-dependent) methods where we do alternate stack
// maintenance work?)
thread->exit(false, JavaThread::jni_detach);
delete thread;
- #ifndef USDT2
- DTRACE_PROBE1(hotspot_jni, DetachCurrentThread__return, JNI_OK);
- #else /* USDT2 */
HOTSPOT_JNI_DETACHCURRENTTHREAD_RETURN(JNI_OK);
- #endif /* USDT2 */
return JNI_OK;
}
- #ifndef USDT2
- DT_RETURN_MARK_DECL(GetEnv, jint);
- #else /* USDT2 */
DT_RETURN_MARK_DECL(GetEnv, jint
, HOTSPOT_JNI_GETENV_RETURN(_ret_ref));
- #endif /* USDT2 */
jint JNICALL jni_GetEnv(JavaVM *vm, void **penv, jint version) {
- #ifndef USDT2
- DTRACE_PROBE3(hotspot_jni, GetEnv__entry, vm, penv, version);
- #else /* USDT2 */
HOTSPOT_JNI_GETENV_ENTRY(vm, penv, version);
- #endif /* USDT2 */
jint ret = JNI_ERR;
DT_RETURN_MARK(GetEnv, jint, (const jint&)ret);
if (!vm_created) {
*penv = NULL;
--- 4245,4263 ----
*** 5464,5494 ****
}
}
jint JNICALL jni_AttachCurrentThreadAsDaemon(JavaVM *vm, void **penv, void *_args) {
- #ifndef USDT2
- DTRACE_PROBE3(hotspot_jni, AttachCurrentThreadAsDaemon__entry, vm, penv, _args);
- #else /* USDT2 */
HOTSPOT_JNI_ATTACHCURRENTTHREADASDAEMON_ENTRY(vm, penv, _args);
- #endif /* USDT2 */
if (!vm_created) {
- #ifndef USDT2
- DTRACE_PROBE1(hotspot_jni, AttachCurrentThreadAsDaemon__return, JNI_ERR);
- #else /* USDT2 */
HOTSPOT_JNI_ATTACHCURRENTTHREADASDAEMON_RETURN((uint32_t) JNI_ERR);
- #endif /* USDT2 */
return JNI_ERR;
}
JNIWrapper("AttachCurrentThreadAsDaemon");
jint ret = attach_current_thread(vm, penv, _args, true);
- #ifndef USDT2
- DTRACE_PROBE1(hotspot_jni, AttachCurrentThreadAsDaemon__return, ret);
- #else /* USDT2 */
HOTSPOT_JNI_ATTACHCURRENTTHREADASDAEMON_RETURN(ret);
- #endif /* USDT2 */
return ret;
}
} // End extern "C"
--- 4307,4325 ----