# HG changeset patch # User sla # Date 1391784505 -3600 # Node ID 118252286d45eaa3d46536779a8a48028c4747ba # Parent 9341a9963d36cccebadae3c903f0d355e5ad6c5e [mq]: usdt1-gone diff --git a/src/share/vm/code/nmethod.cpp b/src/share/vm/code/nmethod.cpp --- a/src/share/vm/code/nmethod.cpp +++ b/src/share/vm/code/nmethod.cpp @@ -50,27 +50,6 @@ // Only bother with this argument setup if dtrace is available -#ifndef USDT2 -HS_DTRACE_PROBE_DECL8(hotspot, compiled__method__load, - const char*, int, const char*, int, const char*, int, void*, size_t); - -HS_DTRACE_PROBE_DECL6(hotspot, compiled__method__unload, - char*, int, char*, int, char*, int); - -#define DTRACE_METHOD_UNLOAD_PROBE(method) \ - { \ - Method* m = (method); \ - if (m != NULL) { \ - Symbol* klass_name = m->klass_name(); \ - Symbol* name = m->name(); \ - Symbol* signature = m->signature(); \ - HS_DTRACE_PROBE6(hotspot, compiled__method__unload, \ - klass_name->bytes(), klass_name->utf8_length(), \ - name->bytes(), name->utf8_length(), \ - signature->bytes(), signature->utf8_length()); \ - } \ - } -#else /* USDT2 */ #define DTRACE_METHOD_UNLOAD_PROBE(method) \ { \ Method* m = (method); \ @@ -84,7 +63,6 @@ (char *) signature->bytes(), signature->utf8_length()); \ } \ } -#endif /* USDT2 */ #else // ndef DTRACE_ENABLED @@ -1520,16 +1498,6 @@ void nmethod::post_compiled_method_load_event() { Method* moop = method(); -#ifndef USDT2 - HS_DTRACE_PROBE8(hotspot, compiled__method__load, - moop->klass_name()->bytes(), - moop->klass_name()->utf8_length(), - moop->name()->bytes(), - moop->name()->utf8_length(), - moop->signature()->bytes(), - moop->signature()->utf8_length(), - insts_begin(), insts_size()); -#else /* USDT2 */ HOTSPOT_COMPILED_METHOD_LOAD( (char *) moop->klass_name()->bytes(), moop->klass_name()->utf8_length(), @@ -1538,7 +1506,6 @@ (char *) moop->signature()->bytes(), moop->signature()->utf8_length(), insts_begin(), insts_size()); -#endif /* USDT2 */ if (JvmtiExport::should_post_compiled_method_load() || JvmtiExport::should_post_compiled_method_unload()) { diff --git a/src/share/vm/compiler/compileBroker.cpp b/src/share/vm/compiler/compileBroker.cpp --- a/src/share/vm/compiler/compileBroker.cpp +++ b/src/share/vm/compiler/compileBroker.cpp @@ -60,38 +60,6 @@ // Only bother with this argument setup if dtrace is available -#ifndef USDT2 -HS_DTRACE_PROBE_DECL8(hotspot, method__compile__begin, - char*, intptr_t, char*, intptr_t, char*, intptr_t, char*, intptr_t); -HS_DTRACE_PROBE_DECL9(hotspot, method__compile__end, - char*, intptr_t, char*, intptr_t, char*, intptr_t, char*, intptr_t, bool); - -#define DTRACE_METHOD_COMPILE_BEGIN_PROBE(method, comp_name) \ - { \ - Symbol* klass_name = (method)->klass_name(); \ - Symbol* name = (method)->name(); \ - Symbol* signature = (method)->signature(); \ - HS_DTRACE_PROBE8(hotspot, method__compile__begin, \ - comp_name, strlen(comp_name), \ - klass_name->bytes(), klass_name->utf8_length(), \ - name->bytes(), name->utf8_length(), \ - signature->bytes(), signature->utf8_length()); \ - } - -#define DTRACE_METHOD_COMPILE_END_PROBE(method, comp_name, success) \ - { \ - Symbol* klass_name = (method)->klass_name(); \ - Symbol* name = (method)->name(); \ - Symbol* signature = (method)->signature(); \ - HS_DTRACE_PROBE9(hotspot, method__compile__end, \ - comp_name, strlen(comp_name), \ - klass_name->bytes(), klass_name->utf8_length(), \ - name->bytes(), name->utf8_length(), \ - signature->bytes(), signature->utf8_length(), (success)); \ - } - -#else /* USDT2 */ - #define DTRACE_METHOD_COMPILE_BEGIN_PROBE(method, comp_name) \ { \ Symbol* klass_name = (method)->klass_name(); \ @@ -115,7 +83,6 @@ (char *) name->bytes(), name->utf8_length(), \ (char *) signature->bytes(), signature->utf8_length(), (success)); \ } -#endif /* USDT2 */ #else // ndef DTRACE_ENABLED diff --git a/src/share/vm/gc_implementation/concurrentMarkSweep/vmCMSOperations.cpp b/src/share/vm/gc_implementation/concurrentMarkSweep/vmCMSOperations.cpp --- a/src/share/vm/gc_implementation/concurrentMarkSweep/vmCMSOperations.cpp +++ b/src/share/vm/gc_implementation/concurrentMarkSweep/vmCMSOperations.cpp @@ -35,14 +35,6 @@ #include "utilities/dtrace.hpp" -#ifndef USDT2 -HS_DTRACE_PROBE_DECL(hs_private, cms__initmark__begin); -HS_DTRACE_PROBE_DECL(hs_private, cms__initmark__end); - -HS_DTRACE_PROBE_DECL(hs_private, cms__remark__begin); -HS_DTRACE_PROBE_DECL(hs_private, cms__remark__end); -#endif /* !USDT2 */ - ////////////////////////////////////////////////////////// // Methods in abstract class VM_CMS_Operation ////////////////////////////////////////////////////////// @@ -138,11 +130,7 @@ // Nothing to do. return; } -#ifndef USDT2 - HS_DTRACE_PROBE(hs_private, cms__initmark__begin); -#else /* USDT2 */ HS_PRIVATE_CMS_INITMARK_BEGIN(); -#endif /* USDT2 */ _collector->_gc_timer_cm->register_gc_pause_start("Initial Mark"); @@ -158,11 +146,7 @@ _collector->_gc_timer_cm->register_gc_pause_end(); -#ifndef USDT2 - HS_DTRACE_PROBE(hs_private, cms__initmark__end); -#else /* USDT2 */ HS_PRIVATE_CMS_INITMARK_END(); -#endif /* USDT2 */ } ////////////////////////////////////////////////////////// @@ -173,11 +157,7 @@ // Nothing to do. return; } -#ifndef USDT2 - HS_DTRACE_PROBE(hs_private, cms__remark__begin); -#else /* USDT2 */ HS_PRIVATE_CMS_REMARK_BEGIN(); -#endif /* USDT2 */ _collector->_gc_timer_cm->register_gc_pause_start("Final Mark"); @@ -194,11 +174,7 @@ _collector->save_heap_summary(); _collector->_gc_timer_cm->register_gc_pause_end(); -#ifndef USDT2 - HS_DTRACE_PROBE(hs_private, cms__remark__end); -#else /* USDT2 */ HS_PRIVATE_CMS_REMARK_END(); -#endif /* USDT2 */ } // VM operation to invoke a concurrent collection of a diff --git a/src/share/vm/gc_implementation/shared/vmGCOperations.cpp b/src/share/vm/gc_implementation/shared/vmGCOperations.cpp --- a/src/share/vm/gc_implementation/shared/vmGCOperations.cpp +++ b/src/share/vm/gc_implementation/shared/vmGCOperations.cpp @@ -41,33 +41,18 @@ #include "gc_implementation/g1/g1CollectedHeap.inline.hpp" #endif // INCLUDE_ALL_GCS -#ifndef USDT2 -HS_DTRACE_PROBE_DECL1(hotspot, gc__begin, bool); -HS_DTRACE_PROBE_DECL(hotspot, gc__end); -#endif /* !USDT2 */ - // The same dtrace probe can't be inserted in two different files, so we // have to call it here, so it's only in one file. Can't create new probes // for the other file anymore. The dtrace probes have to remain stable. void VM_GC_Operation::notify_gc_begin(bool full) { -#ifndef USDT2 - HS_DTRACE_PROBE1(hotspot, gc__begin, full); - HS_DTRACE_WORKAROUND_TAIL_CALL_BUG(); -#else /* USDT2 */ HOTSPOT_GC_BEGIN( full); HS_DTRACE_WORKAROUND_TAIL_CALL_BUG(); -#endif /* USDT2 */ } void VM_GC_Operation::notify_gc_end() { -#ifndef USDT2 - HS_DTRACE_PROBE(hotspot, gc__end); - HS_DTRACE_WORKAROUND_TAIL_CALL_BUG(); -#else /* USDT2 */ HOTSPOT_GC_END(); HS_DTRACE_WORKAROUND_TAIL_CALL_BUG(); -#endif /* USDT2 */ } void VM_GC_Operation::acquire_pending_list_lock() { diff --git a/src/share/vm/oops/instanceKlass.cpp b/src/share/vm/oops/instanceKlass.cpp --- a/src/share/vm/oops/instanceKlass.cpp +++ b/src/share/vm/oops/instanceKlass.cpp @@ -77,51 +77,6 @@ #ifdef DTRACE_ENABLED -#ifndef USDT2 - -HS_DTRACE_PROBE_DECL4(hotspot, class__initialization__required, - char*, intptr_t, oop, intptr_t); -HS_DTRACE_PROBE_DECL5(hotspot, class__initialization__recursive, - char*, intptr_t, oop, intptr_t, int); -HS_DTRACE_PROBE_DECL5(hotspot, class__initialization__concurrent, - char*, intptr_t, oop, intptr_t, int); -HS_DTRACE_PROBE_DECL5(hotspot, class__initialization__erroneous, - char*, intptr_t, oop, intptr_t, int); -HS_DTRACE_PROBE_DECL5(hotspot, class__initialization__super__failed, - char*, intptr_t, oop, intptr_t, int); -HS_DTRACE_PROBE_DECL5(hotspot, class__initialization__clinit, - char*, intptr_t, oop, intptr_t, int); -HS_DTRACE_PROBE_DECL5(hotspot, class__initialization__error, - char*, intptr_t, oop, intptr_t, int); -HS_DTRACE_PROBE_DECL5(hotspot, class__initialization__end, - char*, intptr_t, oop, intptr_t, int); - -#define DTRACE_CLASSINIT_PROBE(type, clss, thread_type) \ - { \ - char* data = NULL; \ - int len = 0; \ - Symbol* name = (clss)->name(); \ - if (name != NULL) { \ - data = (char*)name->bytes(); \ - len = name->utf8_length(); \ - } \ - HS_DTRACE_PROBE4(hotspot, class__initialization__##type, \ - data, len, SOLARIS_ONLY((void *))(clss)->class_loader(), thread_type); \ - } - -#define DTRACE_CLASSINIT_PROBE_WAIT(type, clss, thread_type, wait) \ - { \ - char* data = NULL; \ - int len = 0; \ - Symbol* name = (clss)->name(); \ - if (name != NULL) { \ - data = (char*)name->bytes(); \ - len = name->utf8_length(); \ - } \ - HS_DTRACE_PROBE5(hotspot, class__initialization__##type, \ - data, len, SOLARIS_ONLY((void *))(clss)->class_loader(), thread_type, wait); \ - } -#else /* USDT2 */ #define HOTSPOT_CLASS_INITIALIZATION_required HOTSPOT_CLASS_INITIALIZATION_REQUIRED #define HOTSPOT_CLASS_INITIALIZATION_recursive HOTSPOT_CLASS_INITIALIZATION_RECURSIVE @@ -156,7 +111,6 @@ HOTSPOT_CLASS_INITIALIZATION_##type( \ data, len, (clss)->class_loader(), thread_type, wait); \ } -#endif /* USDT2 */ #else // ndef DTRACE_ENABLED diff --git a/src/share/vm/prims/jni.cpp b/src/share/vm/prims/jni.cpp --- a/src/share/vm/prims/jni.cpp +++ b/src/share/vm/prims/jni.cpp @@ -114,33 +114,6 @@ // 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 { \ @@ -162,7 +135,6 @@ } \ } \ ) -#endif /* USDT2 */ // Place these macros in the function to mark the return. Non-void // functions need the type and address of the return value. @@ -191,15 +163,9 @@ // 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) ) @@ -358,24 +324,16 @@ // 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); @@ -421,20 +379,13 @@ 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); @@ -498,20 +449,14 @@ 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); @@ -538,20 +483,14 @@ 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); @@ -586,20 +525,15 @@ 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); @@ -615,20 +549,14 @@ 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); @@ -657,21 +585,16 @@ 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); @@ -679,28 +602,20 @@ 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); @@ -708,20 +623,15 @@ 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); @@ -750,30 +660,23 @@ 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(); @@ -809,21 +712,15 @@ } } } -#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. @@ -832,21 +729,16 @@ 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 @@ -855,18 +747,12 @@ 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(); @@ -875,22 +761,16 @@ 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(); @@ -905,127 +785,91 @@ 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 */ + +HOTSPOT_JNI_NEWGLOBALREF_ENTRY(env, ref); + 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)) @@ -1036,11 +880,8 @@ 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 @@ -1369,21 +1210,14 @@ 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); @@ -1392,20 +1226,14 @@ 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); @@ -1417,20 +1245,15 @@ 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); @@ -1442,20 +1265,15 @@ 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); @@ -1473,29 +1291,22 @@ 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; @@ -1505,11 +1316,8 @@ 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 @@ -1569,17 +1377,9 @@ 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 @@ -1587,17 +1387,9 @@ 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 @@ -1607,82 +1399,6 @@ // 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) \ @@ -1849,15 +1565,10 @@ 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; @@ -1871,11 +1582,7 @@ 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); @@ -1886,11 +1593,7 @@ 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); @@ -1899,80 +1602,6 @@ 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) \ @@ -2142,17 +1771,11 @@ , 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; @@ -2167,13 +1790,8 @@ 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); @@ -2184,13 +1802,8 @@ 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); @@ -2198,80 +1811,6 @@ 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) \ @@ -2445,15 +1984,10 @@ , 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; @@ -2467,11 +2001,7 @@ 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); @@ -2482,11 +2012,7 @@ 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); @@ -2500,21 +2026,13 @@ // -#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); @@ -2546,11 +2064,7 @@ 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); @@ -2580,50 +2094,11 @@ } } #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) \ @@ -2676,7 +2151,6 @@ 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; @@ -2705,11 +2179,7 @@ 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); @@ -2722,48 +2192,9 @@ 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) \ @@ -2813,23 +2244,13 @@ 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); @@ -2859,21 +2280,13 @@ // // 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); @@ -2909,11 +2322,7 @@ 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 @@ -2925,46 +2334,10 @@ 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) \ @@ -3006,15 +2379,10 @@ , 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. @@ -3025,46 +2393,10 @@ 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) \ @@ -3111,7 +2443,6 @@ DEFINE_SETSTATICFIELD(jdouble, double, Double, 'D', d , HOTSPOT_JNI_SETSTATICDOUBLEFIELD_ENTRY(env, clazz, (uintptr_t) fieldID), HOTSPOT_JNI_SETSTATICDOUBLEFIELD_RETURN()) -#endif /* USDT2 */ // // String Operations @@ -3119,20 +2450,12 @@ // 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); @@ -3143,21 +2466,13 @@ 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 @@ -3165,11 +2480,7 @@ 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); @@ -3189,52 +2500,32 @@ } } } -#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); @@ -3246,32 +2537,20 @@ 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) { @@ -3285,48 +2564,28 @@ } } } -#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 @@ -3335,20 +2594,12 @@ // 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))); @@ -3366,20 +2617,12 @@ 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)); @@ -3393,20 +2636,12 @@ } 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)); @@ -3425,33 +2660,6 @@ 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) \ @@ -3495,7 +2703,6 @@ 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. @@ -3513,47 +2720,6 @@ } -#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) \ @@ -3611,39 +2777,7 @@ 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);\ @@ -3690,41 +2824,7 @@ 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); \ @@ -3774,41 +2874,7 @@ 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); \ @@ -3858,7 +2924,6 @@ DEFINE_SETSCALARARRAYREGION(T_DOUBLE, jdouble, Double, double , HOTSPOT_JNI_SETDOUBLEARRAYREGION_ENTRY(env, array, start, len, (double *) buf), HOTSPOT_JNI_SETDOUBLEARRAYREGION_RETURN()) -#endif /* USDT2 */ // @@ -3943,22 +3008,14 @@ 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); @@ -3996,11 +3053,7 @@ 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()) { @@ -4012,11 +3065,7 @@ } } } -#ifndef USDT2 - DTRACE_PROBE1(hotspot_jni, UnregisterNatives__return, 0); -#else /* USDT2 */ HOTSPOT_JNI_UNREGISTERNATIVES_RETURN(0); -#endif /* USDT2 */ return 0; JNI_END @@ -4024,19 +3073,11 @@ // 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); @@ -4051,19 +3092,11 @@ 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); @@ -4083,20 +3116,12 @@ // 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); @@ -4111,20 +3136,12 @@ } 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); @@ -4150,11 +3167,7 @@ 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; @@ -4168,39 +3181,23 @@ 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; @@ -4215,80 +3212,44 @@ } 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 @@ -4380,19 +3341,11 @@ 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; } } @@ -4403,20 +3356,12 @@ // 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) { @@ -4424,11 +3369,7 @@ 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); @@ -4446,12 +3387,8 @@ 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) { @@ -4459,11 +3396,7 @@ 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); @@ -4490,16 +3423,8 @@ 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 @@ -4507,17 +3432,9 @@ 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 @@ -4895,20 +3812,11 @@ #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); @@ -4990,20 +3898,11 @@ #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); @@ -5125,50 +4024,30 @@ 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); @@ -5320,58 +4199,34 @@ 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; } @@ -5392,27 +4247,15 @@ 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); @@ -5466,27 +4309,15 @@ 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; } diff --git a/src/share/vm/prims/jvm.cpp b/src/share/vm/prims/jvm.cpp --- a/src/share/vm/prims/jvm.cpp +++ b/src/share/vm/prims/jvm.cpp @@ -82,12 +82,6 @@ #include -#ifndef USDT2 -HS_DTRACE_PROBE_DECL1(hotspot, thread__sleep__begin, long long); -HS_DTRACE_PROBE_DECL1(hotspot, thread__sleep__end, int); -HS_DTRACE_PROBE_DECL0(hotspot, thread__yield); -#endif /* !USDT2 */ - /* NOTE about use of any ctor or function call that can trigger a safepoint/GC: such ctors and calls MUST NOT come between an oop declaration/init and its @@ -3002,11 +2996,8 @@ JVM_ENTRY(void, JVM_Yield(JNIEnv *env, jclass threadClass)) JVMWrapper("JVM_Yield"); if (os::dont_yield()) return; -#ifndef USDT2 - HS_DTRACE_PROBE0(hotspot, thread__yield); -#else /* USDT2 */ HOTSPOT_THREAD_YIELD(); -#endif /* USDT2 */ + // When ConvertYieldToSleep is off (default), this matches the classic VM use of yield. // Critical for similar threading behaviour if (ConvertYieldToSleep) { @@ -3032,12 +3023,7 @@ // And set new thread state to SLEEPING. JavaThreadSleepState jtss(thread); -#ifndef USDT2 - HS_DTRACE_PROBE1(hotspot, thread__sleep__begin, millis); -#else /* USDT2 */ - HOTSPOT_THREAD_SLEEP_BEGIN( - millis); -#endif /* USDT2 */ + HOTSPOT_THREAD_SLEEP_BEGIN(millis); EventThreadSleep event; @@ -3065,12 +3051,8 @@ event.set_time(millis); event.commit(); } -#ifndef USDT2 - HS_DTRACE_PROBE1(hotspot, thread__sleep__end,1); -#else /* USDT2 */ - HOTSPOT_THREAD_SLEEP_END( - 1); -#endif /* USDT2 */ + HOTSPOT_THREAD_SLEEP_END(1); + // TODO-FIXME: THROW_MSG returns which means we will not call set_state() // to properly restore the thread state. That's likely wrong. THROW_MSG(vmSymbols::java_lang_InterruptedException(), "sleep interrupted"); @@ -3082,12 +3064,7 @@ event.set_time(millis); event.commit(); } -#ifndef USDT2 - HS_DTRACE_PROBE1(hotspot, thread__sleep__end,0); -#else /* USDT2 */ - HOTSPOT_THREAD_SLEEP_END( - 0); -#endif /* USDT2 */ + HOTSPOT_THREAD_SLEEP_END(0); JVM_END JVM_ENTRY(jobject, JVM_CurrentThread(JNIEnv* env, jclass threadClass)) diff --git a/src/share/vm/prims/unsafe.cpp b/src/share/vm/prims/unsafe.cpp --- a/src/share/vm/prims/unsafe.cpp +++ b/src/share/vm/prims/unsafe.cpp @@ -44,11 +44,6 @@ * Implementation of class sun.misc.Unsafe */ -#ifndef USDT2 -HS_DTRACE_PROBE_DECL3(hotspot, thread__park__begin, uintptr_t, int, long long); -HS_DTRACE_PROBE_DECL1(hotspot, thread__park__end, uintptr_t); -HS_DTRACE_PROBE_DECL1(hotspot, thread__unpark, uintptr_t); -#endif /* !USDT2 */ #define MAX_OBJECT_SIZE \ ( arrayOopDesc::header_size(T_DOUBLE) * HeapWordSize \ @@ -1206,20 +1201,12 @@ UNSAFE_ENTRY(void, Unsafe_Park(JNIEnv *env, jobject unsafe, jboolean isAbsolute, jlong time)) UnsafeWrapper("Unsafe_Park"); EventThreadPark event; -#ifndef USDT2 - HS_DTRACE_PROBE3(hotspot, thread__park__begin, thread->parker(), (int) isAbsolute, time); -#else /* USDT2 */ - HOTSPOT_THREAD_PARK_BEGIN( - (uintptr_t) thread->parker(), (int) isAbsolute, time); -#endif /* USDT2 */ + HOTSPOT_THREAD_PARK_BEGIN((uintptr_t) thread->parker(), (int) isAbsolute, time); + JavaThreadParkedState jtps(thread, time != 0); thread->parker()->park(isAbsolute != 0, time); -#ifndef USDT2 - HS_DTRACE_PROBE1(hotspot, thread__park__end, thread->parker()); -#else /* USDT2 */ - HOTSPOT_THREAD_PARK_END( - (uintptr_t) thread->parker()); -#endif /* USDT2 */ + + HOTSPOT_THREAD_PARK_END((uintptr_t) thread->parker()); if (event.should_commit()) { oop obj = thread->current_park_blocker(); event.set_klass((obj != NULL) ? obj->klass() : NULL); @@ -1258,12 +1245,7 @@ } } if (p != NULL) { -#ifndef USDT2 - HS_DTRACE_PROBE1(hotspot, thread__unpark, p); -#else /* USDT2 */ - HOTSPOT_THREAD_UNPARK( - (uintptr_t) p); -#endif /* USDT2 */ + HOTSPOT_THREAD_UNPARK((uintptr_t) p); p->unpark(); } UNSAFE_END diff --git a/src/share/vm/runtime/java.cpp b/src/share/vm/runtime/java.cpp --- a/src/share/vm/runtime/java.cpp +++ b/src/share/vm/runtime/java.cpp @@ -97,9 +97,6 @@ #include "opto/runtime.hpp" #endif -#ifndef USDT2 -HS_DTRACE_PROBE_DECL(hotspot, vm__shutdown); -#endif /* !USDT2 */ #ifndef PRODUCT @@ -603,13 +600,8 @@ void notify_vm_shutdown() { // For now, just a dtrace probe. -#ifndef USDT2 - HS_DTRACE_PROBE(hotspot, vm__shutdown); - HS_DTRACE_WORKAROUND_TAIL_CALL_BUG(); -#else /* USDT2 */ HOTSPOT_VM_SHUTDOWN(); HS_DTRACE_WORKAROUND_TAIL_CALL_BUG(); -#endif /* USDT2 */ } void vm_direct_exit(int code) { diff --git a/src/share/vm/runtime/objectMonitor.cpp b/src/share/vm/runtime/objectMonitor.cpp --- a/src/share/vm/runtime/objectMonitor.cpp +++ b/src/share/vm/runtime/objectMonitor.cpp @@ -78,39 +78,6 @@ len = klassname->utf8_length(); \ } -#ifndef USDT2 - -HS_DTRACE_PROBE_DECL4(hotspot, monitor__notify, - jlong, uintptr_t, char*, int); -HS_DTRACE_PROBE_DECL4(hotspot, monitor__notifyAll, - jlong, uintptr_t, char*, int); -HS_DTRACE_PROBE_DECL4(hotspot, monitor__contended__enter, - jlong, uintptr_t, char*, int); -HS_DTRACE_PROBE_DECL4(hotspot, monitor__contended__entered, - jlong, uintptr_t, char*, int); -HS_DTRACE_PROBE_DECL4(hotspot, monitor__contended__exit, - jlong, uintptr_t, char*, int); - -#define DTRACE_MONITOR_WAIT_PROBE(monitor, obj, thread, millis) \ - { \ - if (DTraceMonitorProbes) { \ - DTRACE_MONITOR_PROBE_COMMON(obj, thread); \ - HS_DTRACE_PROBE5(hotspot, monitor__wait, jtid, \ - (monitor), bytes, len, (millis)); \ - } \ - } - -#define DTRACE_MONITOR_PROBE(probe, monitor, obj, thread) \ - { \ - if (DTraceMonitorProbes) { \ - DTRACE_MONITOR_PROBE_COMMON(obj, thread); \ - HS_DTRACE_PROBE4(hotspot, monitor__##probe, jtid, \ - (uintptr_t)(monitor), bytes, len); \ - } \ - } - -#else /* USDT2 */ - #define DTRACE_MONITOR_WAIT_PROBE(monitor, obj, thread, millis) \ { \ if (DTraceMonitorProbes) { \ @@ -135,7 +102,6 @@ } \ } -#endif /* USDT2 */ #else // ndef DTRACE_ENABLED #define DTRACE_MONITOR_WAIT_PROBE(obj, thread, millis, mon) {;} diff --git a/src/share/vm/runtime/sharedRuntime.cpp b/src/share/vm/runtime/sharedRuntime.cpp --- a/src/share/vm/runtime/sharedRuntime.cpp +++ b/src/share/vm/runtime/sharedRuntime.cpp @@ -127,14 +127,6 @@ #include -#ifndef USDT2 -HS_DTRACE_PROBE_DECL4(hotspot, object__alloc, Thread*, char*, int, size_t); -HS_DTRACE_PROBE_DECL7(hotspot, method__entry, int, - char*, int, char*, int, char*, int); -HS_DTRACE_PROBE_DECL7(hotspot, method__return, int, - char*, int, char*, int, char*, int); -#endif /* !USDT2 */ - // Implementation of SharedRuntime #ifndef PRODUCT @@ -969,14 +961,9 @@ Klass* klass = o->klass(); int size = o->size(); Symbol* name = klass->name(); -#ifndef USDT2 - HS_DTRACE_PROBE4(hotspot, object__alloc, get_java_tid(thread), - name->bytes(), name->utf8_length(), size * HeapWordSize); -#else /* USDT2 */ HOTSPOT_OBJECT_ALLOC( get_java_tid(thread), (char *) name->bytes(), name->utf8_length(), size * HeapWordSize); -#endif /* USDT2 */ return 0; } @@ -986,18 +973,11 @@ Symbol* kname = method->klass_name(); Symbol* name = method->name(); Symbol* sig = method->signature(); -#ifndef USDT2 - HS_DTRACE_PROBE7(hotspot, method__entry, get_java_tid(thread), - kname->bytes(), kname->utf8_length(), - name->bytes(), name->utf8_length(), - sig->bytes(), sig->utf8_length()); -#else /* USDT2 */ HOTSPOT_METHOD_ENTRY( get_java_tid(thread), (char *) kname->bytes(), kname->utf8_length(), (char *) name->bytes(), name->utf8_length(), (char *) sig->bytes(), sig->utf8_length()); -#endif /* USDT2 */ return 0; JRT_END @@ -1007,18 +987,11 @@ Symbol* kname = method->klass_name(); Symbol* name = method->name(); Symbol* sig = method->signature(); -#ifndef USDT2 - HS_DTRACE_PROBE7(hotspot, method__return, get_java_tid(thread), - kname->bytes(), kname->utf8_length(), - name->bytes(), name->utf8_length(), - sig->bytes(), sig->utf8_length()); -#else /* USDT2 */ HOTSPOT_METHOD_RETURN( get_java_tid(thread), (char *) kname->bytes(), kname->utf8_length(), (char *) name->bytes(), name->utf8_length(), (char *) sig->bytes(), sig->utf8_length()); -#endif /* USDT2 */ return 0; JRT_END diff --git a/src/share/vm/runtime/synchronizer.cpp b/src/share/vm/runtime/synchronizer.cpp --- a/src/share/vm/runtime/synchronizer.cpp +++ b/src/share/vm/runtime/synchronizer.cpp @@ -84,32 +84,6 @@ len = klassname->utf8_length(); \ } -#ifndef USDT2 -HS_DTRACE_PROBE_DECL5(hotspot, monitor__wait, - jlong, uintptr_t, char*, int, long); -HS_DTRACE_PROBE_DECL4(hotspot, monitor__waited, - jlong, uintptr_t, char*, int); - -#define DTRACE_MONITOR_WAIT_PROBE(monitor, obj, thread, millis) \ - { \ - if (DTraceMonitorProbes) { \ - DTRACE_MONITOR_PROBE_COMMON(obj, thread); \ - HS_DTRACE_PROBE5(hotspot, monitor__wait, jtid, \ - (monitor), bytes, len, (millis)); \ - } \ - } - -#define DTRACE_MONITOR_PROBE(probe, monitor, obj, thread) \ - { \ - if (DTraceMonitorProbes) { \ - DTRACE_MONITOR_PROBE_COMMON(obj, thread); \ - HS_DTRACE_PROBE4(hotspot, monitor__##probe, jtid, \ - (uintptr_t)(monitor), bytes, len); \ - } \ - } - -#else /* USDT2 */ - #define DTRACE_MONITOR_WAIT_PROBE(monitor, obj, thread, millis) \ { \ if (DTraceMonitorProbes) { \ @@ -130,7 +104,6 @@ } \ } -#endif /* USDT2 */ #else // ndef DTRACE_ENABLED #define DTRACE_MONITOR_WAIT_PROBE(obj, thread, millis, mon) {;} diff --git a/src/share/vm/runtime/thread.cpp b/src/share/vm/runtime/thread.cpp --- a/src/share/vm/runtime/thread.cpp +++ b/src/share/vm/runtime/thread.cpp @@ -112,29 +112,6 @@ // Only bother with this argument setup if dtrace is available -#ifndef USDT2 -HS_DTRACE_PROBE_DECL(hotspot, vm__init__begin); -HS_DTRACE_PROBE_DECL(hotspot, vm__init__end); -HS_DTRACE_PROBE_DECL5(hotspot, thread__start, char*, intptr_t, - intptr_t, intptr_t, bool); -HS_DTRACE_PROBE_DECL5(hotspot, thread__stop, char*, intptr_t, - intptr_t, intptr_t, bool); - -#define DTRACE_THREAD_PROBE(probe, javathread) \ - { \ - ResourceMark rm(this); \ - int len = 0; \ - const char* name = (javathread)->get_thread_name(); \ - len = strlen(name); \ - HS_DTRACE_PROBE5(hotspot, thread__##probe, \ - name, len, \ - java_lang_Thread::thread_id((javathread)->threadObj()), \ - (javathread)->osthread()->thread_id(), \ - java_lang_Thread::is_daemon((javathread)->threadObj())); \ - } - -#else /* USDT2 */ - #define HOTSPOT_THREAD_PROBE_start HOTSPOT_THREAD_START #define HOTSPOT_THREAD_PROBE_stop HOTSPOT_THREAD_STOP @@ -151,8 +128,6 @@ java_lang_Thread::is_daemon((javathread)->threadObj())); \ } -#endif /* USDT2 */ - #else // ndef DTRACE_ENABLED #define DTRACE_THREAD_PROBE(probe, javathread) @@ -3391,11 +3366,7 @@ os::pause(); } -#ifndef USDT2 - HS_DTRACE_PROBE(hotspot, vm__init__begin); -#else /* USDT2 */ HOTSPOT_VM_INIT_BEGIN(); -#endif /* USDT2 */ // Record VM creation timing statistics TraceVmCreationTime create_vm_timer; @@ -3557,11 +3528,7 @@ // debug stuff, that does not work until all basic classes have been initialized. set_init_completed(); -#ifndef USDT2 - HS_DTRACE_PROBE(hotspot, vm__init__end); -#else /* USDT2 */ HOTSPOT_VM_INIT_END(); -#endif /* USDT2 */ // record VM initialization completion time #if INCLUDE_MANAGEMENT diff --git a/src/share/vm/runtime/vmThread.cpp b/src/share/vm/runtime/vmThread.cpp --- a/src/share/vm/runtime/vmThread.cpp +++ b/src/share/vm/runtime/vmThread.cpp @@ -40,12 +40,6 @@ #include "utilities/events.hpp" #include "utilities/xmlstream.hpp" -#ifndef USDT2 -HS_DTRACE_PROBE_DECL3(hotspot, vmops__request, char *, uintptr_t, int); -HS_DTRACE_PROBE_DECL3(hotspot, vmops__begin, char *, uintptr_t, int); -HS_DTRACE_PROBE_DECL3(hotspot, vmops__end, char *, uintptr_t, int); -#endif /* !USDT2 */ - // Dummy VM operation to act as first element in our circular double-linked list class VM_Dummy: public VM_Operation { VMOp_Type type() const { return VMOp_Dummy; } @@ -154,14 +148,9 @@ // High-level interface bool VMOperationQueue::add(VM_Operation *op) { -#ifndef USDT2 - HS_DTRACE_PROBE3(hotspot, vmops__request, op->name(), strlen(op->name()), - op->evaluation_mode()); -#else /* USDT2 */ HOTSPOT_VMOPS_REQUEST( (char *) op->name(), strlen(op->name()), op->evaluation_mode()); -#endif /* USDT2 */ // Encapsulates VM queue policy. Currently, that // only involves putting them on the right list @@ -358,14 +347,9 @@ { PerfTraceTime vm_op_timer(perf_accumulated_vm_operation_time()); -#ifndef USDT2 - HS_DTRACE_PROBE3(hotspot, vmops__begin, op->name(), strlen(op->name()), - op->evaluation_mode()); -#else /* USDT2 */ HOTSPOT_VMOPS_BEGIN( (char *) op->name(), strlen(op->name()), op->evaluation_mode()); -#endif /* USDT2 */ EventExecuteVMOperation event; @@ -383,14 +367,9 @@ event.commit(); } -#ifndef USDT2 - HS_DTRACE_PROBE3(hotspot, vmops__end, op->name(), strlen(op->name()), - op->evaluation_mode()); -#else /* USDT2 */ HOTSPOT_VMOPS_END( (char *) op->name(), strlen(op->name()), op->evaluation_mode()); -#endif /* USDT2 */ } // Last access of info in _cur_vm_operation! diff --git a/src/share/vm/services/classLoadingService.cpp b/src/share/vm/services/classLoadingService.cpp --- a/src/share/vm/services/classLoadingService.cpp +++ b/src/share/vm/services/classLoadingService.cpp @@ -37,26 +37,6 @@ // Only bother with this argument setup if dtrace is available -#ifndef USDT2 - -HS_DTRACE_PROBE_DECL4(hotspot, class__loaded, char*, int, oop, bool); -HS_DTRACE_PROBE_DECL4(hotspot, class__unloaded, char*, int, oop, bool); - -#define DTRACE_CLASSLOAD_PROBE(type, clss, shared) \ - { \ - char* data = NULL; \ - int len = 0; \ - Symbol* name = (clss)->name(); \ - if (name != NULL) { \ - data = (char*)name->bytes(); \ - len = name->utf8_length(); \ - } \ - HS_DTRACE_PROBE4(hotspot, class__##type, \ - data, len, SOLARIS_ONLY((void *))(clss)->class_loader(), (shared)); \ - } - -#else /* USDT2 */ - #define HOTSPOT_CLASS_unloaded HOTSPOT_CLASS_UNLOADED #define HOTSPOT_CLASS_loaded HOTSPOT_CLASS_LOADED #define DTRACE_CLASSLOAD_PROBE(type, clss, shared) \ @@ -72,7 +52,6 @@ data, len, (clss)->class_loader(), (shared)); \ } -#endif /* USDT2 */ #else // ndef DTRACE_ENABLED #define DTRACE_CLASSLOAD_PROBE(type, clss, shared) diff --git a/src/share/vm/services/memoryManager.cpp b/src/share/vm/services/memoryManager.cpp --- a/src/share/vm/services/memoryManager.cpp +++ b/src/share/vm/services/memoryManager.cpp @@ -36,13 +36,6 @@ #include "services/gcNotifier.hpp" #include "utilities/dtrace.hpp" -#ifndef USDT2 -HS_DTRACE_PROBE_DECL8(hotspot, mem__pool__gc__begin, char*, int, char*, int, - size_t, size_t, size_t, size_t); -HS_DTRACE_PROBE_DECL8(hotspot, mem__pool__gc__end, char*, int, char*, int, - size_t, size_t, size_t, size_t); -#endif /* !USDT2 */ - MemoryManager::MemoryManager() { _num_pools = 0; (void)const_cast(_memory_mgr_obj = NULL); @@ -242,19 +235,11 @@ MemoryPool* pool = MemoryService::get_memory_pool(i); MemoryUsage usage = pool->get_memory_usage(); _current_gc_stat->set_before_gc_usage(i, usage); -#ifndef USDT2 - HS_DTRACE_PROBE8(hotspot, mem__pool__gc__begin, - name(), strlen(name()), - pool->name(), strlen(pool->name()), - usage.init_size(), usage.used(), - usage.committed(), usage.max_size()); -#else /* USDT2 */ HOTSPOT_MEM_POOL_GC_BEGIN( (char *) name(), strlen(name()), (char *) pool->name(), strlen(pool->name()), usage.init_size(), usage.used(), usage.committed(), usage.max_size()); -#endif /* USDT2 */ } } } @@ -280,19 +265,11 @@ MemoryPool* pool = MemoryService::get_memory_pool(i); MemoryUsage usage = pool->get_memory_usage(); -#ifndef USDT2 - HS_DTRACE_PROBE8(hotspot, mem__pool__gc__end, - name(), strlen(name()), - pool->name(), strlen(pool->name()), - usage.init_size(), usage.used(), - usage.committed(), usage.max_size()); -#else /* USDT2 */ HOTSPOT_MEM_POOL_GC_END( (char *) name(), strlen(name()), (char *) pool->name(), strlen(pool->name()), usage.init_size(), usage.used(), usage.committed(), usage.max_size()); -#endif /* USDT2 */ _current_gc_stat->set_after_gc_usage(i, usage); } diff --git a/src/share/vm/services/runtimeService.cpp b/src/share/vm/services/runtimeService.cpp --- a/src/share/vm/services/runtimeService.cpp +++ b/src/share/vm/services/runtimeService.cpp @@ -31,11 +31,6 @@ #include "utilities/exceptions.hpp" #include "utilities/macros.hpp" -#ifndef USDT2 -HS_DTRACE_PROBE_DECL(hs_private, safepoint__begin); -HS_DTRACE_PROBE_DECL(hs_private, safepoint__end); -#endif /* !USDT2 */ - #if INCLUDE_MANAGEMENT TimeStamp RuntimeService::_app_timer; TimeStamp RuntimeService::_safepoint_timer; @@ -112,11 +107,7 @@ } void RuntimeService::record_safepoint_begin() { -#ifndef USDT2 - HS_DTRACE_PROBE(hs_private, safepoint__begin); -#else /* USDT2 */ HS_PRIVATE_SAFEPOINT_BEGIN(); -#endif /* USDT2 */ // Print the time interval in which the app was executing if (PrintGCApplicationConcurrentTime && _app_timer.is_updated()) { @@ -143,11 +134,7 @@ } void RuntimeService::record_safepoint_end() { -#ifndef USDT2 - HS_DTRACE_PROBE(hs_private, safepoint__end); -#else /* USDT2 */ HS_PRIVATE_SAFEPOINT_END(); -#endif /* USDT2 */ // Print the time interval for which the app was stopped // during the current safepoint operation. diff --git a/src/share/vm/utilities/dtrace.hpp b/src/share/vm/utilities/dtrace.hpp --- a/src/share/vm/utilities/dtrace.hpp +++ b/src/share/vm/utilities/dtrace.hpp @@ -37,7 +37,6 @@ // Work around dtrace tail call bug 6672627 until it is fixed in solaris 10. #define HS_DTRACE_WORKAROUND_TAIL_CALL_BUG() \ do { volatile size_t dtrace_workaround_tail_call_bug = 1; } while (0) - #elif defined(LINUX) #define HS_DTRACE_WORKAROUND_TAIL_CALL_BUG() #elif defined(__APPLE__) @@ -47,7 +46,6 @@ #error "dtrace enabled for unknown os" #endif /* defined(SOLARIS) */ -#define USDT2 1 #include "dtracefiles/hotspot.h" #include "dtracefiles/hotspot_jni.h" #include "dtracefiles/hs_private.h" @@ -59,147 +57,8 @@ #define HS_DTRACE_WORKAROUND_TAIL_CALL_BUG() -#ifndef USDT2 - -#define DTRACE_PROBE(a,b) {;} -#define DTRACE_PROBE1(a,b,c) {;} -#define DTRACE_PROBE2(a,b,c,d) {;} -#define DTRACE_PROBE3(a,b,c,d,e) {;} -#define DTRACE_PROBE4(a,b,c,d,e,f) {;} -#define DTRACE_PROBE5(a,b,c,d,e,f,g) {;} -#define DTRACE_PROBE6(a,b,c,d,e,f,g,h) {;} -#define DTRACE_PROBE7(a,b,c,d,e,f,g,h,i) {;} -#define DTRACE_PROBE8(a,b,c,d,e,f,g,h,i,j) {;} -#define DTRACE_PROBE9(a,b,c,d,e,f,g,h,i,j,k) {;} -#define DTRACE_PROBE10(a,b,c,d,e,f,g,h,i,j,k,l) {;} - -#else /* USDT2 */ - #include "dtrace_usdt2_disabled.hpp" -#endif /* USDT2 */ #endif /* defined(DTRACE_ENABLED) */ -#ifndef USDT2 - -#define HS_DTRACE_PROBE_FN(provider,name)\ - __dtrace_##provider##___##name - -#ifdef SOLARIS -// Solaris dtrace needs actual extern function decls. -#define HS_DTRACE_PROBE_DECL_N(provider,name,args) \ - DTRACE_ONLY(extern "C" void HS_DTRACE_PROBE_FN(provider,name) args) -#define HS_DTRACE_PROBE_CDECL_N(provider,name,args) \ - DTRACE_ONLY(extern void HS_DTRACE_PROBE_FN(provider,name) args) -#else -// Systemtap dtrace compatible probes on GNU/Linux don't. -// If dtrace is disabled this macro becomes NULL -#define HS_DTRACE_PROBE_DECL_N(provider,name,args) -#define HS_DTRACE_PROBE_CDECL_N(provider,name,args) -#endif - -/* Dtrace probe declarations */ -#define HS_DTRACE_PROBE_DECL(provider,name) \ - HS_DTRACE_PROBE_DECL0(provider,name) -#define HS_DTRACE_PROBE_DECL0(provider,name)\ - HS_DTRACE_PROBE_DECL_N(provider,name,(void)) -#define HS_DTRACE_PROBE_DECL1(provider,name,t0)\ - HS_DTRACE_PROBE_DECL_N(provider,name,(uintptr_t)) -#define HS_DTRACE_PROBE_DECL2(provider,name,t0,t1)\ - HS_DTRACE_PROBE_DECL_N(provider,name,(uintptr_t,uintptr_t)) -#define HS_DTRACE_PROBE_DECL3(provider,name,t0,t1,t2)\ - HS_DTRACE_PROBE_DECL_N(provider,name,(uintptr_t,uintptr_t,uintptr_t)) -#define HS_DTRACE_PROBE_DECL4(provider,name,t0,t1,t2,t3)\ - HS_DTRACE_PROBE_DECL_N(provider,name,(uintptr_t,uintptr_t,uintptr_t,\ - uintptr_t)) -#define HS_DTRACE_PROBE_DECL5(provider,name,t0,t1,t2,t3,t4)\ - HS_DTRACE_PROBE_DECL_N(provider,name,(\ - uintptr_t,uintptr_t,uintptr_t,uintptr_t,uintptr_t)) -#define HS_DTRACE_PROBE_DECL6(provider,name,t0,t1,t2,t3,t4,t5)\ - HS_DTRACE_PROBE_DECL_N(provider,name,(\ - uintptr_t,uintptr_t,uintptr_t,uintptr_t,uintptr_t,uintptr_t)) -#define HS_DTRACE_PROBE_DECL7(provider,name,t0,t1,t2,t3,t4,t5,t6)\ - HS_DTRACE_PROBE_DECL_N(provider,name,(\ - uintptr_t,uintptr_t,uintptr_t,uintptr_t,uintptr_t,uintptr_t,uintptr_t)) -#define HS_DTRACE_PROBE_DECL8(provider,name,t0,t1,t2,t3,t4,t5,t6,t7)\ - HS_DTRACE_PROBE_DECL_N(provider,name,(\ - uintptr_t,uintptr_t,uintptr_t,uintptr_t,uintptr_t,uintptr_t,uintptr_t,\ - uintptr_t)) -#define HS_DTRACE_PROBE_DECL9(provider,name,t0,t1,t2,t3,t4,t5,t6,t7,t8)\ - HS_DTRACE_PROBE_DECL_N(provider,name,(\ - uintptr_t,uintptr_t,uintptr_t,uintptr_t,uintptr_t,uintptr_t,uintptr_t,\ - uintptr_t,uintptr_t)) -#define HS_DTRACE_PROBE_DECL10(provider,name,t0,t1,t2,t3,t4,t5,t6,t7,t8,t9)\ - HS_DTRACE_PROBE_DECL_N(provider,name,(\ - uintptr_t,uintptr_t,uintptr_t,uintptr_t,uintptr_t,uintptr_t,uintptr_t,\ - uintptr_t,uintptr_t,uintptr_t)) - -/* Dtrace probe definitions */ -#if defined(SOLARIS) -// Solaris dtrace uses actual function calls. -#define HS_DTRACE_PROBE_N(provider,name, args) \ - DTRACE_ONLY(HS_DTRACE_PROBE_FN(provider,name) args) - -#define HS_DTRACE_PROBE(provider,name) HS_DTRACE_PROBE0(provider,name) -#define HS_DTRACE_PROBE0(provider,name)\ - HS_DTRACE_PROBE_N(provider,name,()) -#define HS_DTRACE_PROBE1(provider,name,a0)\ - HS_DTRACE_PROBE_N(provider,name,((uintptr_t)a0)) -#define HS_DTRACE_PROBE2(provider,name,a0,a1)\ - HS_DTRACE_PROBE_N(provider,name,((uintptr_t)a0,(uintptr_t)a1)) -#define HS_DTRACE_PROBE3(provider,name,a0,a1,a2)\ - HS_DTRACE_PROBE_N(provider,name,((uintptr_t)a0,(uintptr_t)a1,(uintptr_t)a2)) -#define HS_DTRACE_PROBE4(provider,name,a0,a1,a2,a3)\ - HS_DTRACE_PROBE_N(provider,name,((uintptr_t)a0,(uintptr_t)a1,(uintptr_t)a2,\ - (uintptr_t)a3)) -#define HS_DTRACE_PROBE5(provider,name,a0,a1,a2,a3,a4)\ - HS_DTRACE_PROBE_N(provider,name,((uintptr_t)a0,(uintptr_t)a1,(uintptr_t)a2,\ - (uintptr_t)a3,(uintptr_t)a4)) -#define HS_DTRACE_PROBE6(provider,name,a0,a1,a2,a3,a4,a5)\ - HS_DTRACE_PROBE_N(provider,name,((uintptr_t)a0,(uintptr_t)a1,(uintptr_t)a2,\ - (uintptr_t)a3,(uintptr_t)a4,(uintptr_t)a5)) -#define HS_DTRACE_PROBE7(provider,name,a0,a1,a2,a3,a4,a5,a6)\ - HS_DTRACE_PROBE_N(provider,name,((uintptr_t)a0,(uintptr_t)a1,(uintptr_t)a2,\ - (uintptr_t)a3,(uintptr_t)a4,(uintptr_t)a5,(uintptr_t)a6)) -#define HS_DTRACE_PROBE8(provider,name,a0,a1,a2,a3,a4,a5,a6,a7)\ - HS_DTRACE_PROBE_N(provider,name,((uintptr_t)a0,(uintptr_t)a1,(uintptr_t)a2,\ - (uintptr_t)a3,(uintptr_t)a4,(uintptr_t)a5,(uintptr_t)a6,(uintptr_t)a7)) -#define HS_DTRACE_PROBE9(provider,name,a0,a1,a2,a3,a4,a5,a6,a7,a8)\ - HS_DTRACE_PROBE_N(provider,name,((uintptr_t)a0,(uintptr_t)a1,(uintptr_t)a2,\ - (uintptr_t)a3,(uintptr_t)a4,(uintptr_t)a5,(uintptr_t)a6,(uintptr_t)a7,\ - (uintptr_t)a8)) -#define HS_DTRACE_PROBE10(provider,name,a0,a1,a2,a3,a4,a5,a6,a7,a8,a9)\ - HS_DTRACE_PROBE_N(provider,name,((uintptr_t)a0,(uintptr_t)a1,(uintptr_t)a2,\ - (uintptr_t)a3,(uintptr_t)a4,(uintptr_t)a5,(uintptr_t)a6,(uintptr_t)a7,\ - (uintptr_t)a8,(uintptr_t)a9)) -#else -// Systemtap dtrace compatible probes on GNU/Linux use direct macros. -// If dtrace is disabled this macro becomes NULL -#define HS_DTRACE_PROBE(provider,name) HS_DTRACE_PROBE0(provider,name) -#define HS_DTRACE_PROBE0(provider,name)\ - DTRACE_PROBE(provider,name) -#define HS_DTRACE_PROBE1(provider,name,a0)\ - DTRACE_PROBE1(provider,name,a0) -#define HS_DTRACE_PROBE2(provider,name,a0,a1)\ - DTRACE_PROBE2(provider,name,a0,a1) -#define HS_DTRACE_PROBE3(provider,name,a0,a1,a2)\ - DTRACE_PROBE3(provider,name,a0,a1,a2) -#define HS_DTRACE_PROBE4(provider,name,a0,a1,a2,a3)\ - DTRACE_PROBE4(provider,name,a0,a1,a2,a3) -#define HS_DTRACE_PROBE5(provider,name,a0,a1,a2,a3,a4)\ - DTRACE_PROBE5(provider,name,a0,a1,a2,a3,a4) -#define HS_DTRACE_PROBE6(provider,name,a0,a1,a2,a3,a4,a5)\ - DTRACE_PROBE6(provider,name,a0,a1,a2,a3,a4,a5) -#define HS_DTRACE_PROBE7(provider,name,a0,a1,a2,a3,a4,a5,a6)\ - DTRACE_PROBE7(provider,name,a0,a1,a2,a3,a4,a5,a6) -#define HS_DTRACE_PROBE8(provider,name,a0,a1,a2,a3,a4,a5,a6,a7)\ - DTRACE_PROBE8(provider,name,a0,a1,a2,a3,a4,a5,a6,a7) -#define HS_DTRACE_PROBE9(provider,name,a0,a1,a2,a3,a4,a5,a6,a7,a8)\ - DTRACE_PROBE9(provider,name,a0,a1,a2,a3,a4,a5,a6,a7,a8) -#define HS_DTRACE_PROBE10(provider,name,a0,a1,a2,a3,a4,a5,a6,a7,a8,a9)\ - DTRACE_PROBE10(provider,name,a0,a1,a2,a3,a4,a5,a6,a7,a8,a9) -#endif - -#endif /* !USDT2 */ - #endif // SHARE_VM_UTILITIES_DTRACE_HPP diff --git a/src/share/vm/utilities/dtrace_usdt2_disabled.hpp b/src/share/vm/utilities/dtrace_usdt2_disabled.hpp --- a/src/share/vm/utilities/dtrace_usdt2_disabled.hpp +++ b/src/share/vm/utilities/dtrace_usdt2_disabled.hpp @@ -32,8 +32,6 @@ */ #if !defined(DTRACE_ENABLED) -#ifdef USDT2 - /* hotspot provider probes */ #define HOTSPOT_CLASS_LOADED(arg0, arg1, arg2, arg3) #define HOTSPOT_CLASS_LOADED_ENABLED() 0 @@ -107,7 +105,7 @@ #define HOTSPOT_THREAD_PARK_BEGIN_ENABLED() 0 #define HOTSPOT_THREAD_PARK_END(arg0) #define HOTSPOT_THREAD_PARK_END_ENABLED() 0 -#define HOTSPOT_THREAD_UNPARK() +#define HOTSPOT_THREAD_UNPARK(arg0) #define HOTSPOT_THREAD_UNPARK_ENABLED() 0 #define HOTSPOT_VM_INIT_BEGIN() #define HOTSPOT_VM_INIT_BEGIN_ENABLED() 0 @@ -1086,12 +1084,8 @@ #define HOTSPOT_JNI_UNREGISTERNATIVES_RETURN(arg0) #define HOTSPOT_JNI_UNREGISTERNATIVES_RETURN_ENABLED() 0 -#else /* USDT2 */ -#error This file should only be included for USDT2 -#endif /* USDT2 */ - #else /* !defined(DTRACE_ENABLED) */ #error This file should only be included when dtrace is not enabled -#end /* !defined(DTRACE_ENABLED) */ +#endif /* !defined(DTRACE_ENABLED) */ #endif // SHARE_VM_UTILITIES_DTRACE_USDT2_DISABLED_HPP