jdk-sandbox: comparison hotspot/src/share/vm/prims/jni.cpp

equal deleted inserted replaced

-:924605caa9a8
+:b9e88eed82d7
 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(
+HOTSPOT_JNI_FINDCLASS_ENTRY(env, (char *)name);
-env, (char *)name);
 #endif /* USDT2 */
 jclass result = NULL;
 DT_RETURN_MARK(FindClass, jclass, (const jclass&)result);
 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(
+HOTSPOT_JNI_FROMREFLECTEDMETHOD_ENTRY(env, method);
-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
 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(
+HOTSPOT_JNI_FROMREFLECTEDFIELD_ENTRY(env, field);
-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
 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(
+HOTSPOT_JNI_TOREFLECTEDMETHOD_ENTRY(env, cls, (uintptr_t) method_id, isStatic);
-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));
 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(
+HOTSPOT_JNI_GETSUPERCLASS_ENTRY(env, sub);
-env, sub);
 #endif /* USDT2 */
 jclass obj = NULL;
 DT_RETURN_MARK(GetSuperclass, jclass, (const jclass&)obj);
 oop mirror = JNIHandles::resolve_non_null(sub);
 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(
+HOTSPOT_JNI_ISASSIGNABLEFROM_ENTRY(env, sub, super);
-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(
+HOTSPOT_JNI_ISASSIGNABLEFROM_RETURN(ret);
-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);
 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(
+HOTSPOT_JNI_ISASSIGNABLEFROM_RETURN(ret);
-ret);
 #endif /* USDT2 */
 return ret;
 JNI_END
 #ifndef 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(
+HOTSPOT_JNI_THROW_ENTRY(env, obj);
-env, obj);
 #endif /* USDT2 */
 jint ret = JNI_OK;
 DT_RETURN_MARK(Throw, jint, (const jint&)ret);
 THROW_OOP_(JNIHandles::resolve(obj), JNI_OK);
 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(
+HOTSPOT_JNI_THROWNEW_ENTRY(env, clazz, (char *) message);
-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)));
 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(
+HOTSPOT_JNI_EXCEPTIONOCCURRED_ENTRY(env);
-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(
+HOTSPOT_JNI_EXCEPTIONOCCURRED_RETURN(ret);
-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(
+HOTSPOT_JNI_EXCEPTIONDESCRIBE_ENTRY(env);
-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())) {
 }
 }
 #ifndef USDT2
 DTRACE_PROBE(hotspot_jni, ExceptionDescribe__return);
 #else /* USDT2 */
-HOTSPOT_JNI_EXCEPTIONDESCRIBE_RETURN(
+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(
+HOTSPOT_JNI_EXCEPTIONCLEAR_ENTRY(env);
-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();
 }
 thread->clear_pending_exception();
 #ifndef USDT2
 DTRACE_PROBE(hotspot_jni, ExceptionClear__return);
 #else /* USDT2 */
-HOTSPOT_JNI_EXCEPTIONCLEAR_RETURN(
+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(
+HOTSPOT_JNI_FATALERROR_ENTRY(env, (char *) msg);
-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(
+HOTSPOT_JNI_PUSHLOCALFRAME_ENTRY(env, capacity);
-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(
+HOTSPOT_JNI_PUSHLOCALFRAME_RETURN((uint32_t)JNI_ERR);
-(uint32_t)JNI_ERR);
 #endif /* USDT2 */
 return JNI_ERR;
 }
 JNIHandleBlock* old_handles = thread->active_handles();
 JNIHandleBlock* new_handles = JNIHandleBlock::allocate_block(thread);
 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(
+HOTSPOT_JNI_PUSHLOCALFRAME_RETURN(ret);
-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(
+HOTSPOT_JNI_POPLOCALFRAME_ENTRY(env, result);
-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();
 result = JNIHandles::make_local(thread, result_handle());
 }
 #ifndef USDT2
 DTRACE_PROBE1(hotspot_jni, PopLocalFrame__return, result);
 #else /* USDT2 */
-HOTSPOT_JNI_POPLOCALFRAME_RETURN(
+HOTSPOT_JNI_POPLOCALFRAME_RETURN(result);
-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(
+HOTSPOT_JNI_NEWGLOBALREF_ENTRY(env, ref);
-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(
+HOTSPOT_JNI_NEWGLOBALREF_RETURN(ret);
-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(
+HOTSPOT_JNI_DELETEGLOBALREF_ENTRY(env, ref);
-env, ref);
 #endif /* USDT2 */
 JNIHandles::destroy_global(ref);
 #ifndef USDT2
 DTRACE_PROBE(hotspot_jni, DeleteGlobalRef__return);
 #else /* USDT2 */
-HOTSPOT_JNI_DELETEGLOBALREF_RETURN(
+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(
+HOTSPOT_JNI_DELETELOCALREF_ENTRY(env, obj);
-env, obj);
 #endif /* USDT2 */
 JNIHandles::destroy_local(obj);
 #ifndef USDT2
 DTRACE_PROBE(hotspot_jni, DeleteLocalRef__return);
 #else /* USDT2 */
-HOTSPOT_JNI_DELETELOCALREF_RETURN(
+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(
+HOTSPOT_JNI_ISSAMEOBJECT_ENTRY(env, r1, r2);
-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(
+HOTSPOT_JNI_ISSAMEOBJECT_RETURN(ret);
-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(
+HOTSPOT_JNI_NEWLOCALREF_ENTRY(env, ref);
-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(
+HOTSPOT_JNI_NEWLOCALREF_RETURN(ret);
-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(
+HOTSPOT_JNI_ENSURELOCALCAPACITY_ENTRY(env, capacity);
-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(
+HOTSPOT_JNI_ENSURELOCALCAPACITY_RETURN(ret);
-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(
+HOTSPOT_JNI_GETOBJECTREFTYPE_ENTRY(env, obj);
-env, obj);
 #endif /* USDT2 */
 jobjectRefType ret;
 if (JNIHandles::is_local_handle(thread, obj) ||
 JNIHandles::is_frame_handle(thread, obj))
 ret = JNILocalRefType;
 else
 ret = JNIInvalidRefType;
 #ifndef USDT2
 DTRACE_PROBE1(hotspot_jni, GetObjectRefType__return, ret);
 #else /* USDT2 */
-HOTSPOT_JNI_GETOBJECTREFTYPE_RETURN(
+HOTSPOT_JNI_GETOBJECTREFTYPE_RETURN((void *) ret);
-(void *) ret);
 #endif /* USDT2 */
 return ret;
 JNI_END
 JNIWrapper("AllocObject");
 #ifndef USDT2
 DTRACE_PROBE2(hotspot_jni, AllocObject__entry, env, clazz);
 #else /* USDT2 */
-HOTSPOT_JNI_ALLOCOBJECT_ENTRY(
+HOTSPOT_JNI_ALLOCOBJECT_ENTRY(env, clazz);
-env, clazz);
 #endif /* USDT2 */
 jobject ret = NULL;
 DT_RETURN_MARK(AllocObject, jobject, (const jobject&)ret);
 instanceOop i = alloc_object(clazz, CHECK_NULL);
 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(
+HOTSPOT_JNI_NEWOBJECTA_ENTRY(env, clazz, (uintptr_t) methodID);
-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);
 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(
+HOTSPOT_JNI_NEWOBJECTV_ENTRY(env, clazz, (uintptr_t) methodID);
-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);
 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(
+HOTSPOT_JNI_NEWOBJECT_ENTRY(env, clazz, (uintptr_t) methodID);
-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);
 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(
+HOTSPOT_JNI_GETOBJECTCLASS_ENTRY(env, obj);
-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(
+HOTSPOT_JNI_GETOBJECTCLASS_RETURN(ret);
-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(
+HOTSPOT_JNI_ISINSTANCEOF_ENTRY(env, obj, clazz);
-env, obj, clazz);
 #endif /* USDT2 */
 jboolean ret = JNI_TRUE;
 if (obj != NULL) {
 ret = JNI_FALSE;
 Klass* k = java_lang_Class::as_Klass(
 }
 }
 #ifndef USDT2
 DTRACE_PROBE1(hotspot_jni, IsInstanceOf__return, ret);
 #else /* USDT2 */
-HOTSPOT_JNI_ISINSTANCEOF_RETURN(
+HOTSPOT_JNI_ISINSTANCEOF_RETURN(ret);
-ret);
 #endif /* USDT2 */
 return ret;
 JNI_END
 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(
+HOTSPOT_JNI_GETMETHODID_ENTRY(env, clazz, (char *) name, (char *) sig);
-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(
+HOTSPOT_JNI_GETMETHODID_RETURN((uintptr_t) ret);
-(uintptr_t) ret);
 #endif /* USDT2 */
 return ret;
 JNI_END
 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(
+HOTSPOT_JNI_GETSTATICMETHODID_ENTRY(env, (char *) clazz, (char *) name, (char *)sig);
-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(
+HOTSPOT_JNI_GETSTATICMETHODID_RETURN((uintptr_t) ret);
-(uintptr_t) ret);
 #endif /* USDT2 */
 return ret;
 JNI_END
 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(
+HOTSPOT_JNI_CALLVOIDMETHOD_ENTRY(env, obj, (uintptr_t) methodID);
-env, obj, (uintptr_t) methodID);
 #endif /* USDT2 */
 DT_VOID_RETURN_MARK(CallVoidMethod);
 va_list args;
 va_start(args, methodID);
 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(
+HOTSPOT_JNI_CALLVOIDMETHODV_ENTRY(env, obj, (uintptr_t) methodID);
-env, obj, (uintptr_t) methodID);
 #endif /* USDT2 */
 DT_VOID_RETURN_MARK(CallVoidMethodV);
 JavaValue jvalue(T_VOID);
 JNI_ArgumentPusherVaArg ap(methodID, args);
 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(
+HOTSPOT_JNI_CALLVOIDMETHODA_ENTRY(env, obj, (uintptr_t) methodID);
-env, obj, (uintptr_t) methodID);
 #endif /* USDT2 */
 DT_VOID_RETURN_MARK(CallVoidMethodA);
 JavaValue jvalue(T_VOID);
 JNI_ArgumentPusherArray ap(methodID, args);
 #ifndef USDT2
 DTRACE_PROBE4(hotspot_jni, CallNonvirtualVoidMethod__entry,
 env, obj, cls, methodID);
 #else /* USDT2 */
-HOTSPOT_JNI_CALLNONVIRTUALVOIDMETHOD_ENTRY(
+HOTSPOT_JNI_CALLNONVIRTUALVOIDMETHOD_ENTRY(env, obj, cls, (uintptr_t) methodID);
-env, obj, cls, (uintptr_t) methodID);
 #endif /* USDT2 */
 DT_VOID_RETURN_MARK(CallNonvirtualVoidMethod);
 va_list args;
 va_start(args, methodID);
 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(
+HOTSPOT_JNI_CALLSTATICVOIDMETHOD_ENTRY(env, cls, (uintptr_t) methodID);
-env, cls, (uintptr_t) methodID);
 #endif /* USDT2 */
 DT_VOID_RETURN_MARK(CallStaticVoidMethod);
 va_list args;
 va_start(args, methodID);
 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(
+HOTSPOT_JNI_CALLSTATICVOIDMETHODV_ENTRY(env, cls, (uintptr_t) methodID);
-env, cls, (uintptr_t) methodID);
 #endif /* USDT2 */
 DT_VOID_RETURN_MARK(CallStaticVoidMethodV);
 JavaValue jvalue(T_VOID);
 JNI_ArgumentPusherVaArg ap(methodID, args);
 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(
+HOTSPOT_JNI_CALLSTATICVOIDMETHODA_ENTRY(env, cls, (uintptr_t) methodID);
-env, cls, (uintptr_t) methodID);
 #endif /* USDT2 */
 DT_VOID_RETURN_MARK(CallStaticVoidMethodA);
 JavaValue jvalue(T_VOID);
 JNI_ArgumentPusherArray ap(methodID, args);
 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(
+HOTSPOT_JNI_GETFIELDID_ENTRY(env, clazz, (char *) name, (char *) sig);
-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
 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(
+HOTSPOT_JNI_GETOBJECTFIELD_ENTRY(env, obj, (uintptr_t) fieldID);
-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.
 }
 #endif // INCLUDE_ALL_GCS
 #ifndef USDT2
 DTRACE_PROBE1(hotspot_jni, GetObjectField__return, ret);
 #else /* USDT2 */
-HOTSPOT_JNI_GETOBJECTFIELD_RETURN(
+HOTSPOT_JNI_GETOBJECTFIELD_RETURN(ret);
-ret);
 #endif /* USDT2 */
 return ret;
 JNI_END
 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(
+HOTSPOT_JNI_SETOBJECTFIELD_ENTRY(env, obj, (uintptr_t) fieldID, value);
-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.
 }
 o->obj_field_put(offset, JNIHandles::resolve(value));
 #ifndef USDT2
 DTRACE_PROBE(hotspot_jni, SetObjectField__return);
 #else /* USDT2 */
-HOTSPOT_JNI_SETOBJECTFIELD_RETURN(
+HOTSPOT_JNI_SETOBJECTFIELD_RETURN();
-);
 #endif /* USDT2 */
 JNI_END
 #ifndef USDT2
 #define DEFINE_SETFIELD(Argument,Fieldname,Result,SigType,unionType) \
 JNIWrapper("ToReflectedField");
 #ifndef USDT2
 DTRACE_PROBE4(hotspot_jni, ToReflectedField__entry,
 env, cls, fieldID, isStatic);
 #else /* USDT2 */
-HOTSPOT_JNI_TOREFLECTEDFIELD_ENTRY(
+HOTSPOT_JNI_TOREFLECTEDFIELD_ENTRY(env, cls, (uintptr_t) fieldID, isStatic);
-env, cls, (uintptr_t) fieldID, isStatic);
 #endif /* USDT2 */
 jobject ret = NULL;
 DT_RETURN_MARK(ToReflectedField, jobject, (const jobject&)ret);
 fieldDescriptor fd;
 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(
+HOTSPOT_JNI_GETSTATICFIELDID_ENTRY(env, clazz, (char *) name, (char *) sig);
-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
 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(
+HOTSPOT_JNI_GETSTATICOBJECTFIELD_ENTRY(env, clazz, (uintptr_t) fieldID);
-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);
 }
 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(
+HOTSPOT_JNI_GETSTATICOBJECTFIELD_RETURN(ret);
-ret);
 #endif /* USDT2 */
 return ret;
 JNI_END
 #ifndef 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(
+HOTSPOT_JNI_SETSTATICOBJECTFIELD_ENTRY(env, clazz, (uintptr_t) fieldID, value);
-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.
 }
 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(
+HOTSPOT_JNI_SETSTATICOBJECTFIELD_RETURN();
-);
 #endif /* USDT2 */
 JNI_END
 #ifndef 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(
+HOTSPOT_JNI_NEWSTRING_ENTRY(env, (uint16_t *) unicodeChars, len);
-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);
 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(
+HOTSPOT_JNI_GETSTRINGLENGTH_ENTRY(env, string);
-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(
+HOTSPOT_JNI_GETSTRINGLENGTH_RETURN(ret);
-ret);
 #endif /* USDT2 */
 return ret;
 JNI_END
 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(
+HOTSPOT_JNI_GETSTRINGCHARS_ENTRY(env, string, (uintptr_t *) isCopy);
-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) {
 }
 }
 #ifndef USDT2
 DTRACE_PROBE1(hotspot_jni, GetStringChars__return, buf);
 #else /* USDT2 */
-HOTSPOT_JNI_GETSTRINGCHARS_RETURN(
+HOTSPOT_JNI_GETSTRINGCHARS_RETURN(buf);
-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(
+HOTSPOT_JNI_RELEASESTRINGCHARS_ENTRY(env, str, (uint16_t *) chars);
-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(
+HOTSPOT_JNI_RELEASESTRINGCHARS_RETURN();
-);
 #endif /* USDT2 */
 JNI_END
 // UTF Interface
 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(
+HOTSPOT_JNI_NEWSTRINGUTF_ENTRY(env, (char *) bytes);
-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);
 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(
+HOTSPOT_JNI_GETSTRINGUTFLENGTH_ENTRY(env, string);
-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(
+HOTSPOT_JNI_GETSTRINGUTFLENGTH_RETURN(ret);
-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(
+HOTSPOT_JNI_GETSTRINGUTFCHARS_ENTRY(env, string, (uintptr_t *) isCopy);
-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);
 }
 }
 #ifndef USDT2
 DTRACE_PROBE1(hotspot_jni, GetStringUTFChars__return, result);
 #else /* USDT2 */
-HOTSPOT_JNI_GETSTRINGUTFCHARS_RETURN(
+HOTSPOT_JNI_GETSTRINGUTFCHARS_RETURN(result);
-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(
+HOTSPOT_JNI_RELEASESTRINGUTFCHARS_ENTRY(env, str, (char *) chars);
-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(
+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(
+HOTSPOT_JNI_GETARRAYLENGTH_ENTRY(env, array);
-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(
+HOTSPOT_JNI_GETARRAYLENGTH_RETURN(ret);
-ret);
 #endif /* USDT2 */
 return ret;
 JNI_END
 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(
+HOTSPOT_JNI_NEWOBJECTARRAY_ENTRY(env, length, elementClass, initialElement);
-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);
 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(
+HOTSPOT_JNI_GETOBJECTARRAYELEMENT_ENTRY(env, array, index);
-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)) {
 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(
+HOTSPOT_JNI_SETOBJECTARRAYELEMENT_ENTRY(env, array, index, value);
-env, array, index, value);
 #endif /* USDT2 */
 DT_VOID_RETURN_MARK(SetObjectArrayElement);
 objArrayOop a = objArrayOop(JNIHandles::resolve_non_null(array));
 oop v = JNIHandles::resolve(value);
 jint nMethods))
 JNIWrapper("RegisterNatives");
 #ifndef USDT2
 DTRACE_PROBE4(hotspot_jni, RegisterNatives__entry, env, clazz, methods, nMethods);
 #else /* USDT2 */
-HOTSPOT_JNI_REGISTERNATIVES_ENTRY(
+HOTSPOT_JNI_REGISTERNATIVES_ENTRY(env, clazz, (void *) methods, nMethods);
-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)));
 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(
+HOTSPOT_JNI_UNREGISTERNATIVES_ENTRY(env, clazz);
-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++) {
 }
 }
 #ifndef USDT2
 DTRACE_PROBE1(hotspot_jni, UnregisterNatives__return, 0);
 #else /* USDT2 */
-HOTSPOT_JNI_UNREGISTERNATIVES_RETURN(
+HOTSPOT_JNI_UNREGISTERNATIVES_RETURN(0);
-0);
 #endif /* USDT2 */
 return 0;
 JNI_END
 //
 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(
+HOTSPOT_JNI_MONITORENTER_ENTRY(env, jobj);
-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
 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(
+HOTSPOT_JNI_MONITOREXIT_ENTRY(env, jobj);
-env, jobj);
 #endif /* USDT2 */
 jint ret = JNI_ERR;
 DT_RETURN_MARK(MonitorExit, jint, (const jint&)ret);
 // Don't do anything with a null object
 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(
+HOTSPOT_JNI_GETSTRINGREGION_ENTRY(env, string, start, len, buf);
-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) {
 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(
+HOTSPOT_JNI_GETSTRINGUTFREGION_ENTRY(env, string, start, len, buf);
-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) {
 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(
+HOTSPOT_JNI_GETPRIMITIVEARRAYCRITICAL_ENTRY(env, array, (uintptr_t *) isCopy);
-env, array, (uintptr_t *) isCopy);
 #endif /* USDT2 */
 GC_locker::lock_critical(thread);
 if (isCopy != NULL) {
 *isCopy = JNI_FALSE;
 }
 }
 void* ret = arrayOop(a)->base(type);
 #ifndef USDT2
 DTRACE_PROBE1(hotspot_jni, GetPrimitiveArrayCritical__return, ret);
 #else /* USDT2 */
-HOTSPOT_JNI_GETPRIMITIVEARRAYCRITICAL_RETURN(
+HOTSPOT_JNI_GETPRIMITIVEARRAYCRITICAL_RETURN(ret);
-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(
+HOTSPOT_JNI_RELEASEPRIMITIVEARRAYCRITICAL_ENTRY(env, array, carray, mode);
-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(
+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(
+HOTSPOT_JNI_GETSTRINGCRITICAL_ENTRY(env, string, (uintptr_t *) isCopy);
-env, string, (uintptr_t *) isCopy);
 #endif /* USDT2 */
 GC_locker::lock_critical(thread);
 if (isCopy != NULL) {
 *isCopy = JNI_FALSE;
 }
 ret = (jchar*) s_value->base(T_CHAR);
 }
 #ifndef USDT2
 DTRACE_PROBE1(hotspot_jni, GetStringCritical__return, ret);
 #else /* USDT2 */
-HOTSPOT_JNI_GETSTRINGCRITICAL_RETURN(
+HOTSPOT_JNI_GETSTRINGCRITICAL_RETURN((uint16_t *) ret);
-(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(
+HOTSPOT_JNI_RELEASESTRINGCRITICAL_ENTRY(env, str, (uint16_t *) chars);
-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(
+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(
+HOTSPOT_JNI_NEWWEAKGLOBALREF_ENTRY(env, ref);
-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(
+HOTSPOT_JNI_NEWWEAKGLOBALREF_RETURN(ret);
-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(
+HOTSPOT_JNI_DELETEWEAKGLOBALREF_ENTRY(env, ref);
-env, ref);
 #endif /* USDT2 */
 JNIHandles::destroy_weak_global(ref);
 #ifndef USDT2
 DTRACE_PROBE(hotspot_jni, DeleteWeakGlobalRef__return);
 #else /* USDT2 */
-HOTSPOT_JNI_DELETEWEAKGLOBALREF_RETURN(
+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(
+HOTSPOT_JNI_EXCEPTIONCHECK_ENTRY(env);
-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(
+HOTSPOT_JNI_EXCEPTIONCHECK_RETURN(ret);
-ret);
 #endif /* USDT2 */
 return ret;
 JNI_END
 JNIWrapper("jni_NewDirectByteBuffer");
 #ifndef USDT2
 DTRACE_PROBE3(hotspot_jni, NewDirectByteBuffer__entry, env, address, capacity);
 #else /* USDT2 */
-HOTSPOT_JNI_NEWDIRECTBYTEBUFFER_ENTRY(
+HOTSPOT_JNI_NEWDIRECTBYTEBUFFER_ENTRY(env, address, capacity);
-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(
+HOTSPOT_JNI_NEWDIRECTBYTEBUFFER_RETURN(NULL);
-NULL);
 #endif /* USDT2 */
 return NULL;
 }
 }
 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(
+HOTSPOT_JNI_NEWDIRECTBYTEBUFFER_RETURN(ret);
-ret);
 #endif /* USDT2 */
 return ret;
 }
 #ifndef USDT2
 JNIWrapper("jni_GetDirectBufferAddress");
 #ifndef USDT2
 DTRACE_PROBE2(hotspot_jni, GetDirectBufferAddress__entry, env, buf);
 #else /* USDT2 */
-HOTSPOT_JNI_GETDIRECTBUFFERADDRESS_ENTRY(
+HOTSPOT_JNI_GETDIRECTBUFFERADDRESS_ENTRY(env, buf);
-env, buf);
 #endif /* USDT2 */
 void* ret = NULL;
 DT_RETURN_MARK(GetDirectBufferAddress, void*, (const void*&)ret);
 if (!directBufferSupportInitializeEnded) {
 JNIWrapper("jni_GetDirectBufferCapacity");
 #ifndef USDT2
 DTRACE_PROBE2(hotspot_jni, GetDirectBufferCapacity__entry, env, buf);
 #else /* USDT2 */
-HOTSPOT_JNI_GETDIRECTBUFFERCAPACITY_ENTRY(
+HOTSPOT_JNI_GETDIRECTBUFFERCAPACITY_ENTRY(env, buf);
-env, buf);
 #endif /* USDT2 */
 jlong ret = -1;
 DT_RETURN_MARK(GetDirectBufferCapacity, jlong, (const jlong&)ret);
 if (!directBufferSupportInitializeEnded) {
 JNI_LEAF(jint, jni_GetVersion(JNIEnv *env))
 JNIWrapper("GetVersion");
 #ifndef USDT2
 DTRACE_PROBE1(hotspot_jni, GetVersion__entry, env);
 #else /* USDT2 */
-HOTSPOT_JNI_GETVERSION_ENTRY(
+HOTSPOT_JNI_GETVERSION_ENTRY(env);
-env);
 #endif /* USDT2 */
 #ifndef USDT2
 DTRACE_PROBE1(hotspot_jni, GetVersion__return, CurrentVersion);
 #else /* USDT2 */
-HOTSPOT_JNI_GETVERSION_RETURN(
+HOTSPOT_JNI_GETVERSION_RETURN(CurrentVersion);
-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(
+HOTSPOT_JNI_GETJAVAVM_ENTRY(env, (void **) vm);
-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(
+HOTSPOT_JNI_GETJAVAVM_RETURN(JNI_OK);
-JNI_OK);
 #endif /* USDT2 */
 return JNI_OK;
 JNI_END
 // Structure containing all jni functions
 _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(
+HOTSPOT_JNI_GETDEFAULTJAVAVMINITARGS_ENTRY(args_);
-args_);
 #endif /* USDT2 */
 JDK1_1InitArgs *args = (JDK1_1InitArgs *)args_;
 jint ret = JNI_ERR;
 DT_RETURN_MARK(GetDefaultJavaVMInitArgs, jint, (const jint&)ret);
 _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(
+HOTSPOT_JNI_CREATEJAVAVM_ENTRY((void **) vm, penv, args);
-(void **) vm, penv, args);
 #endif /* USDT2 */
 jint result = JNI_ERR;
 DT_RETURN_MARK(CreateJavaVM, jint, (const jint&)result);
 // JNIWrapper("GetCreatedJavaVMs");
 #ifndef USDT2
 HS_DTRACE_PROBE3(hotspot_jni, GetCreatedJavaVMs__entry, \
 vm_buf, bufLen, numVMs);
 #else /* USDT2 */
-HOTSPOT_JNI_GETCREATEDJAVAVMS_ENTRY(
+HOTSPOT_JNI_GETCREATEDJAVAVMS_ENTRY((void **) vm_buf, bufLen, (uintptr_t *) numVMs);
-(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(
+HOTSPOT_JNI_GETCREATEDJAVAVMS_RETURN(JNI_OK);
-JNI_OK);
 #endif /* USDT2 */
 return JNI_OK;
 }
 extern "C" {
 jint JNICALL jni_DestroyJavaVM(JavaVM *vm) {
 #ifndef USDT2
 DTRACE_PROBE1(hotspot_jni, DestroyJavaVM__entry, vm);
 #else /* USDT2 */
-HOTSPOT_JNI_DESTROYJAVAVM_ENTRY(
+HOTSPOT_JNI_DESTROYJAVAVM_ENTRY(vm);
-vm);
 #endif /* USDT2 */
 jint res = JNI_ERR;
 DT_RETURN_MARK(DestroyJavaVM, jint, (const jint&)res);
 if (!vm_created) {
 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(
+HOTSPOT_JNI_ATTACHCURRENTTHREAD_ENTRY(vm, penv, _args);
-vm, penv, _args);
 #endif /* USDT2 */
 if (!vm_created) {
 #ifndef USDT2
 DTRACE_PROBE1(hotspot_jni, AttachCurrentThread__return, JNI_ERR);
 #else /* USDT2 */
-HOTSPOT_JNI_ATTACHCURRENTTHREAD_RETURN(
+HOTSPOT_JNI_ATTACHCURRENTTHREAD_RETURN((uint32_t) JNI_ERR);
-(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(
+HOTSPOT_JNI_ATTACHCURRENTTHREAD_RETURN(ret);
-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(
+HOTSPOT_JNI_DETACHCURRENTTHREAD_ENTRY(vm);
-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(
+HOTSPOT_JNI_DETACHCURRENTTHREAD_RETURN(JNI_OK);
-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(
+HOTSPOT_JNI_DETACHCURRENTTHREAD_RETURN((uint32_t) JNI_ERR);
-(uint32_t) JNI_ERR);
 #endif /* USDT2 */
 // Can't detach a thread that's running java, that can't work.
 return JNI_ERR;
 }
 delete thread;
 #ifndef USDT2
 DTRACE_PROBE1(hotspot_jni, DetachCurrentThread__return, JNI_OK);
 #else /* USDT2 */
-HOTSPOT_JNI_DETACHCURRENTTHREAD_RETURN(
+HOTSPOT_JNI_DETACHCURRENTTHREAD_RETURN(JNI_OK);
-JNI_OK);
 #endif /* USDT2 */
 return JNI_OK;
 }
 #ifndef 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(
+HOTSPOT_JNI_GETENV_ENTRY(vm, penv, version);
-vm, penv, version);
 #endif /* USDT2 */
 jint ret = JNI_ERR;
 DT_RETURN_MARK(GetEnv, jint, (const jint&)ret);
 if (!vm_created) {
 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(
+HOTSPOT_JNI_ATTACHCURRENTTHREADASDAEMON_ENTRY(vm, penv, _args);
-vm, penv, _args);
 #endif /* USDT2 */
 if (!vm_created) {
 #ifndef USDT2
 DTRACE_PROBE1(hotspot_jni, AttachCurrentThreadAsDaemon__return, JNI_ERR);
 #else /* USDT2 */
-HOTSPOT_JNI_ATTACHCURRENTTHREADASDAEMON_RETURN(
+HOTSPOT_JNI_ATTACHCURRENTTHREADASDAEMON_RETURN((uint32_t) JNI_ERR);
-(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(
+HOTSPOT_JNI_ATTACHCURRENTTHREADASDAEMON_RETURN(ret);
-ret);
 #endif /* USDT2 */
 return ret;
 }

changeset 22520	b9e88eed82d7
parent 22190	d306a75a70d3
child 22532	1fc87ea15795