Mercurial > hg > graal-jvmci-8
comparison src/share/vm/prims/jni.cpp @ 4137:04b9a2566eec
Merge with hsx23/hotspot.
author | Thomas Wuerthinger <thomas.wuerthinger@oracle.com> |
---|---|
date | Sat, 17 Dec 2011 21:40:27 +0100 |
parents | 0e8a2a629afb 6fd81579526f |
children | d8d6b3de346b |
comparison
equal
deleted
inserted
replaced
3737:9dc19b7d89a3 | 4137:04b9a2566eec |
---|---|
69 #include "services/runtimeService.hpp" | 69 #include "services/runtimeService.hpp" |
70 #include "utilities/defaultStream.hpp" | 70 #include "utilities/defaultStream.hpp" |
71 #include "utilities/dtrace.hpp" | 71 #include "utilities/dtrace.hpp" |
72 #include "utilities/events.hpp" | 72 #include "utilities/events.hpp" |
73 #include "utilities/histogram.hpp" | 73 #include "utilities/histogram.hpp" |
74 #ifdef TARGET_ARCH_x86 | |
75 # include "jniTypes_x86.hpp" | |
76 #endif | |
77 #ifdef TARGET_ARCH_sparc | |
78 # include "jniTypes_sparc.hpp" | |
79 #endif | |
80 #ifdef TARGET_ARCH_zero | |
81 # include "jniTypes_zero.hpp" | |
82 #endif | |
83 #ifdef TARGET_OS_FAMILY_linux | 74 #ifdef TARGET_OS_FAMILY_linux |
84 # include "os_linux.inline.hpp" | 75 # include "os_linux.inline.hpp" |
85 # include "thread_linux.inline.hpp" | 76 # include "thread_linux.inline.hpp" |
86 #endif | 77 #endif |
87 #ifdef TARGET_OS_FAMILY_solaris | 78 #ifdef TARGET_OS_FAMILY_solaris |
89 # include "thread_solaris.inline.hpp" | 80 # include "thread_solaris.inline.hpp" |
90 #endif | 81 #endif |
91 #ifdef TARGET_OS_FAMILY_windows | 82 #ifdef TARGET_OS_FAMILY_windows |
92 # include "os_windows.inline.hpp" | 83 # include "os_windows.inline.hpp" |
93 # include "thread_windows.inline.hpp" | 84 # include "thread_windows.inline.hpp" |
85 #endif | |
86 #ifdef TARGET_OS_FAMILY_bsd | |
87 # include "os_bsd.inline.hpp" | |
88 # include "thread_bsd.inline.hpp" | |
94 #endif | 89 #endif |
95 | 90 |
96 static jint CurrentVersion = JNI_VERSION_1_6; | 91 static jint CurrentVersion = JNI_VERSION_1_6; |
97 | 92 |
98 | 93 |
114 // DT_RETURN_MARK(SomeFunc, int, (const int&)return_value); | 109 // DT_RETURN_MARK(SomeFunc, int, (const int&)return_value); |
115 // foo(CHECK_0) | 110 // foo(CHECK_0) |
116 // return_value = 5; | 111 // return_value = 5; |
117 // return return_value; | 112 // return return_value; |
118 // JNI_END | 113 // JNI_END |
114 #ifndef USDT2 | |
119 #define DT_RETURN_MARK_DECL(name, type) \ | 115 #define DT_RETURN_MARK_DECL(name, type) \ |
120 HS_DTRACE_PROBE_DECL1(hotspot_jni, name##__return, type); \ | 116 HS_DTRACE_PROBE_DECL1(hotspot_jni, name##__return, type); \ |
121 DTRACE_ONLY( \ | 117 DTRACE_ONLY( \ |
122 class DTraceReturnProbeMark_##name { \ | 118 class DTraceReturnProbeMark_##name { \ |
123 public: \ | 119 public: \ |
138 HS_DTRACE_PROBE0(hotspot_jni, name##__return); \ | 134 HS_DTRACE_PROBE0(hotspot_jni, name##__return); \ |
139 } \ | 135 } \ |
140 } \ | 136 } \ |
141 ) | 137 ) |
142 | 138 |
139 #else /* USDT2 */ | |
140 | |
141 #define DT_RETURN_MARK_DECL(name, type, probe) \ | |
142 DTRACE_ONLY( \ | |
143 class DTraceReturnProbeMark_##name { \ | |
144 public: \ | |
145 const type& _ret_ref; \ | |
146 DTraceReturnProbeMark_##name(const type& v) : _ret_ref(v) {} \ | |
147 ~DTraceReturnProbeMark_##name() { \ | |
148 probe; \ | |
149 } \ | |
150 } \ | |
151 ) | |
152 // Void functions are simpler since there's no return value | |
153 #define DT_VOID_RETURN_MARK_DECL(name, probe) \ | |
154 DTRACE_ONLY( \ | |
155 class DTraceReturnProbeMark_##name { \ | |
156 public: \ | |
157 ~DTraceReturnProbeMark_##name() { \ | |
158 probe; \ | |
159 } \ | |
160 } \ | |
161 ) | |
162 #endif /* USDT2 */ | |
143 | 163 |
144 // Place these macros in the function to mark the return. Non-void | 164 // Place these macros in the function to mark the return. Non-void |
145 // functions need the type and address of the return value. | 165 // functions need the type and address of the return value. |
146 #define DT_RETURN_MARK(name, type, ref) \ | 166 #define DT_RETURN_MARK(name, type, ref) \ |
147 DTRACE_ONLY( DTraceReturnProbeMark_##name dtrace_return_mark(ref) ) | 167 DTRACE_ONLY( DTraceReturnProbeMark_##name dtrace_return_mark(ref) ) |
166 | 186 |
167 #define COMMA , | 187 #define COMMA , |
168 | 188 |
169 // Choose DT_RETURN_MARK macros based on the type: float/double -> void | 189 // Choose DT_RETURN_MARK macros based on the type: float/double -> void |
170 // (dtrace doesn't do FP yet) | 190 // (dtrace doesn't do FP yet) |
191 #ifndef USDT2 | |
171 #define DT_RETURN_MARK_DECL_FOR(TypeName, name, type) \ | 192 #define DT_RETURN_MARK_DECL_FOR(TypeName, name, type) \ |
172 FP_SELECT(TypeName, \ | 193 FP_SELECT(TypeName, \ |
173 DT_RETURN_MARK_DECL(name, type), DT_VOID_RETURN_MARK_DECL(name) ) | 194 DT_RETURN_MARK_DECL(name, type), DT_VOID_RETURN_MARK_DECL(name) ) |
195 #else /* USDT2 */ | |
196 #define DT_RETURN_MARK_DECL_FOR(TypeName, name, type, probe) \ | |
197 FP_SELECT(TypeName, \ | |
198 DT_RETURN_MARK_DECL(name, type, probe), DT_VOID_RETURN_MARK_DECL(name, probe) ) | |
199 #endif /* USDT2 */ | |
174 #define DT_RETURN_MARK_FOR(TypeName, name, type, ref) \ | 200 #define DT_RETURN_MARK_FOR(TypeName, name, type, ref) \ |
175 FP_SELECT(TypeName, \ | 201 FP_SELECT(TypeName, \ |
176 DT_RETURN_MARK(name, type, ref), DT_VOID_RETURN_MARK(name) ) | 202 DT_RETURN_MARK(name, type, ref), DT_VOID_RETURN_MARK(name) ) |
177 | 203 |
178 | 204 |
327 #endif | 353 #endif |
328 | 354 |
329 | 355 |
330 // Implementation of JNI entries | 356 // Implementation of JNI entries |
331 | 357 |
358 #ifndef USDT2 | |
332 DT_RETURN_MARK_DECL(DefineClass, jclass); | 359 DT_RETURN_MARK_DECL(DefineClass, jclass); |
360 #else /* USDT2 */ | |
361 DT_RETURN_MARK_DECL(DefineClass, jclass | |
362 , HOTSPOT_JNI_DEFINECLASS_RETURN(_ret_ref)); | |
363 #endif /* USDT2 */ | |
333 | 364 |
334 JNI_ENTRY(jclass, jni_DefineClass(JNIEnv *env, const char *name, jobject loaderRef, | 365 JNI_ENTRY(jclass, jni_DefineClass(JNIEnv *env, const char *name, jobject loaderRef, |
335 const jbyte *buf, jsize bufLen)) | 366 const jbyte *buf, jsize bufLen)) |
336 JNIWrapper("DefineClass"); | 367 JNIWrapper("DefineClass"); |
337 | 368 |
369 #ifndef USDT2 | |
338 DTRACE_PROBE5(hotspot_jni, DefineClass__entry, | 370 DTRACE_PROBE5(hotspot_jni, DefineClass__entry, |
339 env, name, loaderRef, buf, bufLen); | 371 env, name, loaderRef, buf, bufLen); |
372 #else /* USDT2 */ | |
373 HOTSPOT_JNI_DEFINECLASS_ENTRY( | |
374 env, (char*) name, loaderRef, (char*) buf, bufLen); | |
375 #endif /* USDT2 */ | |
340 jclass cls = NULL; | 376 jclass cls = NULL; |
341 DT_RETURN_MARK(DefineClass, jclass, (const jclass&)cls); | 377 DT_RETURN_MARK(DefineClass, jclass, (const jclass&)cls); |
342 | 378 |
343 // Since exceptions can be thrown, class initialization can take place | 379 // Since exceptions can be thrown, class initialization can take place |
344 // if name is NULL no check for class name in .class stream has to be made. | 380 // if name is NULL no check for class name in .class stream has to be made. |
380 | 416 |
381 | 417 |
382 | 418 |
383 static bool first_time_FindClass = true; | 419 static bool first_time_FindClass = true; |
384 | 420 |
421 #ifndef USDT2 | |
385 DT_RETURN_MARK_DECL(FindClass, jclass); | 422 DT_RETURN_MARK_DECL(FindClass, jclass); |
423 #else /* USDT2 */ | |
424 DT_RETURN_MARK_DECL(FindClass, jclass | |
425 , HOTSPOT_JNI_FINDCLASS_RETURN(_ret_ref)); | |
426 #endif /* USDT2 */ | |
386 | 427 |
387 JNI_ENTRY(jclass, jni_FindClass(JNIEnv *env, const char *name)) | 428 JNI_ENTRY(jclass, jni_FindClass(JNIEnv *env, const char *name)) |
388 JNIWrapper("FindClass"); | 429 JNIWrapper("FindClass"); |
430 #ifndef USDT2 | |
389 DTRACE_PROBE2(hotspot_jni, FindClass__entry, env, name); | 431 DTRACE_PROBE2(hotspot_jni, FindClass__entry, env, name); |
432 #else /* USDT2 */ | |
433 HOTSPOT_JNI_FINDCLASS_ENTRY( | |
434 env, (char *)name); | |
435 #endif /* USDT2 */ | |
390 | 436 |
391 jclass result = NULL; | 437 jclass result = NULL; |
392 DT_RETURN_MARK(FindClass, jclass, (const jclass&)result); | 438 DT_RETURN_MARK(FindClass, jclass, (const jclass&)result); |
393 | 439 |
394 // Remember if we are the first invocation of jni_FindClass | 440 // Remember if we are the first invocation of jni_FindClass |
448 CompilationPolicy::completed_vm_startup(); | 494 CompilationPolicy::completed_vm_startup(); |
449 | 495 |
450 return result; | 496 return result; |
451 JNI_END | 497 JNI_END |
452 | 498 |
499 #ifndef USDT2 | |
453 DT_RETURN_MARK_DECL(FromReflectedMethod, jmethodID); | 500 DT_RETURN_MARK_DECL(FromReflectedMethod, jmethodID); |
501 #else /* USDT2 */ | |
502 DT_RETURN_MARK_DECL(FromReflectedMethod, jmethodID | |
503 , HOTSPOT_JNI_FROMREFLECTEDMETHOD_RETURN((uintptr_t)_ret_ref)); | |
504 #endif /* USDT2 */ | |
454 | 505 |
455 JNI_ENTRY(jmethodID, jni_FromReflectedMethod(JNIEnv *env, jobject method)) | 506 JNI_ENTRY(jmethodID, jni_FromReflectedMethod(JNIEnv *env, jobject method)) |
456 JNIWrapper("FromReflectedMethod"); | 507 JNIWrapper("FromReflectedMethod"); |
508 #ifndef USDT2 | |
457 DTRACE_PROBE2(hotspot_jni, FromReflectedMethod__entry, env, method); | 509 DTRACE_PROBE2(hotspot_jni, FromReflectedMethod__entry, env, method); |
510 #else /* USDT2 */ | |
511 HOTSPOT_JNI_FROMREFLECTEDMETHOD_ENTRY( | |
512 env, method); | |
513 #endif /* USDT2 */ | |
458 jmethodID ret = NULL; | 514 jmethodID ret = NULL; |
459 DT_RETURN_MARK(FromReflectedMethod, jmethodID, (const jmethodID&)ret); | 515 DT_RETURN_MARK(FromReflectedMethod, jmethodID, (const jmethodID&)ret); |
460 | 516 |
461 // method is a handle to a java.lang.reflect.Method object | 517 // method is a handle to a java.lang.reflect.Method object |
462 oop reflected = JNIHandles::resolve_non_null(method); | 518 oop reflected = JNIHandles::resolve_non_null(method); |
479 methodOop m = instanceKlass::cast(k1())->method_with_idnum(slot); | 535 methodOop m = instanceKlass::cast(k1())->method_with_idnum(slot); |
480 ret = m==NULL? NULL : m->jmethod_id(); // return NULL if reflected method deleted | 536 ret = m==NULL? NULL : m->jmethod_id(); // return NULL if reflected method deleted |
481 return ret; | 537 return ret; |
482 JNI_END | 538 JNI_END |
483 | 539 |
540 #ifndef USDT2 | |
484 DT_RETURN_MARK_DECL(FromReflectedField, jfieldID); | 541 DT_RETURN_MARK_DECL(FromReflectedField, jfieldID); |
542 #else /* USDT2 */ | |
543 DT_RETURN_MARK_DECL(FromReflectedField, jfieldID | |
544 , HOTSPOT_JNI_FROMREFLECTEDFIELD_RETURN((uintptr_t)_ret_ref)); | |
545 #endif /* USDT2 */ | |
485 | 546 |
486 JNI_ENTRY(jfieldID, jni_FromReflectedField(JNIEnv *env, jobject field)) | 547 JNI_ENTRY(jfieldID, jni_FromReflectedField(JNIEnv *env, jobject field)) |
487 JNIWrapper("FromReflectedField"); | 548 JNIWrapper("FromReflectedField"); |
549 #ifndef USDT2 | |
488 DTRACE_PROBE2(hotspot_jni, FromReflectedField__entry, env, field); | 550 DTRACE_PROBE2(hotspot_jni, FromReflectedField__entry, env, field); |
551 #else /* USDT2 */ | |
552 HOTSPOT_JNI_FROMREFLECTEDFIELD_ENTRY( | |
553 env, field); | |
554 #endif /* USDT2 */ | |
489 jfieldID ret = NULL; | 555 jfieldID ret = NULL; |
490 DT_RETURN_MARK(FromReflectedField, jfieldID, (const jfieldID&)ret); | 556 DT_RETURN_MARK(FromReflectedField, jfieldID, (const jfieldID&)ret); |
491 | 557 |
492 // field is a handle to a java.lang.reflect.Field object | 558 // field is a handle to a java.lang.reflect.Field object |
493 oop reflected = JNIHandles::resolve_non_null(field); | 559 oop reflected = JNIHandles::resolve_non_null(field); |
500 // Make sure class is initialized before handing id's out to fields | 566 // Make sure class is initialized before handing id's out to fields |
501 Klass::cast(k1())->initialize(CHECK_NULL); | 567 Klass::cast(k1())->initialize(CHECK_NULL); |
502 | 568 |
503 // First check if this is a static field | 569 // First check if this is a static field |
504 if (modifiers & JVM_ACC_STATIC) { | 570 if (modifiers & JVM_ACC_STATIC) { |
505 intptr_t offset = instanceKlass::cast(k1())->offset_from_fields( slot ); | 571 intptr_t offset = instanceKlass::cast(k1())->field_offset( slot ); |
506 JNIid* id = instanceKlass::cast(k1())->jni_id_for(offset); | 572 JNIid* id = instanceKlass::cast(k1())->jni_id_for(offset); |
507 assert(id != NULL, "corrupt Field object"); | 573 assert(id != NULL, "corrupt Field object"); |
508 debug_only(id->set_is_static_field_id();) | 574 debug_only(id->set_is_static_field_id();) |
509 // A jfieldID for a static field is a JNIid specifying the field holder and the offset within the klassOop | 575 // A jfieldID for a static field is a JNIid specifying the field holder and the offset within the klassOop |
510 ret = jfieldIDWorkaround::to_static_jfieldID(id); | 576 ret = jfieldIDWorkaround::to_static_jfieldID(id); |
512 } | 578 } |
513 | 579 |
514 // The slot is the index of the field description in the field-array | 580 // The slot is the index of the field description in the field-array |
515 // The jfieldID is the offset of the field within the object | 581 // The jfieldID is the offset of the field within the object |
516 // It may also have hash bits for k, if VerifyJNIFields is turned on. | 582 // It may also have hash bits for k, if VerifyJNIFields is turned on. |
517 intptr_t offset = instanceKlass::cast(k1())->offset_from_fields( slot ); | 583 intptr_t offset = instanceKlass::cast(k1())->field_offset( slot ); |
518 assert(instanceKlass::cast(k1())->contains_field_offset(offset), "stay within object"); | 584 assert(instanceKlass::cast(k1())->contains_field_offset(offset), "stay within object"); |
519 ret = jfieldIDWorkaround::to_instance_jfieldID(k1(), offset); | 585 ret = jfieldIDWorkaround::to_instance_jfieldID(k1(), offset); |
520 return ret; | 586 return ret; |
521 JNI_END | 587 JNI_END |
522 | 588 |
589 #ifndef USDT2 | |
523 DT_RETURN_MARK_DECL(ToReflectedMethod, jobject); | 590 DT_RETURN_MARK_DECL(ToReflectedMethod, jobject); |
591 #else /* USDT2 */ | |
592 DT_RETURN_MARK_DECL(ToReflectedMethod, jobject | |
593 , HOTSPOT_JNI_TOREFLECTEDMETHOD_RETURN(_ret_ref)); | |
594 #endif /* USDT2 */ | |
524 | 595 |
525 JNI_ENTRY(jobject, jni_ToReflectedMethod(JNIEnv *env, jclass cls, jmethodID method_id, jboolean isStatic)) | 596 JNI_ENTRY(jobject, jni_ToReflectedMethod(JNIEnv *env, jclass cls, jmethodID method_id, jboolean isStatic)) |
526 JNIWrapper("ToReflectedMethod"); | 597 JNIWrapper("ToReflectedMethod"); |
598 #ifndef USDT2 | |
527 DTRACE_PROBE4(hotspot_jni, ToReflectedMethod__entry, env, cls, method_id, isStatic); | 599 DTRACE_PROBE4(hotspot_jni, ToReflectedMethod__entry, env, cls, method_id, isStatic); |
600 #else /* USDT2 */ | |
601 HOTSPOT_JNI_TOREFLECTEDMETHOD_ENTRY( | |
602 env, cls, (uintptr_t) method_id, isStatic); | |
603 #endif /* USDT2 */ | |
528 jobject ret = NULL; | 604 jobject ret = NULL; |
529 DT_RETURN_MARK(ToReflectedMethod, jobject, (const jobject&)ret); | 605 DT_RETURN_MARK(ToReflectedMethod, jobject, (const jobject&)ret); |
530 | 606 |
531 methodHandle m (THREAD, JNIHandles::resolve_jmethod_id(method_id)); | 607 methodHandle m (THREAD, JNIHandles::resolve_jmethod_id(method_id)); |
532 assert(m->is_static() == (isStatic != 0), "jni_ToReflectedMethod access flags doesn't match"); | 608 assert(m->is_static() == (isStatic != 0), "jni_ToReflectedMethod access flags doesn't match"); |
538 } | 614 } |
539 ret = JNIHandles::make_local(env, reflection_method); | 615 ret = JNIHandles::make_local(env, reflection_method); |
540 return ret; | 616 return ret; |
541 JNI_END | 617 JNI_END |
542 | 618 |
619 #ifndef USDT2 | |
543 DT_RETURN_MARK_DECL(GetSuperclass, jclass); | 620 DT_RETURN_MARK_DECL(GetSuperclass, jclass); |
621 #else /* USDT2 */ | |
622 DT_RETURN_MARK_DECL(GetSuperclass, jclass | |
623 , HOTSPOT_JNI_GETSUPERCLASS_RETURN(_ret_ref)); | |
624 #endif /* USDT2 */ | |
544 | 625 |
545 JNI_ENTRY(jclass, jni_GetSuperclass(JNIEnv *env, jclass sub)) | 626 JNI_ENTRY(jclass, jni_GetSuperclass(JNIEnv *env, jclass sub)) |
546 JNIWrapper("GetSuperclass"); | 627 JNIWrapper("GetSuperclass"); |
628 #ifndef USDT2 | |
547 DTRACE_PROBE2(hotspot_jni, GetSuperclass__entry, env, sub); | 629 DTRACE_PROBE2(hotspot_jni, GetSuperclass__entry, env, sub); |
630 #else /* USDT2 */ | |
631 HOTSPOT_JNI_GETSUPERCLASS_ENTRY( | |
632 env, sub); | |
633 #endif /* USDT2 */ | |
548 jclass obj = NULL; | 634 jclass obj = NULL; |
549 DT_RETURN_MARK(GetSuperclass, jclass, (const jclass&)obj); | 635 DT_RETURN_MARK(GetSuperclass, jclass, (const jclass&)obj); |
550 | 636 |
551 oop mirror = JNIHandles::resolve_non_null(sub); | 637 oop mirror = JNIHandles::resolve_non_null(sub); |
552 // primitive classes return NULL | 638 // primitive classes return NULL |
571 return obj; | 657 return obj; |
572 JNI_END | 658 JNI_END |
573 | 659 |
574 JNI_QUICK_ENTRY(jboolean, jni_IsAssignableFrom(JNIEnv *env, jclass sub, jclass super)) | 660 JNI_QUICK_ENTRY(jboolean, jni_IsAssignableFrom(JNIEnv *env, jclass sub, jclass super)) |
575 JNIWrapper("IsSubclassOf"); | 661 JNIWrapper("IsSubclassOf"); |
662 #ifndef USDT2 | |
576 DTRACE_PROBE3(hotspot_jni, IsAssignableFrom__entry, env, sub, super); | 663 DTRACE_PROBE3(hotspot_jni, IsAssignableFrom__entry, env, sub, super); |
664 #else /* USDT2 */ | |
665 HOTSPOT_JNI_ISASSIGNABLEFROM_ENTRY( | |
666 env, sub, super); | |
667 #endif /* USDT2 */ | |
577 oop sub_mirror = JNIHandles::resolve_non_null(sub); | 668 oop sub_mirror = JNIHandles::resolve_non_null(sub); |
578 oop super_mirror = JNIHandles::resolve_non_null(super); | 669 oop super_mirror = JNIHandles::resolve_non_null(super); |
579 if (java_lang_Class::is_primitive(sub_mirror) || | 670 if (java_lang_Class::is_primitive(sub_mirror) || |
580 java_lang_Class::is_primitive(super_mirror)) { | 671 java_lang_Class::is_primitive(super_mirror)) { |
581 jboolean ret = (sub_mirror == super_mirror); | 672 jboolean ret = (sub_mirror == super_mirror); |
673 #ifndef USDT2 | |
582 DTRACE_PROBE1(hotspot_jni, IsAssignableFrom__return, ret); | 674 DTRACE_PROBE1(hotspot_jni, IsAssignableFrom__return, ret); |
675 #else /* USDT2 */ | |
676 HOTSPOT_JNI_ISASSIGNABLEFROM_RETURN( | |
677 ret); | |
678 #endif /* USDT2 */ | |
583 return ret; | 679 return ret; |
584 } | 680 } |
585 klassOop sub_klass = java_lang_Class::as_klassOop(sub_mirror); | 681 klassOop sub_klass = java_lang_Class::as_klassOop(sub_mirror); |
586 klassOop super_klass = java_lang_Class::as_klassOop(super_mirror); | 682 klassOop super_klass = java_lang_Class::as_klassOop(super_mirror); |
587 assert(sub_klass != NULL && super_klass != NULL, "invalid arguments to jni_IsAssignableFrom"); | 683 assert(sub_klass != NULL && super_klass != NULL, "invalid arguments to jni_IsAssignableFrom"); |
588 jboolean ret = Klass::cast(sub_klass)->is_subtype_of(super_klass) ? | 684 jboolean ret = Klass::cast(sub_klass)->is_subtype_of(super_klass) ? |
589 JNI_TRUE : JNI_FALSE; | 685 JNI_TRUE : JNI_FALSE; |
686 #ifndef USDT2 | |
590 DTRACE_PROBE1(hotspot_jni, IsAssignableFrom__return, ret); | 687 DTRACE_PROBE1(hotspot_jni, IsAssignableFrom__return, ret); |
688 #else /* USDT2 */ | |
689 HOTSPOT_JNI_ISASSIGNABLEFROM_RETURN( | |
690 ret); | |
691 #endif /* USDT2 */ | |
591 return ret; | 692 return ret; |
592 JNI_END | 693 JNI_END |
593 | 694 |
695 #ifndef USDT2 | |
594 DT_RETURN_MARK_DECL(Throw, jint); | 696 DT_RETURN_MARK_DECL(Throw, jint); |
697 #else /* USDT2 */ | |
698 DT_RETURN_MARK_DECL(Throw, jint | |
699 , HOTSPOT_JNI_THROW_RETURN(_ret_ref)); | |
700 #endif /* USDT2 */ | |
595 | 701 |
596 JNI_ENTRY(jint, jni_Throw(JNIEnv *env, jthrowable obj)) | 702 JNI_ENTRY(jint, jni_Throw(JNIEnv *env, jthrowable obj)) |
597 JNIWrapper("Throw"); | 703 JNIWrapper("Throw"); |
704 #ifndef USDT2 | |
598 DTRACE_PROBE2(hotspot_jni, Throw__entry, env, obj); | 705 DTRACE_PROBE2(hotspot_jni, Throw__entry, env, obj); |
706 #else /* USDT2 */ | |
707 HOTSPOT_JNI_THROW_ENTRY( | |
708 env, obj); | |
709 #endif /* USDT2 */ | |
599 jint ret = JNI_OK; | 710 jint ret = JNI_OK; |
600 DT_RETURN_MARK(Throw, jint, (const jint&)ret); | 711 DT_RETURN_MARK(Throw, jint, (const jint&)ret); |
601 | 712 |
602 THROW_OOP_(JNIHandles::resolve(obj), JNI_OK); | 713 THROW_OOP_(JNIHandles::resolve(obj), JNI_OK); |
603 ShouldNotReachHere(); | 714 ShouldNotReachHere(); |
604 JNI_END | 715 JNI_END |
605 | 716 |
717 #ifndef USDT2 | |
606 DT_RETURN_MARK_DECL(ThrowNew, jint); | 718 DT_RETURN_MARK_DECL(ThrowNew, jint); |
719 #else /* USDT2 */ | |
720 DT_RETURN_MARK_DECL(ThrowNew, jint | |
721 , HOTSPOT_JNI_THROWNEW_RETURN(_ret_ref)); | |
722 #endif /* USDT2 */ | |
607 | 723 |
608 JNI_ENTRY(jint, jni_ThrowNew(JNIEnv *env, jclass clazz, const char *message)) | 724 JNI_ENTRY(jint, jni_ThrowNew(JNIEnv *env, jclass clazz, const char *message)) |
609 JNIWrapper("ThrowNew"); | 725 JNIWrapper("ThrowNew"); |
726 #ifndef USDT2 | |
610 DTRACE_PROBE3(hotspot_jni, ThrowNew__entry, env, clazz, message); | 727 DTRACE_PROBE3(hotspot_jni, ThrowNew__entry, env, clazz, message); |
728 #else /* USDT2 */ | |
729 HOTSPOT_JNI_THROWNEW_ENTRY( | |
730 env, clazz, (char *) message); | |
731 #endif /* USDT2 */ | |
611 jint ret = JNI_OK; | 732 jint ret = JNI_OK; |
612 DT_RETURN_MARK(ThrowNew, jint, (const jint&)ret); | 733 DT_RETURN_MARK(ThrowNew, jint, (const jint&)ret); |
613 | 734 |
614 instanceKlass* k = instanceKlass::cast(java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(clazz))); | 735 instanceKlass* k = instanceKlass::cast(java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(clazz))); |
615 Symbol* name = k->name(); | 736 Symbol* name = k->name(); |
634 thread->check_and_handle_async_exceptions(); | 755 thread->check_and_handle_async_exceptions(); |
635 } | 756 } |
636 | 757 |
637 JNI_ENTRY_NO_PRESERVE(jthrowable, jni_ExceptionOccurred(JNIEnv *env)) | 758 JNI_ENTRY_NO_PRESERVE(jthrowable, jni_ExceptionOccurred(JNIEnv *env)) |
638 JNIWrapper("ExceptionOccurred"); | 759 JNIWrapper("ExceptionOccurred"); |
760 #ifndef USDT2 | |
639 DTRACE_PROBE1(hotspot_jni, ExceptionOccurred__entry, env); | 761 DTRACE_PROBE1(hotspot_jni, ExceptionOccurred__entry, env); |
762 #else /* USDT2 */ | |
763 HOTSPOT_JNI_EXCEPTIONOCCURRED_ENTRY( | |
764 env); | |
765 #endif /* USDT2 */ | |
640 jni_check_async_exceptions(thread); | 766 jni_check_async_exceptions(thread); |
641 oop exception = thread->pending_exception(); | 767 oop exception = thread->pending_exception(); |
642 jthrowable ret = (jthrowable) JNIHandles::make_local(env, exception); | 768 jthrowable ret = (jthrowable) JNIHandles::make_local(env, exception); |
769 #ifndef USDT2 | |
643 DTRACE_PROBE1(hotspot_jni, ExceptionOccurred__return, ret); | 770 DTRACE_PROBE1(hotspot_jni, ExceptionOccurred__return, ret); |
771 #else /* USDT2 */ | |
772 HOTSPOT_JNI_EXCEPTIONOCCURRED_RETURN( | |
773 ret); | |
774 #endif /* USDT2 */ | |
644 return ret; | 775 return ret; |
645 JNI_END | 776 JNI_END |
646 | 777 |
647 | 778 |
648 JNI_ENTRY_NO_PRESERVE(void, jni_ExceptionDescribe(JNIEnv *env)) | 779 JNI_ENTRY_NO_PRESERVE(void, jni_ExceptionDescribe(JNIEnv *env)) |
649 JNIWrapper("ExceptionDescribe"); | 780 JNIWrapper("ExceptionDescribe"); |
781 #ifndef USDT2 | |
650 DTRACE_PROBE1(hotspot_jni, ExceptionDescribe__entry, env); | 782 DTRACE_PROBE1(hotspot_jni, ExceptionDescribe__entry, env); |
783 #else /* USDT2 */ | |
784 HOTSPOT_JNI_EXCEPTIONDESCRIBE_ENTRY( | |
785 env); | |
786 #endif /* USDT2 */ | |
651 if (thread->has_pending_exception()) { | 787 if (thread->has_pending_exception()) { |
652 Handle ex(thread, thread->pending_exception()); | 788 Handle ex(thread, thread->pending_exception()); |
653 thread->clear_pending_exception(); | 789 thread->clear_pending_exception(); |
654 if (ex->is_a(SystemDictionary::ThreadDeath_klass())) { | 790 if (ex->is_a(SystemDictionary::ThreadDeath_klass())) { |
655 // Don't print anything if we are being killed. | 791 // Don't print anything if we are being killed. |
681 ". Uncaught exception of type %s.", | 817 ". Uncaught exception of type %s.", |
682 Klass::cast(ex->klass())->external_name()); | 818 Klass::cast(ex->klass())->external_name()); |
683 } | 819 } |
684 } | 820 } |
685 } | 821 } |
822 #ifndef USDT2 | |
686 DTRACE_PROBE(hotspot_jni, ExceptionDescribe__return); | 823 DTRACE_PROBE(hotspot_jni, ExceptionDescribe__return); |
824 #else /* USDT2 */ | |
825 HOTSPOT_JNI_EXCEPTIONDESCRIBE_RETURN( | |
826 ); | |
827 #endif /* USDT2 */ | |
687 JNI_END | 828 JNI_END |
688 | 829 |
689 | 830 |
690 JNI_QUICK_ENTRY(void, jni_ExceptionClear(JNIEnv *env)) | 831 JNI_QUICK_ENTRY(void, jni_ExceptionClear(JNIEnv *env)) |
691 JNIWrapper("ExceptionClear"); | 832 JNIWrapper("ExceptionClear"); |
833 #ifndef USDT2 | |
692 DTRACE_PROBE1(hotspot_jni, ExceptionClear__entry, env); | 834 DTRACE_PROBE1(hotspot_jni, ExceptionClear__entry, env); |
835 #else /* USDT2 */ | |
836 HOTSPOT_JNI_EXCEPTIONCLEAR_ENTRY( | |
837 env); | |
838 #endif /* USDT2 */ | |
693 | 839 |
694 // The jni code might be using this API to clear java thrown exception. | 840 // The jni code might be using this API to clear java thrown exception. |
695 // So just mark jvmti thread exception state as exception caught. | 841 // So just mark jvmti thread exception state as exception caught. |
696 JvmtiThreadState *state = JavaThread::current()->jvmti_thread_state(); | 842 JvmtiThreadState *state = JavaThread::current()->jvmti_thread_state(); |
697 if (state != NULL && state->is_exception_detected()) { | 843 if (state != NULL && state->is_exception_detected()) { |
698 state->set_exception_caught(); | 844 state->set_exception_caught(); |
699 } | 845 } |
700 thread->clear_pending_exception(); | 846 thread->clear_pending_exception(); |
847 #ifndef USDT2 | |
701 DTRACE_PROBE(hotspot_jni, ExceptionClear__return); | 848 DTRACE_PROBE(hotspot_jni, ExceptionClear__return); |
849 #else /* USDT2 */ | |
850 HOTSPOT_JNI_EXCEPTIONCLEAR_RETURN( | |
851 ); | |
852 #endif /* USDT2 */ | |
702 JNI_END | 853 JNI_END |
703 | 854 |
704 | 855 |
705 JNI_ENTRY(void, jni_FatalError(JNIEnv *env, const char *msg)) | 856 JNI_ENTRY(void, jni_FatalError(JNIEnv *env, const char *msg)) |
706 JNIWrapper("FatalError"); | 857 JNIWrapper("FatalError"); |
858 #ifndef USDT2 | |
707 DTRACE_PROBE2(hotspot_jni, FatalError__entry, env, msg); | 859 DTRACE_PROBE2(hotspot_jni, FatalError__entry, env, msg); |
860 #else /* USDT2 */ | |
861 HOTSPOT_JNI_FATALERROR_ENTRY( | |
862 env, (char *) msg); | |
863 #endif /* USDT2 */ | |
708 tty->print_cr("FATAL ERROR in native method: %s", msg); | 864 tty->print_cr("FATAL ERROR in native method: %s", msg); |
709 thread->print_stack(); | 865 thread->print_stack(); |
710 os::abort(); // Dump core and abort | 866 os::abort(); // Dump core and abort |
711 JNI_END | 867 JNI_END |
712 | 868 |
713 | 869 |
714 JNI_ENTRY(jint, jni_PushLocalFrame(JNIEnv *env, jint capacity)) | 870 JNI_ENTRY(jint, jni_PushLocalFrame(JNIEnv *env, jint capacity)) |
715 JNIWrapper("PushLocalFrame"); | 871 JNIWrapper("PushLocalFrame"); |
872 #ifndef USDT2 | |
716 DTRACE_PROBE2(hotspot_jni, PushLocalFrame__entry, env, capacity); | 873 DTRACE_PROBE2(hotspot_jni, PushLocalFrame__entry, env, capacity); |
874 #else /* USDT2 */ | |
875 HOTSPOT_JNI_PUSHLOCALFRAME_ENTRY( | |
876 env, capacity); | |
877 #endif /* USDT2 */ | |
717 //%note jni_11 | 878 //%note jni_11 |
718 if (capacity < 0 && capacity > MAX_REASONABLE_LOCAL_CAPACITY) { | 879 if (capacity < 0 && capacity > MAX_REASONABLE_LOCAL_CAPACITY) { |
880 #ifndef USDT2 | |
719 DTRACE_PROBE1(hotspot_jni, PushLocalFrame__return, JNI_ERR); | 881 DTRACE_PROBE1(hotspot_jni, PushLocalFrame__return, JNI_ERR); |
882 #else /* USDT2 */ | |
883 HOTSPOT_JNI_PUSHLOCALFRAME_RETURN( | |
884 (uint32_t)JNI_ERR); | |
885 #endif /* USDT2 */ | |
720 return JNI_ERR; | 886 return JNI_ERR; |
721 } | 887 } |
722 JNIHandleBlock* old_handles = thread->active_handles(); | 888 JNIHandleBlock* old_handles = thread->active_handles(); |
723 JNIHandleBlock* new_handles = JNIHandleBlock::allocate_block(thread); | 889 JNIHandleBlock* new_handles = JNIHandleBlock::allocate_block(thread); |
724 assert(new_handles != NULL, "should not be NULL"); | 890 assert(new_handles != NULL, "should not be NULL"); |
725 new_handles->set_pop_frame_link(old_handles); | 891 new_handles->set_pop_frame_link(old_handles); |
726 thread->set_active_handles(new_handles); | 892 thread->set_active_handles(new_handles); |
727 jint ret = JNI_OK; | 893 jint ret = JNI_OK; |
894 #ifndef USDT2 | |
728 DTRACE_PROBE1(hotspot_jni, PushLocalFrame__return, ret); | 895 DTRACE_PROBE1(hotspot_jni, PushLocalFrame__return, ret); |
896 #else /* USDT2 */ | |
897 HOTSPOT_JNI_PUSHLOCALFRAME_RETURN( | |
898 ret); | |
899 #endif /* USDT2 */ | |
729 return ret; | 900 return ret; |
730 JNI_END | 901 JNI_END |
731 | 902 |
732 | 903 |
733 JNI_ENTRY(jobject, jni_PopLocalFrame(JNIEnv *env, jobject result)) | 904 JNI_ENTRY(jobject, jni_PopLocalFrame(JNIEnv *env, jobject result)) |
734 JNIWrapper("PopLocalFrame"); | 905 JNIWrapper("PopLocalFrame"); |
906 #ifndef USDT2 | |
735 DTRACE_PROBE2(hotspot_jni, PopLocalFrame__entry, env, result); | 907 DTRACE_PROBE2(hotspot_jni, PopLocalFrame__entry, env, result); |
908 #else /* USDT2 */ | |
909 HOTSPOT_JNI_POPLOCALFRAME_ENTRY( | |
910 env, result); | |
911 #endif /* USDT2 */ | |
736 //%note jni_11 | 912 //%note jni_11 |
737 Handle result_handle(thread, JNIHandles::resolve(result)); | 913 Handle result_handle(thread, JNIHandles::resolve(result)); |
738 JNIHandleBlock* old_handles = thread->active_handles(); | 914 JNIHandleBlock* old_handles = thread->active_handles(); |
739 JNIHandleBlock* new_handles = old_handles->pop_frame_link(); | 915 JNIHandleBlock* new_handles = old_handles->pop_frame_link(); |
740 if (new_handles != NULL) { | 916 if (new_handles != NULL) { |
745 thread->set_active_handles(new_handles); | 921 thread->set_active_handles(new_handles); |
746 old_handles->set_pop_frame_link(NULL); // clear link we won't release new_handles below | 922 old_handles->set_pop_frame_link(NULL); // clear link we won't release new_handles below |
747 JNIHandleBlock::release_block(old_handles, thread); // may block | 923 JNIHandleBlock::release_block(old_handles, thread); // may block |
748 result = JNIHandles::make_local(thread, result_handle()); | 924 result = JNIHandles::make_local(thread, result_handle()); |
749 } | 925 } |
926 #ifndef USDT2 | |
750 DTRACE_PROBE1(hotspot_jni, PopLocalFrame__return, result); | 927 DTRACE_PROBE1(hotspot_jni, PopLocalFrame__return, result); |
928 #else /* USDT2 */ | |
929 HOTSPOT_JNI_POPLOCALFRAME_RETURN( | |
930 result); | |
931 #endif /* USDT2 */ | |
751 return result; | 932 return result; |
752 JNI_END | 933 JNI_END |
753 | 934 |
754 | 935 |
755 JNI_ENTRY(jobject, jni_NewGlobalRef(JNIEnv *env, jobject ref)) | 936 JNI_ENTRY(jobject, jni_NewGlobalRef(JNIEnv *env, jobject ref)) |
756 JNIWrapper("NewGlobalRef"); | 937 JNIWrapper("NewGlobalRef"); |
938 #ifndef USDT2 | |
757 DTRACE_PROBE2(hotspot_jni, NewGlobalRef__entry, env, ref); | 939 DTRACE_PROBE2(hotspot_jni, NewGlobalRef__entry, env, ref); |
940 #else /* USDT2 */ | |
941 HOTSPOT_JNI_NEWGLOBALREF_ENTRY( | |
942 env, ref); | |
943 #endif /* USDT2 */ | |
758 Handle ref_handle(thread, JNIHandles::resolve(ref)); | 944 Handle ref_handle(thread, JNIHandles::resolve(ref)); |
759 jobject ret = JNIHandles::make_global(ref_handle); | 945 jobject ret = JNIHandles::make_global(ref_handle); |
946 #ifndef USDT2 | |
760 DTRACE_PROBE1(hotspot_jni, NewGlobalRef__return, ret); | 947 DTRACE_PROBE1(hotspot_jni, NewGlobalRef__return, ret); |
948 #else /* USDT2 */ | |
949 HOTSPOT_JNI_NEWGLOBALREF_RETURN( | |
950 ret); | |
951 #endif /* USDT2 */ | |
761 return ret; | 952 return ret; |
762 JNI_END | 953 JNI_END |
763 | 954 |
764 // Must be JNI_ENTRY (with HandleMark) | 955 // Must be JNI_ENTRY (with HandleMark) |
765 JNI_ENTRY_NO_PRESERVE(void, jni_DeleteGlobalRef(JNIEnv *env, jobject ref)) | 956 JNI_ENTRY_NO_PRESERVE(void, jni_DeleteGlobalRef(JNIEnv *env, jobject ref)) |
766 JNIWrapper("DeleteGlobalRef"); | 957 JNIWrapper("DeleteGlobalRef"); |
958 #ifndef USDT2 | |
767 DTRACE_PROBE2(hotspot_jni, DeleteGlobalRef__entry, env, ref); | 959 DTRACE_PROBE2(hotspot_jni, DeleteGlobalRef__entry, env, ref); |
960 #else /* USDT2 */ | |
961 HOTSPOT_JNI_DELETEGLOBALREF_ENTRY( | |
962 env, ref); | |
963 #endif /* USDT2 */ | |
768 JNIHandles::destroy_global(ref); | 964 JNIHandles::destroy_global(ref); |
965 #ifndef USDT2 | |
769 DTRACE_PROBE(hotspot_jni, DeleteGlobalRef__return); | 966 DTRACE_PROBE(hotspot_jni, DeleteGlobalRef__return); |
967 #else /* USDT2 */ | |
968 HOTSPOT_JNI_DELETEGLOBALREF_RETURN( | |
969 ); | |
970 #endif /* USDT2 */ | |
770 JNI_END | 971 JNI_END |
771 | 972 |
772 JNI_QUICK_ENTRY(void, jni_DeleteLocalRef(JNIEnv *env, jobject obj)) | 973 JNI_QUICK_ENTRY(void, jni_DeleteLocalRef(JNIEnv *env, jobject obj)) |
773 JNIWrapper("DeleteLocalRef"); | 974 JNIWrapper("DeleteLocalRef"); |
975 #ifndef USDT2 | |
774 DTRACE_PROBE2(hotspot_jni, DeleteLocalRef__entry, env, obj); | 976 DTRACE_PROBE2(hotspot_jni, DeleteLocalRef__entry, env, obj); |
977 #else /* USDT2 */ | |
978 HOTSPOT_JNI_DELETELOCALREF_ENTRY( | |
979 env, obj); | |
980 #endif /* USDT2 */ | |
775 JNIHandles::destroy_local(obj); | 981 JNIHandles::destroy_local(obj); |
982 #ifndef USDT2 | |
776 DTRACE_PROBE(hotspot_jni, DeleteLocalRef__return); | 983 DTRACE_PROBE(hotspot_jni, DeleteLocalRef__return); |
984 #else /* USDT2 */ | |
985 HOTSPOT_JNI_DELETELOCALREF_RETURN( | |
986 ); | |
987 #endif /* USDT2 */ | |
777 JNI_END | 988 JNI_END |
778 | 989 |
779 JNI_QUICK_ENTRY(jboolean, jni_IsSameObject(JNIEnv *env, jobject r1, jobject r2)) | 990 JNI_QUICK_ENTRY(jboolean, jni_IsSameObject(JNIEnv *env, jobject r1, jobject r2)) |
780 JNIWrapper("IsSameObject"); | 991 JNIWrapper("IsSameObject"); |
992 #ifndef USDT2 | |
781 DTRACE_PROBE3(hotspot_jni, IsSameObject__entry, env, r1, r2); | 993 DTRACE_PROBE3(hotspot_jni, IsSameObject__entry, env, r1, r2); |
994 #else /* USDT2 */ | |
995 HOTSPOT_JNI_ISSAMEOBJECT_ENTRY( | |
996 env, r1, r2); | |
997 #endif /* USDT2 */ | |
782 oop a = JNIHandles::resolve(r1); | 998 oop a = JNIHandles::resolve(r1); |
783 oop b = JNIHandles::resolve(r2); | 999 oop b = JNIHandles::resolve(r2); |
784 jboolean ret = (a == b) ? JNI_TRUE : JNI_FALSE; | 1000 jboolean ret = (a == b) ? JNI_TRUE : JNI_FALSE; |
1001 #ifndef USDT2 | |
785 DTRACE_PROBE1(hotspot_jni, IsSameObject__return, ret); | 1002 DTRACE_PROBE1(hotspot_jni, IsSameObject__return, ret); |
1003 #else /* USDT2 */ | |
1004 HOTSPOT_JNI_ISSAMEOBJECT_RETURN( | |
1005 ret); | |
1006 #endif /* USDT2 */ | |
786 return ret; | 1007 return ret; |
787 JNI_END | 1008 JNI_END |
788 | 1009 |
789 | 1010 |
790 JNI_ENTRY(jobject, jni_NewLocalRef(JNIEnv *env, jobject ref)) | 1011 JNI_ENTRY(jobject, jni_NewLocalRef(JNIEnv *env, jobject ref)) |
791 JNIWrapper("NewLocalRef"); | 1012 JNIWrapper("NewLocalRef"); |
1013 #ifndef USDT2 | |
792 DTRACE_PROBE2(hotspot_jni, NewLocalRef__entry, env, ref); | 1014 DTRACE_PROBE2(hotspot_jni, NewLocalRef__entry, env, ref); |
1015 #else /* USDT2 */ | |
1016 HOTSPOT_JNI_NEWLOCALREF_ENTRY( | |
1017 env, ref); | |
1018 #endif /* USDT2 */ | |
793 jobject ret = JNIHandles::make_local(env, JNIHandles::resolve(ref)); | 1019 jobject ret = JNIHandles::make_local(env, JNIHandles::resolve(ref)); |
1020 #ifndef USDT2 | |
794 DTRACE_PROBE1(hotspot_jni, NewLocalRef__return, ret); | 1021 DTRACE_PROBE1(hotspot_jni, NewLocalRef__return, ret); |
1022 #else /* USDT2 */ | |
1023 HOTSPOT_JNI_NEWLOCALREF_RETURN( | |
1024 ret); | |
1025 #endif /* USDT2 */ | |
795 return ret; | 1026 return ret; |
796 JNI_END | 1027 JNI_END |
797 | 1028 |
798 JNI_LEAF(jint, jni_EnsureLocalCapacity(JNIEnv *env, jint capacity)) | 1029 JNI_LEAF(jint, jni_EnsureLocalCapacity(JNIEnv *env, jint capacity)) |
799 JNIWrapper("EnsureLocalCapacity"); | 1030 JNIWrapper("EnsureLocalCapacity"); |
1031 #ifndef USDT2 | |
800 DTRACE_PROBE2(hotspot_jni, EnsureLocalCapacity__entry, env, capacity); | 1032 DTRACE_PROBE2(hotspot_jni, EnsureLocalCapacity__entry, env, capacity); |
1033 #else /* USDT2 */ | |
1034 HOTSPOT_JNI_ENSURELOCALCAPACITY_ENTRY( | |
1035 env, capacity); | |
1036 #endif /* USDT2 */ | |
801 jint ret; | 1037 jint ret; |
802 if (capacity >= 0 && capacity <= MAX_REASONABLE_LOCAL_CAPACITY) { | 1038 if (capacity >= 0 && capacity <= MAX_REASONABLE_LOCAL_CAPACITY) { |
803 ret = JNI_OK; | 1039 ret = JNI_OK; |
804 } else { | 1040 } else { |
805 ret = JNI_ERR; | 1041 ret = JNI_ERR; |
806 } | 1042 } |
1043 #ifndef USDT2 | |
807 DTRACE_PROBE1(hotspot_jni, EnsureLocalCapacity__return, ret); | 1044 DTRACE_PROBE1(hotspot_jni, EnsureLocalCapacity__return, ret); |
1045 #else /* USDT2 */ | |
1046 HOTSPOT_JNI_ENSURELOCALCAPACITY_RETURN( | |
1047 ret); | |
1048 #endif /* USDT2 */ | |
808 return ret; | 1049 return ret; |
809 JNI_END | 1050 JNI_END |
810 | 1051 |
811 // Return the Handle Type | 1052 // Return the Handle Type |
812 JNI_LEAF(jobjectRefType, jni_GetObjectRefType(JNIEnv *env, jobject obj)) | 1053 JNI_LEAF(jobjectRefType, jni_GetObjectRefType(JNIEnv *env, jobject obj)) |
813 JNIWrapper("GetObjectRefType"); | 1054 JNIWrapper("GetObjectRefType"); |
1055 #ifndef USDT2 | |
814 DTRACE_PROBE2(hotspot_jni, GetObjectRefType__entry, env, obj); | 1056 DTRACE_PROBE2(hotspot_jni, GetObjectRefType__entry, env, obj); |
1057 #else /* USDT2 */ | |
1058 HOTSPOT_JNI_GETOBJECTREFTYPE_ENTRY( | |
1059 env, obj); | |
1060 #endif /* USDT2 */ | |
815 jobjectRefType ret; | 1061 jobjectRefType ret; |
816 if (JNIHandles::is_local_handle(thread, obj) || | 1062 if (JNIHandles::is_local_handle(thread, obj) || |
817 JNIHandles::is_frame_handle(thread, obj)) | 1063 JNIHandles::is_frame_handle(thread, obj)) |
818 ret = JNILocalRefType; | 1064 ret = JNILocalRefType; |
819 else if (JNIHandles::is_global_handle(obj)) | 1065 else if (JNIHandles::is_global_handle(obj)) |
820 ret = JNIGlobalRefType; | 1066 ret = JNIGlobalRefType; |
821 else if (JNIHandles::is_weak_global_handle(obj)) | 1067 else if (JNIHandles::is_weak_global_handle(obj)) |
822 ret = JNIWeakGlobalRefType; | 1068 ret = JNIWeakGlobalRefType; |
823 else | 1069 else |
824 ret = JNIInvalidRefType; | 1070 ret = JNIInvalidRefType; |
1071 #ifndef USDT2 | |
825 DTRACE_PROBE1(hotspot_jni, GetObjectRefType__return, ret); | 1072 DTRACE_PROBE1(hotspot_jni, GetObjectRefType__return, ret); |
1073 #else /* USDT2 */ | |
1074 HOTSPOT_JNI_GETOBJECTREFTYPE_RETURN( | |
1075 (void *) ret); | |
1076 #endif /* USDT2 */ | |
826 return ret; | 1077 return ret; |
827 JNI_END | 1078 JNI_END |
828 | 1079 |
829 | 1080 |
830 class JNI_ArgumentPusher : public SignatureIterator { | 1081 class JNI_ArgumentPusher : public SignatureIterator { |
1171 instanceKlass::cast(k())->initialize(CHECK_NULL); | 1422 instanceKlass::cast(k())->initialize(CHECK_NULL); |
1172 instanceOop ih = instanceKlass::cast(k())->allocate_instance(THREAD); | 1423 instanceOop ih = instanceKlass::cast(k())->allocate_instance(THREAD); |
1173 return ih; | 1424 return ih; |
1174 } | 1425 } |
1175 | 1426 |
1427 #ifndef USDT2 | |
1176 DT_RETURN_MARK_DECL(AllocObject, jobject); | 1428 DT_RETURN_MARK_DECL(AllocObject, jobject); |
1429 #else /* USDT2 */ | |
1430 DT_RETURN_MARK_DECL(AllocObject, jobject | |
1431 , HOTSPOT_JNI_ALLOCOBJECT_RETURN(_ret_ref)); | |
1432 #endif /* USDT2 */ | |
1177 | 1433 |
1178 JNI_ENTRY(jobject, jni_AllocObject(JNIEnv *env, jclass clazz)) | 1434 JNI_ENTRY(jobject, jni_AllocObject(JNIEnv *env, jclass clazz)) |
1179 JNIWrapper("AllocObject"); | 1435 JNIWrapper("AllocObject"); |
1180 | 1436 |
1437 #ifndef USDT2 | |
1181 DTRACE_PROBE2(hotspot_jni, AllocObject__entry, env, clazz); | 1438 DTRACE_PROBE2(hotspot_jni, AllocObject__entry, env, clazz); |
1439 #else /* USDT2 */ | |
1440 HOTSPOT_JNI_ALLOCOBJECT_ENTRY( | |
1441 env, clazz); | |
1442 #endif /* USDT2 */ | |
1182 jobject ret = NULL; | 1443 jobject ret = NULL; |
1183 DT_RETURN_MARK(AllocObject, jobject, (const jobject&)ret); | 1444 DT_RETURN_MARK(AllocObject, jobject, (const jobject&)ret); |
1184 | 1445 |
1185 instanceOop i = alloc_object(clazz, CHECK_NULL); | 1446 instanceOop i = alloc_object(clazz, CHECK_NULL); |
1186 ret = JNIHandles::make_local(env, i); | 1447 ret = JNIHandles::make_local(env, i); |
1187 return ret; | 1448 return ret; |
1188 JNI_END | 1449 JNI_END |
1189 | 1450 |
1451 #ifndef USDT2 | |
1190 DT_RETURN_MARK_DECL(NewObjectA, jobject); | 1452 DT_RETURN_MARK_DECL(NewObjectA, jobject); |
1453 #else /* USDT2 */ | |
1454 DT_RETURN_MARK_DECL(NewObjectA, jobject | |
1455 , HOTSPOT_JNI_NEWOBJECTA_RETURN(_ret_ref)); | |
1456 #endif /* USDT2 */ | |
1191 | 1457 |
1192 JNI_ENTRY(jobject, jni_NewObjectA(JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args)) | 1458 JNI_ENTRY(jobject, jni_NewObjectA(JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args)) |
1193 JNIWrapper("NewObjectA"); | 1459 JNIWrapper("NewObjectA"); |
1460 #ifndef USDT2 | |
1194 DTRACE_PROBE3(hotspot_jni, NewObjectA__entry, env, clazz, methodID); | 1461 DTRACE_PROBE3(hotspot_jni, NewObjectA__entry, env, clazz, methodID); |
1462 #else /* USDT2 */ | |
1463 HOTSPOT_JNI_NEWOBJECTA_ENTRY( | |
1464 env, clazz, (uintptr_t) methodID); | |
1465 #endif /* USDT2 */ | |
1195 jobject obj = NULL; | 1466 jobject obj = NULL; |
1196 DT_RETURN_MARK(NewObjectA, jobject, (const jobject)obj); | 1467 DT_RETURN_MARK(NewObjectA, jobject, (const jobject)obj); |
1197 | 1468 |
1198 instanceOop i = alloc_object(clazz, CHECK_NULL); | 1469 instanceOop i = alloc_object(clazz, CHECK_NULL); |
1199 obj = JNIHandles::make_local(env, i); | 1470 obj = JNIHandles::make_local(env, i); |
1201 JNI_ArgumentPusherArray ap(methodID, args); | 1472 JNI_ArgumentPusherArray ap(methodID, args); |
1202 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK_NULL); | 1473 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK_NULL); |
1203 return obj; | 1474 return obj; |
1204 JNI_END | 1475 JNI_END |
1205 | 1476 |
1477 #ifndef USDT2 | |
1206 DT_RETURN_MARK_DECL(NewObjectV, jobject); | 1478 DT_RETURN_MARK_DECL(NewObjectV, jobject); |
1479 #else /* USDT2 */ | |
1480 DT_RETURN_MARK_DECL(NewObjectV, jobject | |
1481 , HOTSPOT_JNI_NEWOBJECTV_RETURN(_ret_ref)); | |
1482 #endif /* USDT2 */ | |
1207 | 1483 |
1208 JNI_ENTRY(jobject, jni_NewObjectV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)) | 1484 JNI_ENTRY(jobject, jni_NewObjectV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)) |
1209 JNIWrapper("NewObjectV"); | 1485 JNIWrapper("NewObjectV"); |
1486 #ifndef USDT2 | |
1210 DTRACE_PROBE3(hotspot_jni, NewObjectV__entry, env, clazz, methodID); | 1487 DTRACE_PROBE3(hotspot_jni, NewObjectV__entry, env, clazz, methodID); |
1488 #else /* USDT2 */ | |
1489 HOTSPOT_JNI_NEWOBJECTV_ENTRY( | |
1490 env, clazz, (uintptr_t) methodID); | |
1491 #endif /* USDT2 */ | |
1211 jobject obj = NULL; | 1492 jobject obj = NULL; |
1212 DT_RETURN_MARK(NewObjectV, jobject, (const jobject&)obj); | 1493 DT_RETURN_MARK(NewObjectV, jobject, (const jobject&)obj); |
1213 | 1494 |
1214 instanceOop i = alloc_object(clazz, CHECK_NULL); | 1495 instanceOop i = alloc_object(clazz, CHECK_NULL); |
1215 obj = JNIHandles::make_local(env, i); | 1496 obj = JNIHandles::make_local(env, i); |
1217 JNI_ArgumentPusherVaArg ap(methodID, args); | 1498 JNI_ArgumentPusherVaArg ap(methodID, args); |
1218 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK_NULL); | 1499 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK_NULL); |
1219 return obj; | 1500 return obj; |
1220 JNI_END | 1501 JNI_END |
1221 | 1502 |
1503 #ifndef USDT2 | |
1222 DT_RETURN_MARK_DECL(NewObject, jobject); | 1504 DT_RETURN_MARK_DECL(NewObject, jobject); |
1505 #else /* USDT2 */ | |
1506 DT_RETURN_MARK_DECL(NewObject, jobject | |
1507 , HOTSPOT_JNI_NEWOBJECT_RETURN(_ret_ref)); | |
1508 #endif /* USDT2 */ | |
1223 | 1509 |
1224 JNI_ENTRY(jobject, jni_NewObject(JNIEnv *env, jclass clazz, jmethodID methodID, ...)) | 1510 JNI_ENTRY(jobject, jni_NewObject(JNIEnv *env, jclass clazz, jmethodID methodID, ...)) |
1225 JNIWrapper("NewObject"); | 1511 JNIWrapper("NewObject"); |
1512 #ifndef USDT2 | |
1226 DTRACE_PROBE3(hotspot_jni, NewObject__entry, env, clazz, methodID); | 1513 DTRACE_PROBE3(hotspot_jni, NewObject__entry, env, clazz, methodID); |
1514 #else /* USDT2 */ | |
1515 HOTSPOT_JNI_NEWOBJECT_ENTRY( | |
1516 env, clazz, (uintptr_t) methodID); | |
1517 #endif /* USDT2 */ | |
1227 jobject obj = NULL; | 1518 jobject obj = NULL; |
1228 DT_RETURN_MARK(NewObject, jobject, (const jobject&)obj); | 1519 DT_RETURN_MARK(NewObject, jobject, (const jobject&)obj); |
1229 | 1520 |
1230 instanceOop i = alloc_object(clazz, CHECK_NULL); | 1521 instanceOop i = alloc_object(clazz, CHECK_NULL); |
1231 obj = JNIHandles::make_local(env, i); | 1522 obj = JNIHandles::make_local(env, i); |
1239 JNI_END | 1530 JNI_END |
1240 | 1531 |
1241 | 1532 |
1242 JNI_ENTRY(jclass, jni_GetObjectClass(JNIEnv *env, jobject obj)) | 1533 JNI_ENTRY(jclass, jni_GetObjectClass(JNIEnv *env, jobject obj)) |
1243 JNIWrapper("GetObjectClass"); | 1534 JNIWrapper("GetObjectClass"); |
1535 #ifndef USDT2 | |
1244 DTRACE_PROBE2(hotspot_jni, GetObjectClass__entry, env, obj); | 1536 DTRACE_PROBE2(hotspot_jni, GetObjectClass__entry, env, obj); |
1537 #else /* USDT2 */ | |
1538 HOTSPOT_JNI_GETOBJECTCLASS_ENTRY( | |
1539 env, obj); | |
1540 #endif /* USDT2 */ | |
1245 klassOop k = JNIHandles::resolve_non_null(obj)->klass(); | 1541 klassOop k = JNIHandles::resolve_non_null(obj)->klass(); |
1246 jclass ret = | 1542 jclass ret = |
1247 (jclass) JNIHandles::make_local(env, Klass::cast(k)->java_mirror()); | 1543 (jclass) JNIHandles::make_local(env, Klass::cast(k)->java_mirror()); |
1544 #ifndef USDT2 | |
1248 DTRACE_PROBE1(hotspot_jni, GetObjectClass__return, ret); | 1545 DTRACE_PROBE1(hotspot_jni, GetObjectClass__return, ret); |
1546 #else /* USDT2 */ | |
1547 HOTSPOT_JNI_GETOBJECTCLASS_RETURN( | |
1548 ret); | |
1549 #endif /* USDT2 */ | |
1249 return ret; | 1550 return ret; |
1250 JNI_END | 1551 JNI_END |
1251 | 1552 |
1252 JNI_QUICK_ENTRY(jboolean, jni_IsInstanceOf(JNIEnv *env, jobject obj, jclass clazz)) | 1553 JNI_QUICK_ENTRY(jboolean, jni_IsInstanceOf(JNIEnv *env, jobject obj, jclass clazz)) |
1253 JNIWrapper("IsInstanceOf"); | 1554 JNIWrapper("IsInstanceOf"); |
1555 #ifndef USDT2 | |
1254 DTRACE_PROBE3(hotspot_jni, IsInstanceOf__entry, env, obj, clazz); | 1556 DTRACE_PROBE3(hotspot_jni, IsInstanceOf__entry, env, obj, clazz); |
1557 #else /* USDT2 */ | |
1558 HOTSPOT_JNI_ISINSTANCEOF_ENTRY( | |
1559 env, obj, clazz); | |
1560 #endif /* USDT2 */ | |
1255 jboolean ret = JNI_TRUE; | 1561 jboolean ret = JNI_TRUE; |
1256 if (obj != NULL) { | 1562 if (obj != NULL) { |
1257 ret = JNI_FALSE; | 1563 ret = JNI_FALSE; |
1258 klassOop k = java_lang_Class::as_klassOop( | 1564 klassOop k = java_lang_Class::as_klassOop( |
1259 JNIHandles::resolve_non_null(clazz)); | 1565 JNIHandles::resolve_non_null(clazz)); |
1260 if (k != NULL) { | 1566 if (k != NULL) { |
1261 ret = JNIHandles::resolve_non_null(obj)->is_a(k) ? JNI_TRUE : JNI_FALSE; | 1567 ret = JNIHandles::resolve_non_null(obj)->is_a(k) ? JNI_TRUE : JNI_FALSE; |
1262 } | 1568 } |
1263 } | 1569 } |
1570 #ifndef USDT2 | |
1264 DTRACE_PROBE1(hotspot_jni, IsInstanceOf__return, ret); | 1571 DTRACE_PROBE1(hotspot_jni, IsInstanceOf__return, ret); |
1572 #else /* USDT2 */ | |
1573 HOTSPOT_JNI_ISINSTANCEOF_RETURN( | |
1574 ret); | |
1575 #endif /* USDT2 */ | |
1265 return ret; | 1576 return ret; |
1266 JNI_END | 1577 JNI_END |
1267 | 1578 |
1268 | 1579 |
1269 static jmethodID get_method_id(JNIEnv *env, jclass clazz, const char *name_str, | 1580 static jmethodID get_method_id(JNIEnv *env, jclass clazz, const char *name_str, |
1321 | 1632 |
1322 | 1633 |
1323 JNI_ENTRY(jmethodID, jni_GetMethodID(JNIEnv *env, jclass clazz, | 1634 JNI_ENTRY(jmethodID, jni_GetMethodID(JNIEnv *env, jclass clazz, |
1324 const char *name, const char *sig)) | 1635 const char *name, const char *sig)) |
1325 JNIWrapper("GetMethodID"); | 1636 JNIWrapper("GetMethodID"); |
1637 #ifndef USDT2 | |
1326 DTRACE_PROBE4(hotspot_jni, GetMethodID__entry, env, clazz, name, sig); | 1638 DTRACE_PROBE4(hotspot_jni, GetMethodID__entry, env, clazz, name, sig); |
1639 #else /* USDT2 */ | |
1640 HOTSPOT_JNI_GETMETHODID_ENTRY( | |
1641 env, clazz, (char *) name, (char *) sig); | |
1642 #endif /* USDT2 */ | |
1327 jmethodID ret = get_method_id(env, clazz, name, sig, false, thread); | 1643 jmethodID ret = get_method_id(env, clazz, name, sig, false, thread); |
1644 #ifndef USDT2 | |
1328 DTRACE_PROBE1(hotspot_jni, GetMethodID__return, ret); | 1645 DTRACE_PROBE1(hotspot_jni, GetMethodID__return, ret); |
1646 #else /* USDT2 */ | |
1647 HOTSPOT_JNI_GETMETHODID_RETURN( | |
1648 (uintptr_t) ret); | |
1649 #endif /* USDT2 */ | |
1329 return ret; | 1650 return ret; |
1330 JNI_END | 1651 JNI_END |
1331 | 1652 |
1332 | 1653 |
1333 JNI_ENTRY(jmethodID, jni_GetStaticMethodID(JNIEnv *env, jclass clazz, | 1654 JNI_ENTRY(jmethodID, jni_GetStaticMethodID(JNIEnv *env, jclass clazz, |
1334 const char *name, const char *sig)) | 1655 const char *name, const char *sig)) |
1335 JNIWrapper("GetStaticMethodID"); | 1656 JNIWrapper("GetStaticMethodID"); |
1657 #ifndef USDT2 | |
1336 DTRACE_PROBE4(hotspot_jni, GetStaticMethodID__entry, env, clazz, name, sig); | 1658 DTRACE_PROBE4(hotspot_jni, GetStaticMethodID__entry, env, clazz, name, sig); |
1659 #else /* USDT2 */ | |
1660 HOTSPOT_JNI_GETSTATICMETHODID_ENTRY( | |
1661 env, (char *) clazz, (char *) name, (char *)sig); | |
1662 #endif /* USDT2 */ | |
1337 jmethodID ret = get_method_id(env, clazz, name, sig, true, thread); | 1663 jmethodID ret = get_method_id(env, clazz, name, sig, true, thread); |
1664 #ifndef USDT2 | |
1338 DTRACE_PROBE1(hotspot_jni, GetStaticMethodID__return, ret); | 1665 DTRACE_PROBE1(hotspot_jni, GetStaticMethodID__return, ret); |
1666 #else /* USDT2 */ | |
1667 HOTSPOT_JNI_GETSTATICMETHODID_RETURN( | |
1668 (uintptr_t) ret); | |
1669 #endif /* USDT2 */ | |
1339 return ret; | 1670 return ret; |
1340 JNI_END | 1671 JNI_END |
1341 | 1672 |
1342 | 1673 |
1343 | 1674 |
1344 // | 1675 // |
1345 // Calling Methods | 1676 // Calling Methods |
1346 // | 1677 // |
1347 | 1678 |
1348 | 1679 #ifndef USDT2 |
1349 #define DEFINE_CALLMETHOD(ResultType, Result, Tag) \ | 1680 #define DEFINE_CALLMETHOD(ResultType, Result, Tag) \ |
1350 \ | 1681 \ |
1351 DT_RETURN_MARK_DECL_FOR(Result, Call##Result##Method, ResultType);\ | 1682 DT_RETURN_MARK_DECL_FOR(Result, Call##Result##Method, ResultType);\ |
1352 DT_RETURN_MARK_DECL_FOR(Result, Call##Result##MethodV, ResultType);\ | 1683 DT_RETURN_MARK_DECL_FOR(Result, Call##Result##MethodV, ResultType);\ |
1353 DT_RETURN_MARK_DECL_FOR(Result, Call##Result##MethodA, ResultType);\ | 1684 DT_RETURN_MARK_DECL_FOR(Result, Call##Result##MethodA, ResultType);\ |
1354 \ | 1685 \ |
1355 JNI_ENTRY(ResultType, \ | 1686 JNI_ENTRY(ResultType, \ |
1356 jni_Call##Result##Method(JNIEnv *env, jobject obj, jmethodID methodID, ...)) \ | 1687 jni_Call##Result##Method(JNIEnv *env, jobject obj, jmethodID methodID, ...)) \ |
1357 JNIWrapper("Call" XSTR(Result) "Method"); \ | 1688 JNIWrapper("Call" XSTR(Result) "Method"); \ |
1358 \ | 1689 \ |
1359 DTRACE_PROBE3(hotspot_jni, Call##Result##Method__entry, env, obj, methodID);\ | 1690 DTRACE_PROBE3(hotspot_jni, Call##Result##Method__entry, env, obj, methodID); \ |
1360 ResultType ret = 0;\ | 1691 ResultType ret = 0;\ |
1361 DT_RETURN_MARK_FOR(Result, Call##Result##Method, ResultType, \ | 1692 DT_RETURN_MARK_FOR(Result, Call##Result##Method, ResultType, \ |
1362 (const ResultType&)ret);\ | 1693 (const ResultType&)ret);\ |
1363 \ | 1694 \ |
1364 va_list args; \ | 1695 va_list args; \ |
1374 \ | 1705 \ |
1375 JNI_ENTRY(ResultType, \ | 1706 JNI_ENTRY(ResultType, \ |
1376 jni_Call##Result##MethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)) \ | 1707 jni_Call##Result##MethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)) \ |
1377 JNIWrapper("Call" XSTR(Result) "MethodV"); \ | 1708 JNIWrapper("Call" XSTR(Result) "MethodV"); \ |
1378 \ | 1709 \ |
1379 DTRACE_PROBE3(hotspot_jni, Call##Result##MethodV__entry, env, obj, methodID);\ | 1710 DTRACE_PROBE3(hotspot_jni, Call##Result##MethodV__entry, env, obj, methodID); \ |
1380 ResultType ret = 0;\ | 1711 ResultType ret = 0;\ |
1381 DT_RETURN_MARK_FOR(Result, Call##Result##MethodV, ResultType, \ | 1712 DT_RETURN_MARK_FOR(Result, Call##Result##MethodV, ResultType, \ |
1382 (const ResultType&)ret);\ | 1713 (const ResultType&)ret);\ |
1383 \ | 1714 \ |
1384 JavaValue jvalue(Tag); \ | 1715 JavaValue jvalue(Tag); \ |
1390 \ | 1721 \ |
1391 \ | 1722 \ |
1392 JNI_ENTRY(ResultType, \ | 1723 JNI_ENTRY(ResultType, \ |
1393 jni_Call##Result##MethodA(JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args)) \ | 1724 jni_Call##Result##MethodA(JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args)) \ |
1394 JNIWrapper("Call" XSTR(Result) "MethodA"); \ | 1725 JNIWrapper("Call" XSTR(Result) "MethodA"); \ |
1395 DTRACE_PROBE3(hotspot_jni, Call##Result##MethodA__entry, env, obj, methodID);\ | 1726 DTRACE_PROBE3(hotspot_jni, Call##Result##MethodA__entry, env, obj, methodID); \ |
1396 ResultType ret = 0;\ | 1727 ResultType ret = 0;\ |
1397 DT_RETURN_MARK_FOR(Result, Call##Result##MethodA, ResultType, \ | 1728 DT_RETURN_MARK_FOR(Result, Call##Result##MethodA, ResultType, \ |
1398 (const ResultType&)ret);\ | 1729 (const ResultType&)ret);\ |
1399 \ | 1730 \ |
1400 JavaValue jvalue(Tag); \ | 1731 JavaValue jvalue(Tag); \ |
1418 | 1749 |
1419 DT_VOID_RETURN_MARK_DECL(CallVoidMethod); | 1750 DT_VOID_RETURN_MARK_DECL(CallVoidMethod); |
1420 DT_VOID_RETURN_MARK_DECL(CallVoidMethodV); | 1751 DT_VOID_RETURN_MARK_DECL(CallVoidMethodV); |
1421 DT_VOID_RETURN_MARK_DECL(CallVoidMethodA); | 1752 DT_VOID_RETURN_MARK_DECL(CallVoidMethodA); |
1422 | 1753 |
1754 #else /* USDT2 */ | |
1755 | |
1756 #define DEFINE_CALLMETHOD(ResultType, Result, Tag \ | |
1757 , EntryProbe, ReturnProbe) \ | |
1758 \ | |
1759 DT_RETURN_MARK_DECL_FOR(Result, Call##Result##Method, ResultType \ | |
1760 , ReturnProbe); \ | |
1761 \ | |
1762 JNI_ENTRY(ResultType, \ | |
1763 jni_Call##Result##Method(JNIEnv *env, jobject obj, jmethodID methodID, ...)) \ | |
1764 JNIWrapper("Call" XSTR(Result) "Method"); \ | |
1765 \ | |
1766 EntryProbe; \ | |
1767 ResultType ret = 0;\ | |
1768 DT_RETURN_MARK_FOR(Result, Call##Result##Method, ResultType, \ | |
1769 (const ResultType&)ret);\ | |
1770 \ | |
1771 va_list args; \ | |
1772 va_start(args, methodID); \ | |
1773 JavaValue jvalue(Tag); \ | |
1774 JNI_ArgumentPusherVaArg ap(methodID, args); \ | |
1775 jni_invoke_nonstatic(env, &jvalue, obj, JNI_VIRTUAL, methodID, &ap, CHECK_0); \ | |
1776 va_end(args); \ | |
1777 ret = jvalue.get_##ResultType(); \ | |
1778 return ret;\ | |
1779 JNI_END | |
1780 | |
1781 // the runtime type of subword integral basic types is integer | |
1782 DEFINE_CALLMETHOD(jboolean, Boolean, T_BOOLEAN | |
1783 , HOTSPOT_JNI_CALLBOOLEANMETHOD_ENTRY(env, obj, (uintptr_t)methodID), | |
1784 HOTSPOT_JNI_CALLBOOLEANMETHOD_RETURN(_ret_ref)) | |
1785 DEFINE_CALLMETHOD(jbyte, Byte, T_BYTE | |
1786 , HOTSPOT_JNI_CALLBYTEMETHOD_ENTRY(env, obj, (uintptr_t)methodID), | |
1787 HOTSPOT_JNI_CALLBYTEMETHOD_RETURN(_ret_ref)) | |
1788 DEFINE_CALLMETHOD(jchar, Char, T_CHAR | |
1789 , HOTSPOT_JNI_CALLCHARMETHOD_ENTRY(env, obj, (uintptr_t)methodID), | |
1790 HOTSPOT_JNI_CALLCHARMETHOD_RETURN(_ret_ref)) | |
1791 DEFINE_CALLMETHOD(jshort, Short, T_SHORT | |
1792 , HOTSPOT_JNI_CALLSHORTMETHOD_ENTRY(env, obj, (uintptr_t)methodID), | |
1793 HOTSPOT_JNI_CALLSHORTMETHOD_RETURN(_ret_ref)) | |
1794 | |
1795 DEFINE_CALLMETHOD(jobject, Object, T_OBJECT | |
1796 , HOTSPOT_JNI_CALLOBJECTMETHOD_ENTRY(env, obj, (uintptr_t)methodID), | |
1797 HOTSPOT_JNI_CALLOBJECTMETHOD_RETURN(_ret_ref)) | |
1798 DEFINE_CALLMETHOD(jint, Int, T_INT, | |
1799 HOTSPOT_JNI_CALLINTMETHOD_ENTRY(env, obj, (uintptr_t)methodID), | |
1800 HOTSPOT_JNI_CALLINTMETHOD_RETURN(_ret_ref)) | |
1801 DEFINE_CALLMETHOD(jlong, Long, T_LONG | |
1802 , HOTSPOT_JNI_CALLLONGMETHOD_ENTRY(env, obj, (uintptr_t)methodID), | |
1803 HOTSPOT_JNI_CALLLONGMETHOD_RETURN(_ret_ref)) | |
1804 // Float and double probes don't return value because dtrace doesn't currently support it | |
1805 DEFINE_CALLMETHOD(jfloat, Float, T_FLOAT | |
1806 , HOTSPOT_JNI_CALLFLOATMETHOD_ENTRY(env, obj, (uintptr_t)methodID), | |
1807 HOTSPOT_JNI_CALLFLOATMETHOD_RETURN()) | |
1808 DEFINE_CALLMETHOD(jdouble, Double, T_DOUBLE | |
1809 , HOTSPOT_JNI_CALLDOUBLEMETHOD_ENTRY(env, obj, (uintptr_t)methodID), | |
1810 HOTSPOT_JNI_CALLDOUBLEMETHOD_RETURN()) | |
1811 | |
1812 #define DEFINE_CALLMETHODV(ResultType, Result, Tag \ | |
1813 , EntryProbe, ReturnProbe) \ | |
1814 \ | |
1815 DT_RETURN_MARK_DECL_FOR(Result, Call##Result##MethodV, ResultType \ | |
1816 , ReturnProbe); \ | |
1817 \ | |
1818 JNI_ENTRY(ResultType, \ | |
1819 jni_Call##Result##MethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)) \ | |
1820 JNIWrapper("Call" XSTR(Result) "MethodV"); \ | |
1821 \ | |
1822 EntryProbe;\ | |
1823 ResultType ret = 0;\ | |
1824 DT_RETURN_MARK_FOR(Result, Call##Result##MethodV, ResultType, \ | |
1825 (const ResultType&)ret);\ | |
1826 \ | |
1827 JavaValue jvalue(Tag); \ | |
1828 JNI_ArgumentPusherVaArg ap(methodID, args); \ | |
1829 jni_invoke_nonstatic(env, &jvalue, obj, JNI_VIRTUAL, methodID, &ap, CHECK_0); \ | |
1830 ret = jvalue.get_##ResultType(); \ | |
1831 return ret;\ | |
1832 JNI_END | |
1833 | |
1834 // the runtime type of subword integral basic types is integer | |
1835 DEFINE_CALLMETHODV(jboolean, Boolean, T_BOOLEAN | |
1836 , HOTSPOT_JNI_CALLBOOLEANMETHOD_ENTRY(env, obj, (uintptr_t)methodID), | |
1837 HOTSPOT_JNI_CALLBOOLEANMETHOD_RETURN(_ret_ref)) | |
1838 DEFINE_CALLMETHODV(jbyte, Byte, T_BYTE | |
1839 , HOTSPOT_JNI_CALLBYTEMETHOD_ENTRY(env, obj, (uintptr_t)methodID), | |
1840 HOTSPOT_JNI_CALLBYTEMETHOD_RETURN(_ret_ref)) | |
1841 DEFINE_CALLMETHODV(jchar, Char, T_CHAR | |
1842 , HOTSPOT_JNI_CALLCHARMETHOD_ENTRY(env, obj, (uintptr_t)methodID), | |
1843 HOTSPOT_JNI_CALLCHARMETHOD_RETURN(_ret_ref)) | |
1844 DEFINE_CALLMETHODV(jshort, Short, T_SHORT | |
1845 , HOTSPOT_JNI_CALLSHORTMETHOD_ENTRY(env, obj, (uintptr_t)methodID), | |
1846 HOTSPOT_JNI_CALLSHORTMETHOD_RETURN(_ret_ref)) | |
1847 | |
1848 DEFINE_CALLMETHODV(jobject, Object, T_OBJECT | |
1849 , HOTSPOT_JNI_CALLOBJECTMETHOD_ENTRY(env, obj, (uintptr_t)methodID), | |
1850 HOTSPOT_JNI_CALLOBJECTMETHOD_RETURN(_ret_ref)) | |
1851 DEFINE_CALLMETHODV(jint, Int, T_INT, | |
1852 HOTSPOT_JNI_CALLINTMETHOD_ENTRY(env, obj, (uintptr_t)methodID), | |
1853 HOTSPOT_JNI_CALLINTMETHOD_RETURN(_ret_ref)) | |
1854 DEFINE_CALLMETHODV(jlong, Long, T_LONG | |
1855 , HOTSPOT_JNI_CALLLONGMETHOD_ENTRY(env, obj, (uintptr_t)methodID), | |
1856 HOTSPOT_JNI_CALLLONGMETHOD_RETURN(_ret_ref)) | |
1857 // Float and double probes don't return value because dtrace doesn't currently support it | |
1858 DEFINE_CALLMETHODV(jfloat, Float, T_FLOAT | |
1859 , HOTSPOT_JNI_CALLFLOATMETHOD_ENTRY(env, obj, (uintptr_t)methodID), | |
1860 HOTSPOT_JNI_CALLFLOATMETHOD_RETURN()) | |
1861 DEFINE_CALLMETHODV(jdouble, Double, T_DOUBLE | |
1862 , HOTSPOT_JNI_CALLDOUBLEMETHOD_ENTRY(env, obj, (uintptr_t)methodID), | |
1863 HOTSPOT_JNI_CALLDOUBLEMETHOD_RETURN()) | |
1864 | |
1865 #define DEFINE_CALLMETHODA(ResultType, Result, Tag \ | |
1866 , EntryProbe, ReturnProbe) \ | |
1867 \ | |
1868 DT_RETURN_MARK_DECL_FOR(Result, Call##Result##MethodA, ResultType \ | |
1869 , ReturnProbe); \ | |
1870 \ | |
1871 JNI_ENTRY(ResultType, \ | |
1872 jni_Call##Result##MethodA(JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args)) \ | |
1873 JNIWrapper("Call" XSTR(Result) "MethodA"); \ | |
1874 EntryProbe; \ | |
1875 ResultType ret = 0;\ | |
1876 DT_RETURN_MARK_FOR(Result, Call##Result##MethodA, ResultType, \ | |
1877 (const ResultType&)ret);\ | |
1878 \ | |
1879 JavaValue jvalue(Tag); \ | |
1880 JNI_ArgumentPusherArray ap(methodID, args); \ | |
1881 jni_invoke_nonstatic(env, &jvalue, obj, JNI_VIRTUAL, methodID, &ap, CHECK_0); \ | |
1882 ret = jvalue.get_##ResultType(); \ | |
1883 return ret;\ | |
1884 JNI_END | |
1885 | |
1886 // the runtime type of subword integral basic types is integer | |
1887 DEFINE_CALLMETHODA(jboolean, Boolean, T_BOOLEAN | |
1888 , HOTSPOT_JNI_CALLBOOLEANMETHOD_ENTRY(env, obj, (uintptr_t)methodID), | |
1889 HOTSPOT_JNI_CALLBOOLEANMETHOD_RETURN(_ret_ref)) | |
1890 DEFINE_CALLMETHODA(jbyte, Byte, T_BYTE | |
1891 , HOTSPOT_JNI_CALLBYTEMETHOD_ENTRY(env, obj, (uintptr_t)methodID), | |
1892 HOTSPOT_JNI_CALLBYTEMETHOD_RETURN(_ret_ref)) | |
1893 DEFINE_CALLMETHODA(jchar, Char, T_CHAR | |
1894 , HOTSPOT_JNI_CALLCHARMETHOD_ENTRY(env, obj, (uintptr_t)methodID), | |
1895 HOTSPOT_JNI_CALLCHARMETHOD_RETURN(_ret_ref)) | |
1896 DEFINE_CALLMETHODA(jshort, Short, T_SHORT | |
1897 , HOTSPOT_JNI_CALLSHORTMETHOD_ENTRY(env, obj, (uintptr_t)methodID), | |
1898 HOTSPOT_JNI_CALLSHORTMETHOD_RETURN(_ret_ref)) | |
1899 | |
1900 DEFINE_CALLMETHODA(jobject, Object, T_OBJECT | |
1901 , HOTSPOT_JNI_CALLOBJECTMETHOD_ENTRY(env, obj, (uintptr_t)methodID), | |
1902 HOTSPOT_JNI_CALLOBJECTMETHOD_RETURN(_ret_ref)) | |
1903 DEFINE_CALLMETHODA(jint, Int, T_INT, | |
1904 HOTSPOT_JNI_CALLINTMETHOD_ENTRY(env, obj, (uintptr_t)methodID), | |
1905 HOTSPOT_JNI_CALLINTMETHOD_RETURN(_ret_ref)) | |
1906 DEFINE_CALLMETHODA(jlong, Long, T_LONG | |
1907 , HOTSPOT_JNI_CALLLONGMETHOD_ENTRY(env, obj, (uintptr_t)methodID), | |
1908 HOTSPOT_JNI_CALLLONGMETHOD_RETURN(_ret_ref)) | |
1909 // Float and double probes don't return value because dtrace doesn't currently support it | |
1910 DEFINE_CALLMETHODA(jfloat, Float, T_FLOAT | |
1911 , HOTSPOT_JNI_CALLFLOATMETHOD_ENTRY(env, obj, (uintptr_t)methodID), | |
1912 HOTSPOT_JNI_CALLFLOATMETHOD_RETURN()) | |
1913 DEFINE_CALLMETHODA(jdouble, Double, T_DOUBLE | |
1914 , HOTSPOT_JNI_CALLDOUBLEMETHOD_ENTRY(env, obj, (uintptr_t)methodID), | |
1915 HOTSPOT_JNI_CALLDOUBLEMETHOD_RETURN()) | |
1916 | |
1917 DT_VOID_RETURN_MARK_DECL(CallVoidMethod, HOTSPOT_JNI_CALLVOIDMETHOD_RETURN()); | |
1918 DT_VOID_RETURN_MARK_DECL(CallVoidMethodV, HOTSPOT_JNI_CALLVOIDMETHODV_RETURN()); | |
1919 DT_VOID_RETURN_MARK_DECL(CallVoidMethodA, HOTSPOT_JNI_CALLVOIDMETHODA_RETURN()); | |
1920 | |
1921 #endif /* USDT2 */ | |
1922 | |
1423 JNI_ENTRY(void, jni_CallVoidMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)) | 1923 JNI_ENTRY(void, jni_CallVoidMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)) |
1424 JNIWrapper("CallVoidMethod"); | 1924 JNIWrapper("CallVoidMethod"); |
1925 #ifndef USDT2 | |
1425 DTRACE_PROBE3(hotspot_jni, CallVoidMethod__entry, env, obj, methodID); | 1926 DTRACE_PROBE3(hotspot_jni, CallVoidMethod__entry, env, obj, methodID); |
1927 #else /* USDT2 */ | |
1928 HOTSPOT_JNI_CALLVOIDMETHOD_ENTRY( | |
1929 env, obj, (uintptr_t) methodID); | |
1930 #endif /* USDT2 */ | |
1426 DT_VOID_RETURN_MARK(CallVoidMethod); | 1931 DT_VOID_RETURN_MARK(CallVoidMethod); |
1427 | 1932 |
1428 va_list args; | 1933 va_list args; |
1429 va_start(args, methodID); | 1934 va_start(args, methodID); |
1430 JavaValue jvalue(T_VOID); | 1935 JavaValue jvalue(T_VOID); |
1434 JNI_END | 1939 JNI_END |
1435 | 1940 |
1436 | 1941 |
1437 JNI_ENTRY(void, jni_CallVoidMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)) | 1942 JNI_ENTRY(void, jni_CallVoidMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)) |
1438 JNIWrapper("CallVoidMethodV"); | 1943 JNIWrapper("CallVoidMethodV"); |
1944 #ifndef USDT2 | |
1439 DTRACE_PROBE3(hotspot_jni, CallVoidMethodV__entry, env, obj, methodID); | 1945 DTRACE_PROBE3(hotspot_jni, CallVoidMethodV__entry, env, obj, methodID); |
1946 #else /* USDT2 */ | |
1947 HOTSPOT_JNI_CALLVOIDMETHODV_ENTRY( | |
1948 env, obj, (uintptr_t) methodID); | |
1949 #endif /* USDT2 */ | |
1440 DT_VOID_RETURN_MARK(CallVoidMethodV); | 1950 DT_VOID_RETURN_MARK(CallVoidMethodV); |
1441 | 1951 |
1442 JavaValue jvalue(T_VOID); | 1952 JavaValue jvalue(T_VOID); |
1443 JNI_ArgumentPusherVaArg ap(methodID, args); | 1953 JNI_ArgumentPusherVaArg ap(methodID, args); |
1444 jni_invoke_nonstatic(env, &jvalue, obj, JNI_VIRTUAL, methodID, &ap, CHECK); | 1954 jni_invoke_nonstatic(env, &jvalue, obj, JNI_VIRTUAL, methodID, &ap, CHECK); |
1445 JNI_END | 1955 JNI_END |
1446 | 1956 |
1447 | 1957 |
1448 JNI_ENTRY(void, jni_CallVoidMethodA(JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args)) | 1958 JNI_ENTRY(void, jni_CallVoidMethodA(JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args)) |
1449 JNIWrapper("CallVoidMethodA"); | 1959 JNIWrapper("CallVoidMethodA"); |
1960 #ifndef USDT2 | |
1450 DTRACE_PROBE3(hotspot_jni, CallVoidMethodA__entry, env, obj, methodID); | 1961 DTRACE_PROBE3(hotspot_jni, CallVoidMethodA__entry, env, obj, methodID); |
1962 #else /* USDT2 */ | |
1963 HOTSPOT_JNI_CALLVOIDMETHODA_ENTRY( | |
1964 env, obj, (uintptr_t) methodID); | |
1965 #endif /* USDT2 */ | |
1451 DT_VOID_RETURN_MARK(CallVoidMethodA); | 1966 DT_VOID_RETURN_MARK(CallVoidMethodA); |
1452 | 1967 |
1453 JavaValue jvalue(T_VOID); | 1968 JavaValue jvalue(T_VOID); |
1454 JNI_ArgumentPusherArray ap(methodID, args); | 1969 JNI_ArgumentPusherArray ap(methodID, args); |
1455 jni_invoke_nonstatic(env, &jvalue, obj, JNI_VIRTUAL, methodID, &ap, CHECK); | 1970 jni_invoke_nonstatic(env, &jvalue, obj, JNI_VIRTUAL, methodID, &ap, CHECK); |
1456 JNI_END | 1971 JNI_END |
1457 | 1972 |
1458 | 1973 |
1974 #ifndef USDT2 | |
1459 #define DEFINE_CALLNONVIRTUALMETHOD(ResultType, Result, Tag) \ | 1975 #define DEFINE_CALLNONVIRTUALMETHOD(ResultType, Result, Tag) \ |
1460 \ | 1976 \ |
1461 DT_RETURN_MARK_DECL_FOR(Result, CallNonvirtual##Result##Method, ResultType);\ | 1977 DT_RETURN_MARK_DECL_FOR(Result, CallNonvirtual##Result##Method, ResultType);\ |
1462 DT_RETURN_MARK_DECL_FOR(Result, CallNonvirtual##Result##MethodV, ResultType);\ | 1978 DT_RETURN_MARK_DECL_FOR(Result, CallNonvirtual##Result##MethodV, ResultType);\ |
1463 DT_RETURN_MARK_DECL_FOR(Result, CallNonvirtual##Result##MethodA, ResultType);\ | 1979 DT_RETURN_MARK_DECL_FOR(Result, CallNonvirtual##Result##MethodA, ResultType);\ |
1526 | 2042 |
1527 DT_VOID_RETURN_MARK_DECL(CallNonvirtualVoidMethod); | 2043 DT_VOID_RETURN_MARK_DECL(CallNonvirtualVoidMethod); |
1528 DT_VOID_RETURN_MARK_DECL(CallNonvirtualVoidMethodV); | 2044 DT_VOID_RETURN_MARK_DECL(CallNonvirtualVoidMethodV); |
1529 DT_VOID_RETURN_MARK_DECL(CallNonvirtualVoidMethodA); | 2045 DT_VOID_RETURN_MARK_DECL(CallNonvirtualVoidMethodA); |
1530 | 2046 |
2047 #else /* USDT2 */ | |
2048 | |
2049 #define DEFINE_CALLNONVIRTUALMETHOD(ResultType, Result, Tag \ | |
2050 , EntryProbe, ReturnProbe) \ | |
2051 \ | |
2052 DT_RETURN_MARK_DECL_FOR(Result, CallNonvirtual##Result##Method, ResultType \ | |
2053 , ReturnProbe);\ | |
2054 \ | |
2055 JNI_ENTRY(ResultType, \ | |
2056 jni_CallNonvirtual##Result##Method(JNIEnv *env, jobject obj, jclass cls, jmethodID methodID, ...)) \ | |
2057 JNIWrapper("CallNonvitual" XSTR(Result) "Method"); \ | |
2058 \ | |
2059 EntryProbe;\ | |
2060 ResultType ret;\ | |
2061 DT_RETURN_MARK_FOR(Result, CallNonvirtual##Result##Method, ResultType, \ | |
2062 (const ResultType&)ret);\ | |
2063 \ | |
2064 va_list args; \ | |
2065 va_start(args, methodID); \ | |
2066 JavaValue jvalue(Tag); \ | |
2067 JNI_ArgumentPusherVaArg ap(methodID, args); \ | |
2068 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK_0); \ | |
2069 va_end(args); \ | |
2070 ret = jvalue.get_##ResultType(); \ | |
2071 return ret;\ | |
2072 JNI_END | |
2073 | |
2074 // the runtime type of subword integral basic types is integer | |
2075 DEFINE_CALLNONVIRTUALMETHOD(jboolean, Boolean, T_BOOLEAN | |
2076 , HOTSPOT_JNI_CALLNONVIRTUALBOOLEANMETHOD_ENTRY(env, obj, cls, (uintptr_t)methodID), | |
2077 HOTSPOT_JNI_CALLNONVIRTUALBOOLEANMETHOD_RETURN(_ret_ref)) | |
2078 DEFINE_CALLNONVIRTUALMETHOD(jbyte, Byte, T_BYTE | |
2079 , HOTSPOT_JNI_CALLNONVIRTUALBYTEMETHOD_ENTRY(env, obj, cls, (uintptr_t)methodID), | |
2080 HOTSPOT_JNI_CALLNONVIRTUALBYTEMETHOD_RETURN(_ret_ref)) | |
2081 DEFINE_CALLNONVIRTUALMETHOD(jchar, Char, T_CHAR | |
2082 , HOTSPOT_JNI_CALLNONVIRTUALCHARMETHOD_ENTRY(env, obj, cls, (uintptr_t)methodID), | |
2083 HOTSPOT_JNI_CALLNONVIRTUALCHARMETHOD_RETURN(_ret_ref)) | |
2084 DEFINE_CALLNONVIRTUALMETHOD(jshort, Short, T_SHORT | |
2085 , HOTSPOT_JNI_CALLNONVIRTUALSHORTMETHOD_ENTRY(env, obj, cls, (uintptr_t)methodID), | |
2086 HOTSPOT_JNI_CALLNONVIRTUALSHORTMETHOD_RETURN(_ret_ref)) | |
2087 | |
2088 DEFINE_CALLNONVIRTUALMETHOD(jobject, Object, T_OBJECT | |
2089 , HOTSPOT_JNI_CALLNONVIRTUALOBJECTMETHOD_ENTRY(env, obj, cls, (uintptr_t)methodID), | |
2090 HOTSPOT_JNI_CALLNONVIRTUALOBJECTMETHOD_RETURN(_ret_ref)) | |
2091 DEFINE_CALLNONVIRTUALMETHOD(jint, Int, T_INT | |
2092 , HOTSPOT_JNI_CALLNONVIRTUALINTMETHOD_ENTRY(env, obj, cls, (uintptr_t)methodID), | |
2093 HOTSPOT_JNI_CALLNONVIRTUALINTMETHOD_RETURN(_ret_ref)) | |
2094 DEFINE_CALLNONVIRTUALMETHOD(jlong, Long, T_LONG | |
2095 , HOTSPOT_JNI_CALLNONVIRTUALLONGMETHOD_ENTRY(env, obj, cls, (uintptr_t)methodID), | |
2096 // Float and double probes don't return value because dtrace doesn't currently support it | |
2097 HOTSPOT_JNI_CALLNONVIRTUALLONGMETHOD_RETURN(_ret_ref)) | |
2098 DEFINE_CALLNONVIRTUALMETHOD(jfloat, Float, T_FLOAT | |
2099 , HOTSPOT_JNI_CALLNONVIRTUALFLOATMETHOD_ENTRY(env, obj, cls, (uintptr_t)methodID), | |
2100 HOTSPOT_JNI_CALLNONVIRTUALFLOATMETHOD_RETURN()) | |
2101 DEFINE_CALLNONVIRTUALMETHOD(jdouble, Double, T_DOUBLE | |
2102 , HOTSPOT_JNI_CALLNONVIRTUALDOUBLEMETHOD_ENTRY(env, obj, cls, (uintptr_t)methodID), | |
2103 HOTSPOT_JNI_CALLNONVIRTUALDOUBLEMETHOD_RETURN()) | |
2104 | |
2105 #define DEFINE_CALLNONVIRTUALMETHODV(ResultType, Result, Tag \ | |
2106 , EntryProbe, ReturnProbe) \ | |
2107 \ | |
2108 DT_RETURN_MARK_DECL_FOR(Result, CallNonvirtual##Result##MethodV, ResultType \ | |
2109 , ReturnProbe);\ | |
2110 \ | |
2111 JNI_ENTRY(ResultType, \ | |
2112 jni_CallNonvirtual##Result##MethodV(JNIEnv *env, jobject obj, jclass cls, jmethodID methodID, va_list args)) \ | |
2113 JNIWrapper("CallNonvitual" XSTR(Result) "MethodV"); \ | |
2114 \ | |
2115 EntryProbe;\ | |
2116 ResultType ret;\ | |
2117 DT_RETURN_MARK_FOR(Result, CallNonvirtual##Result##MethodV, ResultType, \ | |
2118 (const ResultType&)ret);\ | |
2119 \ | |
2120 JavaValue jvalue(Tag); \ | |
2121 JNI_ArgumentPusherVaArg ap(methodID, args); \ | |
2122 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK_0); \ | |
2123 ret = jvalue.get_##ResultType(); \ | |
2124 return ret;\ | |
2125 JNI_END | |
2126 | |
2127 // the runtime type of subword integral basic types is integer | |
2128 DEFINE_CALLNONVIRTUALMETHODV(jboolean, Boolean, T_BOOLEAN | |
2129 , HOTSPOT_JNI_CALLNONVIRTUALBOOLEANMETHODV_ENTRY(env, obj, cls, (uintptr_t)methodID), | |
2130 HOTSPOT_JNI_CALLNONVIRTUALBOOLEANMETHODV_RETURN(_ret_ref)) | |
2131 DEFINE_CALLNONVIRTUALMETHODV(jbyte, Byte, T_BYTE | |
2132 , HOTSPOT_JNI_CALLNONVIRTUALBYTEMETHODV_ENTRY(env, obj, cls, (uintptr_t)methodID), | |
2133 HOTSPOT_JNI_CALLNONVIRTUALBYTEMETHODV_RETURN(_ret_ref)) | |
2134 DEFINE_CALLNONVIRTUALMETHODV(jchar, Char, T_CHAR | |
2135 , HOTSPOT_JNI_CALLNONVIRTUALCHARMETHODV_ENTRY(env, obj, cls, (uintptr_t)methodID), | |
2136 HOTSPOT_JNI_CALLNONVIRTUALCHARMETHODV_RETURN(_ret_ref)) | |
2137 DEFINE_CALLNONVIRTUALMETHODV(jshort, Short, T_SHORT | |
2138 , HOTSPOT_JNI_CALLNONVIRTUALSHORTMETHODV_ENTRY(env, obj, cls, (uintptr_t)methodID), | |
2139 HOTSPOT_JNI_CALLNONVIRTUALSHORTMETHODV_RETURN(_ret_ref)) | |
2140 | |
2141 DEFINE_CALLNONVIRTUALMETHODV(jobject, Object, T_OBJECT | |
2142 , HOTSPOT_JNI_CALLNONVIRTUALOBJECTMETHODV_ENTRY(env, obj, cls, (uintptr_t)methodID), | |
2143 HOTSPOT_JNI_CALLNONVIRTUALOBJECTMETHODV_RETURN(_ret_ref)) | |
2144 DEFINE_CALLNONVIRTUALMETHODV(jint, Int, T_INT | |
2145 , HOTSPOT_JNI_CALLNONVIRTUALINTMETHODV_ENTRY(env, obj, cls, (uintptr_t)methodID), | |
2146 HOTSPOT_JNI_CALLNONVIRTUALINTMETHODV_RETURN(_ret_ref)) | |
2147 DEFINE_CALLNONVIRTUALMETHODV(jlong, Long, T_LONG | |
2148 , HOTSPOT_JNI_CALLNONVIRTUALLONGMETHODV_ENTRY(env, obj, cls, (uintptr_t)methodID), | |
2149 // Float and double probes don't return value because dtrace doesn't currently support it | |
2150 HOTSPOT_JNI_CALLNONVIRTUALLONGMETHODV_RETURN(_ret_ref)) | |
2151 DEFINE_CALLNONVIRTUALMETHODV(jfloat, Float, T_FLOAT | |
2152 , HOTSPOT_JNI_CALLNONVIRTUALFLOATMETHODV_ENTRY(env, obj, cls, (uintptr_t)methodID), | |
2153 HOTSPOT_JNI_CALLNONVIRTUALFLOATMETHODV_RETURN()) | |
2154 DEFINE_CALLNONVIRTUALMETHODV(jdouble, Double, T_DOUBLE | |
2155 , HOTSPOT_JNI_CALLNONVIRTUALDOUBLEMETHODV_ENTRY(env, obj, cls, (uintptr_t)methodID), | |
2156 HOTSPOT_JNI_CALLNONVIRTUALDOUBLEMETHODV_RETURN()) | |
2157 | |
2158 #define DEFINE_CALLNONVIRTUALMETHODA(ResultType, Result, Tag \ | |
2159 , EntryProbe, ReturnProbe) \ | |
2160 \ | |
2161 DT_RETURN_MARK_DECL_FOR(Result, CallNonvirtual##Result##MethodA, ResultType \ | |
2162 , ReturnProbe);\ | |
2163 \ | |
2164 JNI_ENTRY(ResultType, \ | |
2165 jni_CallNonvirtual##Result##MethodA(JNIEnv *env, jobject obj, jclass cls, jmethodID methodID, const jvalue *args)) \ | |
2166 JNIWrapper("CallNonvitual" XSTR(Result) "MethodA"); \ | |
2167 \ | |
2168 EntryProbe;\ | |
2169 ResultType ret;\ | |
2170 DT_RETURN_MARK_FOR(Result, CallNonvirtual##Result##MethodA, ResultType, \ | |
2171 (const ResultType&)ret);\ | |
2172 \ | |
2173 JavaValue jvalue(Tag); \ | |
2174 JNI_ArgumentPusherArray ap(methodID, args); \ | |
2175 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK_0); \ | |
2176 ret = jvalue.get_##ResultType(); \ | |
2177 return ret;\ | |
2178 JNI_END | |
2179 | |
2180 // the runtime type of subword integral basic types is integer | |
2181 DEFINE_CALLNONVIRTUALMETHODA(jboolean, Boolean, T_BOOLEAN | |
2182 , HOTSPOT_JNI_CALLNONVIRTUALBOOLEANMETHODA_ENTRY(env, obj, cls, (uintptr_t)methodID), | |
2183 HOTSPOT_JNI_CALLNONVIRTUALBOOLEANMETHODA_RETURN(_ret_ref)) | |
2184 DEFINE_CALLNONVIRTUALMETHODA(jbyte, Byte, T_BYTE | |
2185 , HOTSPOT_JNI_CALLNONVIRTUALBYTEMETHODA_ENTRY(env, obj, cls, (uintptr_t)methodID), | |
2186 HOTSPOT_JNI_CALLNONVIRTUALBYTEMETHODA_RETURN(_ret_ref)) | |
2187 DEFINE_CALLNONVIRTUALMETHODA(jchar, Char, T_CHAR | |
2188 , HOTSPOT_JNI_CALLNONVIRTUALCHARMETHODA_ENTRY(env, obj, cls, (uintptr_t)methodID), | |
2189 HOTSPOT_JNI_CALLNONVIRTUALCHARMETHODA_RETURN(_ret_ref)) | |
2190 DEFINE_CALLNONVIRTUALMETHODA(jshort, Short, T_SHORT | |
2191 , HOTSPOT_JNI_CALLNONVIRTUALSHORTMETHODA_ENTRY(env, obj, cls, (uintptr_t)methodID), | |
2192 HOTSPOT_JNI_CALLNONVIRTUALSHORTMETHODA_RETURN(_ret_ref)) | |
2193 | |
2194 DEFINE_CALLNONVIRTUALMETHODA(jobject, Object, T_OBJECT | |
2195 , HOTSPOT_JNI_CALLNONVIRTUALOBJECTMETHODA_ENTRY(env, obj, cls, (uintptr_t)methodID), | |
2196 HOTSPOT_JNI_CALLNONVIRTUALOBJECTMETHODA_RETURN(_ret_ref)) | |
2197 DEFINE_CALLNONVIRTUALMETHODA(jint, Int, T_INT | |
2198 , HOTSPOT_JNI_CALLNONVIRTUALINTMETHODA_ENTRY(env, obj, cls, (uintptr_t)methodID), | |
2199 HOTSPOT_JNI_CALLNONVIRTUALINTMETHODA_RETURN(_ret_ref)) | |
2200 DEFINE_CALLNONVIRTUALMETHODA(jlong, Long, T_LONG | |
2201 , HOTSPOT_JNI_CALLNONVIRTUALLONGMETHODA_ENTRY(env, obj, cls, (uintptr_t)methodID), | |
2202 // Float and double probes don't return value because dtrace doesn't currently support it | |
2203 HOTSPOT_JNI_CALLNONVIRTUALLONGMETHODA_RETURN(_ret_ref)) | |
2204 DEFINE_CALLNONVIRTUALMETHODA(jfloat, Float, T_FLOAT | |
2205 , HOTSPOT_JNI_CALLNONVIRTUALFLOATMETHODA_ENTRY(env, obj, cls, (uintptr_t)methodID), | |
2206 HOTSPOT_JNI_CALLNONVIRTUALFLOATMETHODA_RETURN()) | |
2207 DEFINE_CALLNONVIRTUALMETHODA(jdouble, Double, T_DOUBLE | |
2208 , HOTSPOT_JNI_CALLNONVIRTUALDOUBLEMETHODA_ENTRY(env, obj, cls, (uintptr_t)methodID), | |
2209 HOTSPOT_JNI_CALLNONVIRTUALDOUBLEMETHODA_RETURN()) | |
2210 | |
2211 DT_VOID_RETURN_MARK_DECL(CallNonvirtualVoidMethod | |
2212 , HOTSPOT_JNI_CALLNONVIRTUALVOIDMETHOD_RETURN()); | |
2213 DT_VOID_RETURN_MARK_DECL(CallNonvirtualVoidMethodV | |
2214 , HOTSPOT_JNI_CALLNONVIRTUALVOIDMETHODV_RETURN()); | |
2215 DT_VOID_RETURN_MARK_DECL(CallNonvirtualVoidMethodA | |
2216 , HOTSPOT_JNI_CALLNONVIRTUALVOIDMETHODA_RETURN()); | |
2217 #endif /* USDT2 */ | |
2218 | |
1531 JNI_ENTRY(void, jni_CallNonvirtualVoidMethod(JNIEnv *env, jobject obj, jclass cls, jmethodID methodID, ...)) | 2219 JNI_ENTRY(void, jni_CallNonvirtualVoidMethod(JNIEnv *env, jobject obj, jclass cls, jmethodID methodID, ...)) |
1532 JNIWrapper("CallNonvirtualVoidMethod"); | 2220 JNIWrapper("CallNonvirtualVoidMethod"); |
1533 | 2221 |
2222 #ifndef USDT2 | |
1534 DTRACE_PROBE4(hotspot_jni, CallNonvirtualVoidMethod__entry, | 2223 DTRACE_PROBE4(hotspot_jni, CallNonvirtualVoidMethod__entry, |
1535 env, obj, cls, methodID); | 2224 env, obj, cls, methodID); |
2225 #else /* USDT2 */ | |
2226 HOTSPOT_JNI_CALLNONVIRTUALVOIDMETHOD_ENTRY( | |
2227 env, obj, cls, (uintptr_t) methodID); | |
2228 #endif /* USDT2 */ | |
1536 DT_VOID_RETURN_MARK(CallNonvirtualVoidMethod); | 2229 DT_VOID_RETURN_MARK(CallNonvirtualVoidMethod); |
1537 | 2230 |
1538 va_list args; | 2231 va_list args; |
1539 va_start(args, methodID); | 2232 va_start(args, methodID); |
1540 JavaValue jvalue(T_VOID); | 2233 JavaValue jvalue(T_VOID); |
1545 | 2238 |
1546 | 2239 |
1547 JNI_ENTRY(void, jni_CallNonvirtualVoidMethodV(JNIEnv *env, jobject obj, jclass cls, jmethodID methodID, va_list args)) | 2240 JNI_ENTRY(void, jni_CallNonvirtualVoidMethodV(JNIEnv *env, jobject obj, jclass cls, jmethodID methodID, va_list args)) |
1548 JNIWrapper("CallNonvirtualVoidMethodV"); | 2241 JNIWrapper("CallNonvirtualVoidMethodV"); |
1549 | 2242 |
2243 #ifndef USDT2 | |
1550 DTRACE_PROBE4(hotspot_jni, CallNonvirtualVoidMethodV__entry, | 2244 DTRACE_PROBE4(hotspot_jni, CallNonvirtualVoidMethodV__entry, |
1551 env, obj, cls, methodID); | 2245 env, obj, cls, methodID); |
2246 #else /* USDT2 */ | |
2247 HOTSPOT_JNI_CALLNONVIRTUALVOIDMETHODV_ENTRY( | |
2248 env, obj, cls, (uintptr_t) methodID); | |
2249 #endif /* USDT2 */ | |
1552 DT_VOID_RETURN_MARK(CallNonvirtualVoidMethodV); | 2250 DT_VOID_RETURN_MARK(CallNonvirtualVoidMethodV); |
1553 | 2251 |
1554 JavaValue jvalue(T_VOID); | 2252 JavaValue jvalue(T_VOID); |
1555 JNI_ArgumentPusherVaArg ap(methodID, args); | 2253 JNI_ArgumentPusherVaArg ap(methodID, args); |
1556 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK); | 2254 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK); |
1557 JNI_END | 2255 JNI_END |
1558 | 2256 |
1559 | 2257 |
1560 JNI_ENTRY(void, jni_CallNonvirtualVoidMethodA(JNIEnv *env, jobject obj, jclass cls, jmethodID methodID, const jvalue *args)) | 2258 JNI_ENTRY(void, jni_CallNonvirtualVoidMethodA(JNIEnv *env, jobject obj, jclass cls, jmethodID methodID, const jvalue *args)) |
1561 JNIWrapper("CallNonvirtualVoidMethodA"); | 2259 JNIWrapper("CallNonvirtualVoidMethodA"); |
2260 #ifndef USDT2 | |
1562 DTRACE_PROBE4(hotspot_jni, CallNonvirtualVoidMethodA__entry, | 2261 DTRACE_PROBE4(hotspot_jni, CallNonvirtualVoidMethodA__entry, |
1563 env, obj, cls, methodID); | 2262 env, obj, cls, methodID); |
2263 #else /* USDT2 */ | |
2264 HOTSPOT_JNI_CALLNONVIRTUALVOIDMETHODA_ENTRY( | |
2265 env, obj, cls, (uintptr_t) methodID); | |
2266 #endif /* USDT2 */ | |
1564 DT_VOID_RETURN_MARK(CallNonvirtualVoidMethodA); | 2267 DT_VOID_RETURN_MARK(CallNonvirtualVoidMethodA); |
1565 JavaValue jvalue(T_VOID); | 2268 JavaValue jvalue(T_VOID); |
1566 JNI_ArgumentPusherArray ap(methodID, args); | 2269 JNI_ArgumentPusherArray ap(methodID, args); |
1567 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK); | 2270 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK); |
1568 JNI_END | 2271 JNI_END |
1569 | 2272 |
1570 | 2273 |
2274 #ifndef USDT2 | |
1571 #define DEFINE_CALLSTATICMETHOD(ResultType, Result, Tag) \ | 2275 #define DEFINE_CALLSTATICMETHOD(ResultType, Result, Tag) \ |
1572 \ | 2276 \ |
1573 DT_RETURN_MARK_DECL_FOR(Result, CallStatic##Result##Method, ResultType);\ | 2277 DT_RETURN_MARK_DECL_FOR(Result, CallStatic##Result##Method, ResultType);\ |
1574 DT_RETURN_MARK_DECL_FOR(Result, CallStatic##Result##MethodV, ResultType);\ | 2278 DT_RETURN_MARK_DECL_FOR(Result, CallStatic##Result##MethodV, ResultType);\ |
1575 DT_RETURN_MARK_DECL_FOR(Result, CallStatic##Result##MethodA, ResultType);\ | 2279 DT_RETURN_MARK_DECL_FOR(Result, CallStatic##Result##MethodA, ResultType);\ |
1638 | 2342 |
1639 DT_VOID_RETURN_MARK_DECL(CallStaticVoidMethod); | 2343 DT_VOID_RETURN_MARK_DECL(CallStaticVoidMethod); |
1640 DT_VOID_RETURN_MARK_DECL(CallStaticVoidMethodV); | 2344 DT_VOID_RETURN_MARK_DECL(CallStaticVoidMethodV); |
1641 DT_VOID_RETURN_MARK_DECL(CallStaticVoidMethodA); | 2345 DT_VOID_RETURN_MARK_DECL(CallStaticVoidMethodA); |
1642 | 2346 |
2347 #else /* USDT2 */ | |
2348 | |
2349 #define DEFINE_CALLSTATICMETHOD(ResultType, Result, Tag \ | |
2350 , EntryProbe, ResultProbe) \ | |
2351 \ | |
2352 DT_RETURN_MARK_DECL_FOR(Result, CallStatic##Result##Method, ResultType \ | |
2353 , ResultProbe); \ | |
2354 \ | |
2355 JNI_ENTRY(ResultType, \ | |
2356 jni_CallStatic##Result##Method(JNIEnv *env, jclass cls, jmethodID methodID, ...)) \ | |
2357 JNIWrapper("CallStatic" XSTR(Result) "Method"); \ | |
2358 \ | |
2359 EntryProbe; \ | |
2360 ResultType ret = 0;\ | |
2361 DT_RETURN_MARK_FOR(Result, CallStatic##Result##Method, ResultType, \ | |
2362 (const ResultType&)ret);\ | |
2363 \ | |
2364 va_list args; \ | |
2365 va_start(args, methodID); \ | |
2366 JavaValue jvalue(Tag); \ | |
2367 JNI_ArgumentPusherVaArg ap(methodID, args); \ | |
2368 jni_invoke_static(env, &jvalue, NULL, JNI_STATIC, methodID, &ap, CHECK_0); \ | |
2369 va_end(args); \ | |
2370 ret = jvalue.get_##ResultType(); \ | |
2371 return ret;\ | |
2372 JNI_END | |
2373 | |
2374 // the runtime type of subword integral basic types is integer | |
2375 DEFINE_CALLSTATICMETHOD(jboolean, Boolean, T_BOOLEAN | |
2376 , HOTSPOT_JNI_CALLSTATICBOOLEANMETHOD_ENTRY(env, cls, (uintptr_t)methodID), | |
2377 HOTSPOT_JNI_CALLSTATICBOOLEANMETHOD_RETURN(_ret_ref)); | |
2378 DEFINE_CALLSTATICMETHOD(jbyte, Byte, T_BYTE | |
2379 , HOTSPOT_JNI_CALLSTATICBYTEMETHOD_ENTRY(env, cls, (uintptr_t)methodID), | |
2380 HOTSPOT_JNI_CALLSTATICBYTEMETHOD_RETURN(_ret_ref)); | |
2381 DEFINE_CALLSTATICMETHOD(jchar, Char, T_CHAR | |
2382 , HOTSPOT_JNI_CALLSTATICCHARMETHOD_ENTRY(env, cls, (uintptr_t)methodID), | |
2383 HOTSPOT_JNI_CALLSTATICCHARMETHOD_RETURN(_ret_ref)); | |
2384 DEFINE_CALLSTATICMETHOD(jshort, Short, T_SHORT | |
2385 , HOTSPOT_JNI_CALLSTATICSHORTMETHOD_ENTRY(env, cls, (uintptr_t)methodID), | |
2386 HOTSPOT_JNI_CALLSTATICSHORTMETHOD_RETURN(_ret_ref)); | |
2387 | |
2388 DEFINE_CALLSTATICMETHOD(jobject, Object, T_OBJECT | |
2389 , HOTSPOT_JNI_CALLSTATICOBJECTMETHOD_ENTRY(env, cls, (uintptr_t)methodID), | |
2390 HOTSPOT_JNI_CALLSTATICOBJECTMETHOD_RETURN(_ret_ref)); | |
2391 DEFINE_CALLSTATICMETHOD(jint, Int, T_INT | |
2392 , HOTSPOT_JNI_CALLSTATICINTMETHOD_ENTRY(env, cls, (uintptr_t)methodID), | |
2393 HOTSPOT_JNI_CALLSTATICINTMETHOD_RETURN(_ret_ref)); | |
2394 DEFINE_CALLSTATICMETHOD(jlong, Long, T_LONG | |
2395 , HOTSPOT_JNI_CALLSTATICLONGMETHOD_ENTRY(env, cls, (uintptr_t)methodID), | |
2396 HOTSPOT_JNI_CALLSTATICLONGMETHOD_RETURN(_ret_ref)); | |
2397 // Float and double probes don't return value because dtrace doesn't currently support it | |
2398 DEFINE_CALLSTATICMETHOD(jfloat, Float, T_FLOAT | |
2399 , HOTSPOT_JNI_CALLSTATICFLOATMETHOD_ENTRY(env, cls, (uintptr_t)methodID), | |
2400 HOTSPOT_JNI_CALLSTATICFLOATMETHOD_RETURN()); | |
2401 DEFINE_CALLSTATICMETHOD(jdouble, Double, T_DOUBLE | |
2402 , HOTSPOT_JNI_CALLSTATICDOUBLEMETHOD_ENTRY(env, cls, (uintptr_t)methodID), | |
2403 HOTSPOT_JNI_CALLSTATICDOUBLEMETHOD_RETURN()); | |
2404 | |
2405 #define DEFINE_CALLSTATICMETHODV(ResultType, Result, Tag \ | |
2406 , EntryProbe, ResultProbe) \ | |
2407 \ | |
2408 DT_RETURN_MARK_DECL_FOR(Result, CallStatic##Result##MethodV, ResultType \ | |
2409 , ResultProbe); \ | |
2410 \ | |
2411 JNI_ENTRY(ResultType, \ | |
2412 jni_CallStatic##Result##MethodV(JNIEnv *env, jclass cls, jmethodID methodID, va_list args)) \ | |
2413 JNIWrapper("CallStatic" XSTR(Result) "MethodV"); \ | |
2414 \ | |
2415 EntryProbe; \ | |
2416 ResultType ret = 0;\ | |
2417 DT_RETURN_MARK_FOR(Result, CallStatic##Result##MethodV, ResultType, \ | |
2418 (const ResultType&)ret);\ | |
2419 \ | |
2420 JavaValue jvalue(Tag); \ | |
2421 JNI_ArgumentPusherVaArg ap(methodID, args); \ | |
2422 /* Make sure class is initialized before trying to invoke its method */ \ | |
2423 KlassHandle k(THREAD, java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls))); \ | |
2424 Klass::cast(k())->initialize(CHECK_0); \ | |
2425 jni_invoke_static(env, &jvalue, NULL, JNI_STATIC, methodID, &ap, CHECK_0); \ | |
2426 va_end(args); \ | |
2427 ret = jvalue.get_##ResultType(); \ | |
2428 return ret;\ | |
2429 JNI_END | |
2430 | |
2431 // the runtime type of subword integral basic types is integer | |
2432 DEFINE_CALLSTATICMETHODV(jboolean, Boolean, T_BOOLEAN | |
2433 , HOTSPOT_JNI_CALLSTATICBOOLEANMETHODV_ENTRY(env, cls, (uintptr_t)methodID), | |
2434 HOTSPOT_JNI_CALLSTATICBOOLEANMETHODV_RETURN(_ret_ref)); | |
2435 DEFINE_CALLSTATICMETHODV(jbyte, Byte, T_BYTE | |
2436 , HOTSPOT_JNI_CALLSTATICBYTEMETHODV_ENTRY(env, cls, (uintptr_t)methodID), | |
2437 HOTSPOT_JNI_CALLSTATICBYTEMETHODV_RETURN(_ret_ref)); | |
2438 DEFINE_CALLSTATICMETHODV(jchar, Char, T_CHAR | |
2439 , HOTSPOT_JNI_CALLSTATICCHARMETHODV_ENTRY(env, cls, (uintptr_t)methodID), | |
2440 HOTSPOT_JNI_CALLSTATICCHARMETHODV_RETURN(_ret_ref)); | |
2441 DEFINE_CALLSTATICMETHODV(jshort, Short, T_SHORT | |
2442 , HOTSPOT_JNI_CALLSTATICSHORTMETHODV_ENTRY(env, cls, (uintptr_t)methodID), | |
2443 HOTSPOT_JNI_CALLSTATICSHORTMETHODV_RETURN(_ret_ref)); | |
2444 | |
2445 DEFINE_CALLSTATICMETHODV(jobject, Object, T_OBJECT | |
2446 , HOTSPOT_JNI_CALLSTATICOBJECTMETHODV_ENTRY(env, cls, (uintptr_t)methodID), | |
2447 HOTSPOT_JNI_CALLSTATICOBJECTMETHODV_RETURN(_ret_ref)); | |
2448 DEFINE_CALLSTATICMETHODV(jint, Int, T_INT | |
2449 , HOTSPOT_JNI_CALLSTATICINTMETHODV_ENTRY(env, cls, (uintptr_t)methodID), | |
2450 HOTSPOT_JNI_CALLSTATICINTMETHODV_RETURN(_ret_ref)); | |
2451 DEFINE_CALLSTATICMETHODV(jlong, Long, T_LONG | |
2452 , HOTSPOT_JNI_CALLSTATICLONGMETHODV_ENTRY(env, cls, (uintptr_t)methodID), | |
2453 HOTSPOT_JNI_CALLSTATICLONGMETHODV_RETURN(_ret_ref)); | |
2454 // Float and double probes don't return value because dtrace doesn't currently support it | |
2455 DEFINE_CALLSTATICMETHODV(jfloat, Float, T_FLOAT | |
2456 , HOTSPOT_JNI_CALLSTATICFLOATMETHODV_ENTRY(env, cls, (uintptr_t)methodID), | |
2457 HOTSPOT_JNI_CALLSTATICFLOATMETHODV_RETURN()); | |
2458 DEFINE_CALLSTATICMETHODV(jdouble, Double, T_DOUBLE | |
2459 , HOTSPOT_JNI_CALLSTATICDOUBLEMETHODV_ENTRY(env, cls, (uintptr_t)methodID), | |
2460 HOTSPOT_JNI_CALLSTATICDOUBLEMETHODV_RETURN()); | |
2461 | |
2462 #define DEFINE_CALLSTATICMETHODA(ResultType, Result, Tag \ | |
2463 , EntryProbe, ResultProbe) \ | |
2464 \ | |
2465 DT_RETURN_MARK_DECL_FOR(Result, CallStatic##Result##MethodA, ResultType \ | |
2466 , ResultProbe); \ | |
2467 \ | |
2468 JNI_ENTRY(ResultType, \ | |
2469 jni_CallStatic##Result##MethodA(JNIEnv *env, jclass cls, jmethodID methodID, const jvalue *args)) \ | |
2470 JNIWrapper("CallStatic" XSTR(Result) "MethodA"); \ | |
2471 \ | |
2472 EntryProbe; \ | |
2473 ResultType ret = 0;\ | |
2474 DT_RETURN_MARK_FOR(Result, CallStatic##Result##MethodA, ResultType, \ | |
2475 (const ResultType&)ret);\ | |
2476 \ | |
2477 JavaValue jvalue(Tag); \ | |
2478 JNI_ArgumentPusherArray ap(methodID, args); \ | |
2479 jni_invoke_static(env, &jvalue, NULL, JNI_STATIC, methodID, &ap, CHECK_0); \ | |
2480 ret = jvalue.get_##ResultType(); \ | |
2481 return ret;\ | |
2482 JNI_END | |
2483 | |
2484 // the runtime type of subword integral basic types is integer | |
2485 DEFINE_CALLSTATICMETHODA(jboolean, Boolean, T_BOOLEAN | |
2486 , HOTSPOT_JNI_CALLSTATICBOOLEANMETHODA_ENTRY(env, cls, (uintptr_t)methodID), | |
2487 HOTSPOT_JNI_CALLSTATICBOOLEANMETHODA_RETURN(_ret_ref)); | |
2488 DEFINE_CALLSTATICMETHODA(jbyte, Byte, T_BYTE | |
2489 , HOTSPOT_JNI_CALLSTATICBYTEMETHODA_ENTRY(env, cls, (uintptr_t)methodID), | |
2490 HOTSPOT_JNI_CALLSTATICBYTEMETHODA_RETURN(_ret_ref)); | |
2491 DEFINE_CALLSTATICMETHODA(jchar, Char, T_CHAR | |
2492 , HOTSPOT_JNI_CALLSTATICCHARMETHODA_ENTRY(env, cls, (uintptr_t)methodID), | |
2493 HOTSPOT_JNI_CALLSTATICCHARMETHODA_RETURN(_ret_ref)); | |
2494 DEFINE_CALLSTATICMETHODA(jshort, Short, T_SHORT | |
2495 , HOTSPOT_JNI_CALLSTATICSHORTMETHODA_ENTRY(env, cls, (uintptr_t)methodID), | |
2496 HOTSPOT_JNI_CALLSTATICSHORTMETHODA_RETURN(_ret_ref)); | |
2497 | |
2498 DEFINE_CALLSTATICMETHODA(jobject, Object, T_OBJECT | |
2499 , HOTSPOT_JNI_CALLSTATICOBJECTMETHODA_ENTRY(env, cls, (uintptr_t)methodID), | |
2500 HOTSPOT_JNI_CALLSTATICOBJECTMETHODA_RETURN(_ret_ref)); | |
2501 DEFINE_CALLSTATICMETHODA(jint, Int, T_INT | |
2502 , HOTSPOT_JNI_CALLSTATICINTMETHODA_ENTRY(env, cls, (uintptr_t)methodID), | |
2503 HOTSPOT_JNI_CALLSTATICINTMETHODA_RETURN(_ret_ref)); | |
2504 DEFINE_CALLSTATICMETHODA(jlong, Long, T_LONG | |
2505 , HOTSPOT_JNI_CALLSTATICLONGMETHODA_ENTRY(env, cls, (uintptr_t)methodID), | |
2506 HOTSPOT_JNI_CALLSTATICLONGMETHODA_RETURN(_ret_ref)); | |
2507 // Float and double probes don't return value because dtrace doesn't currently support it | |
2508 DEFINE_CALLSTATICMETHODA(jfloat, Float, T_FLOAT | |
2509 , HOTSPOT_JNI_CALLSTATICFLOATMETHODA_ENTRY(env, cls, (uintptr_t)methodID), | |
2510 HOTSPOT_JNI_CALLSTATICFLOATMETHODA_RETURN()); | |
2511 DEFINE_CALLSTATICMETHODA(jdouble, Double, T_DOUBLE | |
2512 , HOTSPOT_JNI_CALLSTATICDOUBLEMETHODA_ENTRY(env, cls, (uintptr_t)methodID), | |
2513 HOTSPOT_JNI_CALLSTATICDOUBLEMETHODA_RETURN()); | |
2514 | |
2515 DT_VOID_RETURN_MARK_DECL(CallStaticVoidMethod | |
2516 , HOTSPOT_JNI_CALLSTATICVOIDMETHOD_RETURN()); | |
2517 DT_VOID_RETURN_MARK_DECL(CallStaticVoidMethodV | |
2518 , HOTSPOT_JNI_CALLSTATICVOIDMETHODV_RETURN()); | |
2519 DT_VOID_RETURN_MARK_DECL(CallStaticVoidMethodA | |
2520 , HOTSPOT_JNI_CALLSTATICVOIDMETHODA_RETURN()); | |
2521 #endif /* USDT2 */ | |
2522 | |
1643 JNI_ENTRY(void, jni_CallStaticVoidMethod(JNIEnv *env, jclass cls, jmethodID methodID, ...)) | 2523 JNI_ENTRY(void, jni_CallStaticVoidMethod(JNIEnv *env, jclass cls, jmethodID methodID, ...)) |
1644 JNIWrapper("CallStaticVoidMethod"); | 2524 JNIWrapper("CallStaticVoidMethod"); |
2525 #ifndef USDT2 | |
1645 DTRACE_PROBE3(hotspot_jni, CallStaticVoidMethod__entry, env, cls, methodID); | 2526 DTRACE_PROBE3(hotspot_jni, CallStaticVoidMethod__entry, env, cls, methodID); |
2527 #else /* USDT2 */ | |
2528 HOTSPOT_JNI_CALLSTATICVOIDMETHOD_ENTRY( | |
2529 env, cls, (uintptr_t) methodID); | |
2530 #endif /* USDT2 */ | |
1646 DT_VOID_RETURN_MARK(CallStaticVoidMethod); | 2531 DT_VOID_RETURN_MARK(CallStaticVoidMethod); |
1647 | 2532 |
1648 va_list args; | 2533 va_list args; |
1649 va_start(args, methodID); | 2534 va_start(args, methodID); |
1650 JavaValue jvalue(T_VOID); | 2535 JavaValue jvalue(T_VOID); |
1654 JNI_END | 2539 JNI_END |
1655 | 2540 |
1656 | 2541 |
1657 JNI_ENTRY(void, jni_CallStaticVoidMethodV(JNIEnv *env, jclass cls, jmethodID methodID, va_list args)) | 2542 JNI_ENTRY(void, jni_CallStaticVoidMethodV(JNIEnv *env, jclass cls, jmethodID methodID, va_list args)) |
1658 JNIWrapper("CallStaticVoidMethodV"); | 2543 JNIWrapper("CallStaticVoidMethodV"); |
2544 #ifndef USDT2 | |
1659 DTRACE_PROBE3(hotspot_jni, CallStaticVoidMethodV__entry, env, cls, methodID); | 2545 DTRACE_PROBE3(hotspot_jni, CallStaticVoidMethodV__entry, env, cls, methodID); |
2546 #else /* USDT2 */ | |
2547 HOTSPOT_JNI_CALLSTATICVOIDMETHODV_ENTRY( | |
2548 env, cls, (uintptr_t) methodID); | |
2549 #endif /* USDT2 */ | |
1660 DT_VOID_RETURN_MARK(CallStaticVoidMethodV); | 2550 DT_VOID_RETURN_MARK(CallStaticVoidMethodV); |
1661 | 2551 |
1662 JavaValue jvalue(T_VOID); | 2552 JavaValue jvalue(T_VOID); |
1663 JNI_ArgumentPusherVaArg ap(methodID, args); | 2553 JNI_ArgumentPusherVaArg ap(methodID, args); |
1664 jni_invoke_static(env, &jvalue, NULL, JNI_STATIC, methodID, &ap, CHECK); | 2554 jni_invoke_static(env, &jvalue, NULL, JNI_STATIC, methodID, &ap, CHECK); |
1665 JNI_END | 2555 JNI_END |
1666 | 2556 |
1667 | 2557 |
1668 JNI_ENTRY(void, jni_CallStaticVoidMethodA(JNIEnv *env, jclass cls, jmethodID methodID, const jvalue *args)) | 2558 JNI_ENTRY(void, jni_CallStaticVoidMethodA(JNIEnv *env, jclass cls, jmethodID methodID, const jvalue *args)) |
1669 JNIWrapper("CallStaticVoidMethodA"); | 2559 JNIWrapper("CallStaticVoidMethodA"); |
2560 #ifndef USDT2 | |
1670 DTRACE_PROBE3(hotspot_jni, CallStaticVoidMethodA__entry, env, cls, methodID); | 2561 DTRACE_PROBE3(hotspot_jni, CallStaticVoidMethodA__entry, env, cls, methodID); |
2562 #else /* USDT2 */ | |
2563 HOTSPOT_JNI_CALLSTATICVOIDMETHODA_ENTRY( | |
2564 env, cls, (uintptr_t) methodID); | |
2565 #endif /* USDT2 */ | |
1671 DT_VOID_RETURN_MARK(CallStaticVoidMethodA); | 2566 DT_VOID_RETURN_MARK(CallStaticVoidMethodA); |
1672 | 2567 |
1673 JavaValue jvalue(T_VOID); | 2568 JavaValue jvalue(T_VOID); |
1674 JNI_ArgumentPusherArray ap(methodID, args); | 2569 JNI_ArgumentPusherArray ap(methodID, args); |
1675 jni_invoke_static(env, &jvalue, NULL, JNI_STATIC, methodID, &ap, CHECK); | 2570 jni_invoke_static(env, &jvalue, NULL, JNI_STATIC, methodID, &ap, CHECK); |
1679 // | 2574 // |
1680 // Accessing Fields | 2575 // Accessing Fields |
1681 // | 2576 // |
1682 | 2577 |
1683 | 2578 |
2579 #ifndef USDT2 | |
1684 DT_RETURN_MARK_DECL(GetFieldID, jfieldID); | 2580 DT_RETURN_MARK_DECL(GetFieldID, jfieldID); |
2581 #else /* USDT2 */ | |
2582 DT_RETURN_MARK_DECL(GetFieldID, jfieldID | |
2583 , HOTSPOT_JNI_GETFIELDID_RETURN((uintptr_t)_ret_ref)); | |
2584 #endif /* USDT2 */ | |
1685 | 2585 |
1686 JNI_ENTRY(jfieldID, jni_GetFieldID(JNIEnv *env, jclass clazz, | 2586 JNI_ENTRY(jfieldID, jni_GetFieldID(JNIEnv *env, jclass clazz, |
1687 const char *name, const char *sig)) | 2587 const char *name, const char *sig)) |
1688 JNIWrapper("GetFieldID"); | 2588 JNIWrapper("GetFieldID"); |
2589 #ifndef USDT2 | |
1689 DTRACE_PROBE4(hotspot_jni, GetFieldID__entry, env, clazz, name, sig); | 2590 DTRACE_PROBE4(hotspot_jni, GetFieldID__entry, env, clazz, name, sig); |
2591 #else /* USDT2 */ | |
2592 HOTSPOT_JNI_GETFIELDID_ENTRY( | |
2593 env, clazz, (char *) name, (char *) sig); | |
2594 #endif /* USDT2 */ | |
1690 jfieldID ret = 0; | 2595 jfieldID ret = 0; |
1691 DT_RETURN_MARK(GetFieldID, jfieldID, (const jfieldID&)ret); | 2596 DT_RETURN_MARK(GetFieldID, jfieldID, (const jfieldID&)ret); |
1692 | 2597 |
1693 // The class should have been loaded (we have an instance of the class | 2598 // The class should have been loaded (we have an instance of the class |
1694 // passed in) so the field and signature should already be in the symbol | 2599 // passed in) so the field and signature should already be in the symbol |
1716 JNI_END | 2621 JNI_END |
1717 | 2622 |
1718 | 2623 |
1719 JNI_ENTRY(jobject, jni_GetObjectField(JNIEnv *env, jobject obj, jfieldID fieldID)) | 2624 JNI_ENTRY(jobject, jni_GetObjectField(JNIEnv *env, jobject obj, jfieldID fieldID)) |
1720 JNIWrapper("GetObjectField"); | 2625 JNIWrapper("GetObjectField"); |
2626 #ifndef USDT2 | |
1721 DTRACE_PROBE3(hotspot_jni, GetObjectField__entry, env, obj, fieldID); | 2627 DTRACE_PROBE3(hotspot_jni, GetObjectField__entry, env, obj, fieldID); |
2628 #else /* USDT2 */ | |
2629 HOTSPOT_JNI_GETOBJECTFIELD_ENTRY( | |
2630 env, obj, (uintptr_t) fieldID); | |
2631 #endif /* USDT2 */ | |
1722 oop o = JNIHandles::resolve_non_null(obj); | 2632 oop o = JNIHandles::resolve_non_null(obj); |
1723 klassOop k = o->klass(); | 2633 klassOop k = o->klass(); |
1724 int offset = jfieldIDWorkaround::from_instance_jfieldID(k, fieldID); | 2634 int offset = jfieldIDWorkaround::from_instance_jfieldID(k, fieldID); |
1725 // Keep JVMTI addition small and only check enabled flag here. | 2635 // Keep JVMTI addition small and only check enabled flag here. |
1726 // jni_GetField_probe() assumes that is okay to create handles. | 2636 // jni_GetField_probe() assumes that is okay to create handles. |
1746 oop referent = JNIHandles::resolve(ret); | 2656 oop referent = JNIHandles::resolve(ret); |
1747 G1SATBCardTableModRefBS::enqueue(referent); | 2657 G1SATBCardTableModRefBS::enqueue(referent); |
1748 } | 2658 } |
1749 } | 2659 } |
1750 #endif // SERIALGC | 2660 #endif // SERIALGC |
2661 #ifndef USDT2 | |
1751 DTRACE_PROBE1(hotspot_jni, GetObjectField__return, ret); | 2662 DTRACE_PROBE1(hotspot_jni, GetObjectField__return, ret); |
2663 #else /* USDT2 */ | |
2664 HOTSPOT_JNI_GETOBJECTFIELD_RETURN( | |
2665 ret); | |
2666 #endif /* USDT2 */ | |
1752 return ret; | 2667 return ret; |
1753 JNI_END | 2668 JNI_END |
1754 | 2669 |
1755 | 2670 |
2671 #ifndef USDT2 | |
1756 #define DEFINE_GETFIELD(Return,Fieldname,Result) \ | 2672 #define DEFINE_GETFIELD(Return,Fieldname,Result) \ |
1757 \ | 2673 \ |
1758 DT_RETURN_MARK_DECL_FOR(Result, Get##Result##Field, Return);\ | 2674 DT_RETURN_MARK_DECL_FOR(Result, Get##Result##Field, Return);\ |
1759 \ | 2675 \ |
1760 JNI_QUICK_ENTRY(Return, jni_Get##Result##Field(JNIEnv *env, jobject obj, jfieldID fieldID)) \ | 2676 JNI_QUICK_ENTRY(Return, jni_Get##Result##Field(JNIEnv *env, jobject obj, jfieldID fieldID)) \ |
1783 DEFINE_GETFIELD(jshort, short, Short) | 2699 DEFINE_GETFIELD(jshort, short, Short) |
1784 DEFINE_GETFIELD(jint, int, Int) | 2700 DEFINE_GETFIELD(jint, int, Int) |
1785 DEFINE_GETFIELD(jlong, long, Long) | 2701 DEFINE_GETFIELD(jlong, long, Long) |
1786 DEFINE_GETFIELD(jfloat, float, Float) | 2702 DEFINE_GETFIELD(jfloat, float, Float) |
1787 DEFINE_GETFIELD(jdouble, double, Double) | 2703 DEFINE_GETFIELD(jdouble, double, Double) |
2704 | |
2705 #else /* USDT2 */ | |
2706 | |
2707 #define DEFINE_GETFIELD(Return,Fieldname,Result \ | |
2708 , EntryProbe, ReturnProbe) \ | |
2709 \ | |
2710 DT_RETURN_MARK_DECL_FOR(Result, Get##Result##Field, Return \ | |
2711 , ReturnProbe); \ | |
2712 \ | |
2713 JNI_QUICK_ENTRY(Return, jni_Get##Result##Field(JNIEnv *env, jobject obj, jfieldID fieldID)) \ | |
2714 JNIWrapper("Get" XSTR(Result) "Field"); \ | |
2715 \ | |
2716 EntryProbe; \ | |
2717 Return ret = 0;\ | |
2718 DT_RETURN_MARK_FOR(Result, Get##Result##Field, Return, (const Return&)ret);\ | |
2719 \ | |
2720 oop o = JNIHandles::resolve_non_null(obj); \ | |
2721 klassOop k = o->klass(); \ | |
2722 int offset = jfieldIDWorkaround::from_instance_jfieldID(k, fieldID); \ | |
2723 /* Keep JVMTI addition small and only check enabled flag here. */ \ | |
2724 /* jni_GetField_probe_nh() assumes that is not okay to create handles */ \ | |
2725 /* and creates a ResetNoHandleMark. */ \ | |
2726 if (JvmtiExport::should_post_field_access()) { \ | |
2727 o = JvmtiExport::jni_GetField_probe_nh(thread, obj, o, k, fieldID, false); \ | |
2728 } \ | |
2729 ret = o->Fieldname##_field(offset); \ | |
2730 return ret; \ | |
2731 JNI_END | |
2732 | |
2733 DEFINE_GETFIELD(jboolean, bool, Boolean | |
2734 , HOTSPOT_JNI_GETBOOLEANFIELD_ENTRY(env, obj, (uintptr_t)fieldID), | |
2735 HOTSPOT_JNI_GETBOOLEANFIELD_RETURN(_ret_ref)) | |
2736 DEFINE_GETFIELD(jbyte, byte, Byte | |
2737 , HOTSPOT_JNI_GETBYTEFIELD_ENTRY(env, obj, (uintptr_t)fieldID), | |
2738 HOTSPOT_JNI_GETBYTEFIELD_RETURN(_ret_ref)) | |
2739 DEFINE_GETFIELD(jchar, char, Char | |
2740 , HOTSPOT_JNI_GETCHARFIELD_ENTRY(env, obj, (uintptr_t)fieldID), | |
2741 HOTSPOT_JNI_GETCHARFIELD_RETURN(_ret_ref)) | |
2742 DEFINE_GETFIELD(jshort, short, Short | |
2743 , HOTSPOT_JNI_GETSHORTFIELD_ENTRY(env, obj, (uintptr_t)fieldID), | |
2744 HOTSPOT_JNI_GETSHORTFIELD_RETURN(_ret_ref)) | |
2745 DEFINE_GETFIELD(jint, int, Int | |
2746 , HOTSPOT_JNI_GETINTFIELD_ENTRY(env, obj, (uintptr_t)fieldID), | |
2747 HOTSPOT_JNI_GETINTFIELD_RETURN(_ret_ref)) | |
2748 DEFINE_GETFIELD(jlong, long, Long | |
2749 , HOTSPOT_JNI_GETLONGFIELD_ENTRY(env, obj, (uintptr_t)fieldID), | |
2750 HOTSPOT_JNI_GETLONGFIELD_RETURN(_ret_ref)) | |
2751 // Float and double probes don't return value because dtrace doesn't currently support it | |
2752 DEFINE_GETFIELD(jfloat, float, Float | |
2753 , HOTSPOT_JNI_GETFLOATFIELD_ENTRY(env, obj, (uintptr_t)fieldID), | |
2754 HOTSPOT_JNI_GETFLOATFIELD_RETURN()) | |
2755 DEFINE_GETFIELD(jdouble, double, Double | |
2756 , HOTSPOT_JNI_GETDOUBLEFIELD_ENTRY(env, obj, (uintptr_t)fieldID), | |
2757 HOTSPOT_JNI_GETDOUBLEFIELD_RETURN()) | |
2758 #endif /* USDT2 */ | |
1788 | 2759 |
1789 address jni_GetBooleanField_addr() { | 2760 address jni_GetBooleanField_addr() { |
1790 return (address)jni_GetBooleanField; | 2761 return (address)jni_GetBooleanField; |
1791 } | 2762 } |
1792 address jni_GetByteField_addr() { | 2763 address jni_GetByteField_addr() { |
1811 return (address)jni_GetDoubleField; | 2782 return (address)jni_GetDoubleField; |
1812 } | 2783 } |
1813 | 2784 |
1814 JNI_QUICK_ENTRY(void, jni_SetObjectField(JNIEnv *env, jobject obj, jfieldID fieldID, jobject value)) | 2785 JNI_QUICK_ENTRY(void, jni_SetObjectField(JNIEnv *env, jobject obj, jfieldID fieldID, jobject value)) |
1815 JNIWrapper("SetObjectField"); | 2786 JNIWrapper("SetObjectField"); |
2787 #ifndef USDT2 | |
1816 DTRACE_PROBE4(hotspot_jni, SetObjectField__entry, env, obj, fieldID, value); | 2788 DTRACE_PROBE4(hotspot_jni, SetObjectField__entry, env, obj, fieldID, value); |
2789 #else /* USDT2 */ | |
2790 HOTSPOT_JNI_SETOBJECTFIELD_ENTRY( | |
2791 env, obj, (uintptr_t) fieldID, value); | |
2792 #endif /* USDT2 */ | |
1817 oop o = JNIHandles::resolve_non_null(obj); | 2793 oop o = JNIHandles::resolve_non_null(obj); |
1818 klassOop k = o->klass(); | 2794 klassOop k = o->klass(); |
1819 int offset = jfieldIDWorkaround::from_instance_jfieldID(k, fieldID); | 2795 int offset = jfieldIDWorkaround::from_instance_jfieldID(k, fieldID); |
1820 // Keep JVMTI addition small and only check enabled flag here. | 2796 // Keep JVMTI addition small and only check enabled flag here. |
1821 // jni_SetField_probe_nh() assumes that is not okay to create handles | 2797 // jni_SetField_probe_nh() assumes that is not okay to create handles |
1824 jvalue field_value; | 2800 jvalue field_value; |
1825 field_value.l = value; | 2801 field_value.l = value; |
1826 o = JvmtiExport::jni_SetField_probe_nh(thread, obj, o, k, fieldID, false, 'L', (jvalue *)&field_value); | 2802 o = JvmtiExport::jni_SetField_probe_nh(thread, obj, o, k, fieldID, false, 'L', (jvalue *)&field_value); |
1827 } | 2803 } |
1828 o->obj_field_put(offset, JNIHandles::resolve(value)); | 2804 o->obj_field_put(offset, JNIHandles::resolve(value)); |
2805 #ifndef USDT2 | |
1829 DTRACE_PROBE(hotspot_jni, SetObjectField__return); | 2806 DTRACE_PROBE(hotspot_jni, SetObjectField__return); |
1830 JNI_END | 2807 #else /* USDT2 */ |
1831 | 2808 HOTSPOT_JNI_SETOBJECTFIELD_RETURN( |
2809 ); | |
2810 #endif /* USDT2 */ | |
2811 JNI_END | |
2812 | |
2813 #ifndef USDT2 | |
1832 #define DEFINE_SETFIELD(Argument,Fieldname,Result,SigType,unionType) \ | 2814 #define DEFINE_SETFIELD(Argument,Fieldname,Result,SigType,unionType) \ |
1833 \ | 2815 \ |
1834 JNI_QUICK_ENTRY(void, jni_Set##Result##Field(JNIEnv *env, jobject obj, jfieldID fieldID, Argument value)) \ | 2816 JNI_QUICK_ENTRY(void, jni_Set##Result##Field(JNIEnv *env, jobject obj, jfieldID fieldID, Argument value)) \ |
1835 JNIWrapper("Set" XSTR(Result) "Field"); \ | 2817 JNIWrapper("Set" XSTR(Result) "Field"); \ |
1836 \ | 2818 \ |
1861 DEFINE_SETFIELD(jint, int, Int, 'I', i) | 2843 DEFINE_SETFIELD(jint, int, Int, 'I', i) |
1862 DEFINE_SETFIELD(jlong, long, Long, 'J', j) | 2844 DEFINE_SETFIELD(jlong, long, Long, 'J', j) |
1863 DEFINE_SETFIELD(jfloat, float, Float, 'F', f) | 2845 DEFINE_SETFIELD(jfloat, float, Float, 'F', f) |
1864 DEFINE_SETFIELD(jdouble, double, Double, 'D', d) | 2846 DEFINE_SETFIELD(jdouble, double, Double, 'D', d) |
1865 | 2847 |
2848 #else /* USDT2 */ | |
2849 | |
2850 #define DEFINE_SETFIELD(Argument,Fieldname,Result,SigType,unionType \ | |
2851 , EntryProbe, ReturnProbe) \ | |
2852 \ | |
2853 JNI_QUICK_ENTRY(void, jni_Set##Result##Field(JNIEnv *env, jobject obj, jfieldID fieldID, Argument value)) \ | |
2854 JNIWrapper("Set" XSTR(Result) "Field"); \ | |
2855 \ | |
2856 EntryProbe; \ | |
2857 \ | |
2858 oop o = JNIHandles::resolve_non_null(obj); \ | |
2859 klassOop k = o->klass(); \ | |
2860 int offset = jfieldIDWorkaround::from_instance_jfieldID(k, fieldID); \ | |
2861 /* Keep JVMTI addition small and only check enabled flag here. */ \ | |
2862 /* jni_SetField_probe_nh() assumes that is not okay to create handles */ \ | |
2863 /* and creates a ResetNoHandleMark. */ \ | |
2864 if (JvmtiExport::should_post_field_modification()) { \ | |
2865 jvalue field_value; \ | |
2866 field_value.unionType = value; \ | |
2867 o = JvmtiExport::jni_SetField_probe_nh(thread, obj, o, k, fieldID, false, SigType, (jvalue *)&field_value); \ | |
2868 } \ | |
2869 o->Fieldname##_field_put(offset, value); \ | |
2870 ReturnProbe; \ | |
2871 JNI_END | |
2872 | |
2873 DEFINE_SETFIELD(jboolean, bool, Boolean, 'Z', z | |
2874 , HOTSPOT_JNI_SETBOOLEANFIELD_ENTRY(env, obj, (uintptr_t)fieldID, value), | |
2875 HOTSPOT_JNI_SETBOOLEANFIELD_RETURN()) | |
2876 DEFINE_SETFIELD(jbyte, byte, Byte, 'B', b | |
2877 , HOTSPOT_JNI_SETBYTEFIELD_ENTRY(env, obj, (uintptr_t)fieldID, value), | |
2878 HOTSPOT_JNI_SETBYTEFIELD_RETURN()) | |
2879 DEFINE_SETFIELD(jchar, char, Char, 'C', c | |
2880 , HOTSPOT_JNI_SETCHARFIELD_ENTRY(env, obj, (uintptr_t)fieldID, value), | |
2881 HOTSPOT_JNI_SETCHARFIELD_RETURN()) | |
2882 DEFINE_SETFIELD(jshort, short, Short, 'S', s | |
2883 , HOTSPOT_JNI_SETSHORTFIELD_ENTRY(env, obj, (uintptr_t)fieldID, value), | |
2884 HOTSPOT_JNI_SETSHORTFIELD_RETURN()) | |
2885 DEFINE_SETFIELD(jint, int, Int, 'I', i | |
2886 , HOTSPOT_JNI_SETINTFIELD_ENTRY(env, obj, (uintptr_t)fieldID, value), | |
2887 HOTSPOT_JNI_SETINTFIELD_RETURN()) | |
2888 DEFINE_SETFIELD(jlong, long, Long, 'J', j | |
2889 , HOTSPOT_JNI_SETLONGFIELD_ENTRY(env, obj, (uintptr_t)fieldID, value), | |
2890 HOTSPOT_JNI_SETLONGFIELD_RETURN()) | |
2891 // Float and double probes don't return value because dtrace doesn't currently support it | |
2892 DEFINE_SETFIELD(jfloat, float, Float, 'F', f | |
2893 , HOTSPOT_JNI_SETFLOATFIELD_ENTRY(env, obj, (uintptr_t)fieldID), | |
2894 HOTSPOT_JNI_SETFLOATFIELD_RETURN()) | |
2895 DEFINE_SETFIELD(jdouble, double, Double, 'D', d | |
2896 , HOTSPOT_JNI_SETDOUBLEFIELD_ENTRY(env, obj, (uintptr_t)fieldID), | |
2897 HOTSPOT_JNI_SETDOUBLEFIELD_RETURN()) | |
2898 #endif /* USDT2 */ | |
2899 | |
2900 #ifndef USDT2 | |
1866 DT_RETURN_MARK_DECL(ToReflectedField, jobject); | 2901 DT_RETURN_MARK_DECL(ToReflectedField, jobject); |
2902 #else /* USDT2 */ | |
2903 DT_RETURN_MARK_DECL(ToReflectedField, jobject | |
2904 , HOTSPOT_JNI_TOREFLECTEDFIELD_RETURN(_ret_ref)); | |
2905 #endif /* USDT2 */ | |
1867 | 2906 |
1868 JNI_ENTRY(jobject, jni_ToReflectedField(JNIEnv *env, jclass cls, jfieldID fieldID, jboolean isStatic)) | 2907 JNI_ENTRY(jobject, jni_ToReflectedField(JNIEnv *env, jclass cls, jfieldID fieldID, jboolean isStatic)) |
1869 JNIWrapper("ToReflectedField"); | 2908 JNIWrapper("ToReflectedField"); |
2909 #ifndef USDT2 | |
1870 DTRACE_PROBE4(hotspot_jni, ToReflectedField__entry, | 2910 DTRACE_PROBE4(hotspot_jni, ToReflectedField__entry, |
1871 env, cls, fieldID, isStatic); | 2911 env, cls, fieldID, isStatic); |
2912 #else /* USDT2 */ | |
2913 HOTSPOT_JNI_TOREFLECTEDFIELD_ENTRY( | |
2914 env, cls, (uintptr_t) fieldID, isStatic); | |
2915 #endif /* USDT2 */ | |
1872 jobject ret = NULL; | 2916 jobject ret = NULL; |
1873 DT_RETURN_MARK(ToReflectedField, jobject, (const jobject&)ret); | 2917 DT_RETURN_MARK(ToReflectedField, jobject, (const jobject&)ret); |
1874 | 2918 |
1875 fieldDescriptor fd; | 2919 fieldDescriptor fd; |
1876 bool found = false; | 2920 bool found = false; |
1896 | 2940 |
1897 | 2941 |
1898 // | 2942 // |
1899 // Accessing Static Fields | 2943 // Accessing Static Fields |
1900 // | 2944 // |
2945 #ifndef USDT2 | |
1901 DT_RETURN_MARK_DECL(GetStaticFieldID, jfieldID); | 2946 DT_RETURN_MARK_DECL(GetStaticFieldID, jfieldID); |
2947 #else /* USDT2 */ | |
2948 DT_RETURN_MARK_DECL(GetStaticFieldID, jfieldID | |
2949 , HOTSPOT_JNI_GETSTATICFIELDID_RETURN((uintptr_t)_ret_ref)); | |
2950 #endif /* USDT2 */ | |
1902 | 2951 |
1903 JNI_ENTRY(jfieldID, jni_GetStaticFieldID(JNIEnv *env, jclass clazz, | 2952 JNI_ENTRY(jfieldID, jni_GetStaticFieldID(JNIEnv *env, jclass clazz, |
1904 const char *name, const char *sig)) | 2953 const char *name, const char *sig)) |
1905 JNIWrapper("GetStaticFieldID"); | 2954 JNIWrapper("GetStaticFieldID"); |
2955 #ifndef USDT2 | |
1906 DTRACE_PROBE4(hotspot_jni, GetStaticFieldID__entry, env, clazz, name, sig); | 2956 DTRACE_PROBE4(hotspot_jni, GetStaticFieldID__entry, env, clazz, name, sig); |
2957 #else /* USDT2 */ | |
2958 HOTSPOT_JNI_GETSTATICFIELDID_ENTRY( | |
2959 env, clazz, (char *) name, (char *) sig); | |
2960 #endif /* USDT2 */ | |
1907 jfieldID ret = NULL; | 2961 jfieldID ret = NULL; |
1908 DT_RETURN_MARK(GetStaticFieldID, jfieldID, (const jfieldID&)ret); | 2962 DT_RETURN_MARK(GetStaticFieldID, jfieldID, (const jfieldID&)ret); |
1909 | 2963 |
1910 // The class should have been loaded (we have an instance of the class | 2964 // The class should have been loaded (we have an instance of the class |
1911 // passed in) so the field and signature should already be in the symbol | 2965 // passed in) so the field and signature should already be in the symbol |
1937 JNI_END | 2991 JNI_END |
1938 | 2992 |
1939 | 2993 |
1940 JNI_ENTRY(jobject, jni_GetStaticObjectField(JNIEnv *env, jclass clazz, jfieldID fieldID)) | 2994 JNI_ENTRY(jobject, jni_GetStaticObjectField(JNIEnv *env, jclass clazz, jfieldID fieldID)) |
1941 JNIWrapper("GetStaticObjectField"); | 2995 JNIWrapper("GetStaticObjectField"); |
2996 #ifndef USDT2 | |
1942 DTRACE_PROBE3(hotspot_jni, GetStaticObjectField__entry, env, clazz, fieldID); | 2997 DTRACE_PROBE3(hotspot_jni, GetStaticObjectField__entry, env, clazz, fieldID); |
2998 #else /* USDT2 */ | |
2999 HOTSPOT_JNI_GETSTATICOBJECTFIELD_ENTRY( | |
3000 env, clazz, (uintptr_t) fieldID); | |
3001 #endif /* USDT2 */ | |
1943 #ifndef JNICHECK_KERNEL | 3002 #ifndef JNICHECK_KERNEL |
1944 DEBUG_ONLY(klassOop param_k = jniCheck::validate_class(thread, clazz);) | 3003 DEBUG_ONLY(klassOop param_k = jniCheck::validate_class(thread, clazz);) |
1945 #endif // JNICHECK_KERNEL | 3004 #endif // JNICHECK_KERNEL |
1946 JNIid* id = jfieldIDWorkaround::from_static_jfieldID(fieldID); | 3005 JNIid* id = jfieldIDWorkaround::from_static_jfieldID(fieldID); |
1947 assert(id->is_static_field_id(), "invalid static field id"); | 3006 assert(id->is_static_field_id(), "invalid static field id"); |
1949 // jni_GetField_probe() assumes that is okay to create handles. | 3008 // jni_GetField_probe() assumes that is okay to create handles. |
1950 if (JvmtiExport::should_post_field_access()) { | 3009 if (JvmtiExport::should_post_field_access()) { |
1951 JvmtiExport::jni_GetField_probe(thread, NULL, NULL, id->holder(), fieldID, true); | 3010 JvmtiExport::jni_GetField_probe(thread, NULL, NULL, id->holder(), fieldID, true); |
1952 } | 3011 } |
1953 jobject ret = JNIHandles::make_local(id->holder()->java_mirror()->obj_field(id->offset())); | 3012 jobject ret = JNIHandles::make_local(id->holder()->java_mirror()->obj_field(id->offset())); |
3013 #ifndef USDT2 | |
1954 DTRACE_PROBE1(hotspot_jni, GetStaticObjectField__return, ret); | 3014 DTRACE_PROBE1(hotspot_jni, GetStaticObjectField__return, ret); |
3015 #else /* USDT2 */ | |
3016 HOTSPOT_JNI_GETSTATICOBJECTFIELD_RETURN( | |
3017 ret); | |
3018 #endif /* USDT2 */ | |
1955 return ret; | 3019 return ret; |
1956 JNI_END | 3020 JNI_END |
1957 | 3021 |
3022 #ifndef USDT2 | |
1958 #define DEFINE_GETSTATICFIELD(Return,Fieldname,Result) \ | 3023 #define DEFINE_GETSTATICFIELD(Return,Fieldname,Result) \ |
1959 \ | 3024 \ |
1960 DT_RETURN_MARK_DECL_FOR(Result, GetStatic##Result##Field, Return);\ | 3025 DT_RETURN_MARK_DECL_FOR(Result, GetStatic##Result##Field, Return);\ |
1961 \ | 3026 \ |
1962 JNI_ENTRY(Return, jni_GetStatic##Result##Field(JNIEnv *env, jclass clazz, jfieldID fieldID)) \ | 3027 JNI_ENTRY(Return, jni_GetStatic##Result##Field(JNIEnv *env, jclass clazz, jfieldID fieldID)) \ |
1983 DEFINE_GETSTATICFIELD(jint, int, Int) | 3048 DEFINE_GETSTATICFIELD(jint, int, Int) |
1984 DEFINE_GETSTATICFIELD(jlong, long, Long) | 3049 DEFINE_GETSTATICFIELD(jlong, long, Long) |
1985 DEFINE_GETSTATICFIELD(jfloat, float, Float) | 3050 DEFINE_GETSTATICFIELD(jfloat, float, Float) |
1986 DEFINE_GETSTATICFIELD(jdouble, double, Double) | 3051 DEFINE_GETSTATICFIELD(jdouble, double, Double) |
1987 | 3052 |
3053 #else /* USDT2 */ | |
3054 | |
3055 #define DEFINE_GETSTATICFIELD(Return,Fieldname,Result \ | |
3056 , EntryProbe, ReturnProbe) \ | |
3057 \ | |
3058 DT_RETURN_MARK_DECL_FOR(Result, GetStatic##Result##Field, Return \ | |
3059 , ReturnProbe); \ | |
3060 \ | |
3061 JNI_ENTRY(Return, jni_GetStatic##Result##Field(JNIEnv *env, jclass clazz, jfieldID fieldID)) \ | |
3062 JNIWrapper("GetStatic" XSTR(Result) "Field"); \ | |
3063 EntryProbe; \ | |
3064 Return ret = 0;\ | |
3065 DT_RETURN_MARK_FOR(Result, GetStatic##Result##Field, Return, \ | |
3066 (const Return&)ret);\ | |
3067 JNIid* id = jfieldIDWorkaround::from_static_jfieldID(fieldID); \ | |
3068 assert(id->is_static_field_id(), "invalid static field id"); \ | |
3069 /* Keep JVMTI addition small and only check enabled flag here. */ \ | |
3070 /* jni_GetField_probe() assumes that is okay to create handles. */ \ | |
3071 if (JvmtiExport::should_post_field_access()) { \ | |
3072 JvmtiExport::jni_GetField_probe(thread, NULL, NULL, id->holder(), fieldID, true); \ | |
3073 } \ | |
3074 ret = id->holder()->java_mirror()-> Fieldname##_field (id->offset()); \ | |
3075 return ret;\ | |
3076 JNI_END | |
3077 | |
3078 DEFINE_GETSTATICFIELD(jboolean, bool, Boolean | |
3079 , HOTSPOT_JNI_GETSTATICBOOLEANFIELD_ENTRY(env, clazz, (uintptr_t) fieldID), HOTSPOT_JNI_GETSTATICBOOLEANFIELD_RETURN(_ret_ref)) | |
3080 DEFINE_GETSTATICFIELD(jbyte, byte, Byte | |
3081 , HOTSPOT_JNI_GETSTATICBYTEFIELD_ENTRY(env, clazz, (uintptr_t) fieldID), HOTSPOT_JNI_GETSTATICBYTEFIELD_RETURN(_ret_ref) ) | |
3082 DEFINE_GETSTATICFIELD(jchar, char, Char | |
3083 , HOTSPOT_JNI_GETSTATICCHARFIELD_ENTRY(env, clazz, (uintptr_t) fieldID), HOTSPOT_JNI_GETSTATICCHARFIELD_RETURN(_ret_ref) ) | |
3084 DEFINE_GETSTATICFIELD(jshort, short, Short | |
3085 , HOTSPOT_JNI_GETSTATICSHORTFIELD_ENTRY(env, clazz, (uintptr_t) fieldID), HOTSPOT_JNI_GETSTATICSHORTFIELD_RETURN(_ret_ref) ) | |
3086 DEFINE_GETSTATICFIELD(jint, int, Int | |
3087 , HOTSPOT_JNI_GETSTATICINTFIELD_ENTRY(env, clazz, (uintptr_t) fieldID), HOTSPOT_JNI_GETSTATICINTFIELD_RETURN(_ret_ref) ) | |
3088 DEFINE_GETSTATICFIELD(jlong, long, Long | |
3089 , HOTSPOT_JNI_GETSTATICLONGFIELD_ENTRY(env, clazz, (uintptr_t) fieldID), HOTSPOT_JNI_GETSTATICLONGFIELD_RETURN(_ret_ref) ) | |
3090 // Float and double probes don't return value because dtrace doesn't currently support it | |
3091 DEFINE_GETSTATICFIELD(jfloat, float, Float | |
3092 , HOTSPOT_JNI_GETSTATICFLOATFIELD_ENTRY(env, clazz, (uintptr_t) fieldID), HOTSPOT_JNI_GETSTATICFLOATFIELD_RETURN() ) | |
3093 DEFINE_GETSTATICFIELD(jdouble, double, Double | |
3094 , HOTSPOT_JNI_GETSTATICDOUBLEFIELD_ENTRY(env, clazz, (uintptr_t) fieldID), HOTSPOT_JNI_GETSTATICDOUBLEFIELD_RETURN() ) | |
3095 #endif /* USDT2 */ | |
1988 | 3096 |
1989 JNI_ENTRY(void, jni_SetStaticObjectField(JNIEnv *env, jclass clazz, jfieldID fieldID, jobject value)) | 3097 JNI_ENTRY(void, jni_SetStaticObjectField(JNIEnv *env, jclass clazz, jfieldID fieldID, jobject value)) |
1990 JNIWrapper("SetStaticObjectField"); | 3098 JNIWrapper("SetStaticObjectField"); |
3099 #ifndef USDT2 | |
1991 DTRACE_PROBE4(hotspot_jni, SetStaticObjectField__entry, env, clazz, fieldID, value); | 3100 DTRACE_PROBE4(hotspot_jni, SetStaticObjectField__entry, env, clazz, fieldID, value); |
3101 #else /* USDT2 */ | |
3102 HOTSPOT_JNI_SETSTATICOBJECTFIELD_ENTRY( | |
3103 env, clazz, (uintptr_t) fieldID, value); | |
3104 #endif /* USDT2 */ | |
1992 JNIid* id = jfieldIDWorkaround::from_static_jfieldID(fieldID); | 3105 JNIid* id = jfieldIDWorkaround::from_static_jfieldID(fieldID); |
1993 assert(id->is_static_field_id(), "invalid static field id"); | 3106 assert(id->is_static_field_id(), "invalid static field id"); |
1994 // Keep JVMTI addition small and only check enabled flag here. | 3107 // Keep JVMTI addition small and only check enabled flag here. |
1995 // jni_SetField_probe() assumes that is okay to create handles. | 3108 // jni_SetField_probe() assumes that is okay to create handles. |
1996 if (JvmtiExport::should_post_field_modification()) { | 3109 if (JvmtiExport::should_post_field_modification()) { |
1997 jvalue field_value; | 3110 jvalue field_value; |
1998 field_value.l = value; | 3111 field_value.l = value; |
1999 JvmtiExport::jni_SetField_probe(thread, NULL, NULL, id->holder(), fieldID, true, 'L', (jvalue *)&field_value); | 3112 JvmtiExport::jni_SetField_probe(thread, NULL, NULL, id->holder(), fieldID, true, 'L', (jvalue *)&field_value); |
2000 } | 3113 } |
2001 id->holder()->java_mirror()->obj_field_put(id->offset(), JNIHandles::resolve(value)); | 3114 id->holder()->java_mirror()->obj_field_put(id->offset(), JNIHandles::resolve(value)); |
3115 #ifndef USDT2 | |
2002 DTRACE_PROBE(hotspot_jni, SetStaticObjectField__return); | 3116 DTRACE_PROBE(hotspot_jni, SetStaticObjectField__return); |
2003 JNI_END | 3117 #else /* USDT2 */ |
2004 | 3118 HOTSPOT_JNI_SETSTATICOBJECTFIELD_RETURN( |
2005 | 3119 ); |
3120 #endif /* USDT2 */ | |
3121 JNI_END | |
3122 | |
3123 | |
3124 #ifndef USDT2 | |
2006 #define DEFINE_SETSTATICFIELD(Argument,Fieldname,Result,SigType,unionType) \ | 3125 #define DEFINE_SETSTATICFIELD(Argument,Fieldname,Result,SigType,unionType) \ |
2007 \ | 3126 \ |
2008 JNI_ENTRY(void, jni_SetStatic##Result##Field(JNIEnv *env, jclass clazz, jfieldID fieldID, Argument value)) \ | 3127 JNI_ENTRY(void, jni_SetStatic##Result##Field(JNIEnv *env, jclass clazz, jfieldID fieldID, Argument value)) \ |
2009 JNIWrapper("SetStatic" XSTR(Result) "Field"); \ | 3128 JNIWrapper("SetStatic" XSTR(Result) "Field"); \ |
2010 HS_DTRACE_PROBE_CDECL_N(hotspot_jni, SetStatic##Result##Field__entry,\ | 3129 HS_DTRACE_PROBE_CDECL_N(hotspot_jni, SetStatic##Result##Field__entry,\ |
2032 DEFINE_SETSTATICFIELD(jint, int, Int, 'I', i) | 3151 DEFINE_SETSTATICFIELD(jint, int, Int, 'I', i) |
2033 DEFINE_SETSTATICFIELD(jlong, long, Long, 'J', j) | 3152 DEFINE_SETSTATICFIELD(jlong, long, Long, 'J', j) |
2034 DEFINE_SETSTATICFIELD(jfloat, float, Float, 'F', f) | 3153 DEFINE_SETSTATICFIELD(jfloat, float, Float, 'F', f) |
2035 DEFINE_SETSTATICFIELD(jdouble, double, Double, 'D', d) | 3154 DEFINE_SETSTATICFIELD(jdouble, double, Double, 'D', d) |
2036 | 3155 |
3156 #else /* USDT2 */ | |
3157 | |
3158 #define DEFINE_SETSTATICFIELD(Argument,Fieldname,Result,SigType,unionType \ | |
3159 , EntryProbe, ReturnProbe) \ | |
3160 \ | |
3161 JNI_ENTRY(void, jni_SetStatic##Result##Field(JNIEnv *env, jclass clazz, jfieldID fieldID, Argument value)) \ | |
3162 JNIWrapper("SetStatic" XSTR(Result) "Field"); \ | |
3163 EntryProbe; \ | |
3164 \ | |
3165 JNIid* id = jfieldIDWorkaround::from_static_jfieldID(fieldID); \ | |
3166 assert(id->is_static_field_id(), "invalid static field id"); \ | |
3167 /* Keep JVMTI addition small and only check enabled flag here. */ \ | |
3168 /* jni_SetField_probe() assumes that is okay to create handles. */ \ | |
3169 if (JvmtiExport::should_post_field_modification()) { \ | |
3170 jvalue field_value; \ | |
3171 field_value.unionType = value; \ | |
3172 JvmtiExport::jni_SetField_probe(thread, NULL, NULL, id->holder(), fieldID, true, SigType, (jvalue *)&field_value); \ | |
3173 } \ | |
3174 id->holder()->java_mirror()-> Fieldname##_field_put (id->offset(), value); \ | |
3175 ReturnProbe;\ | |
3176 JNI_END | |
3177 | |
3178 DEFINE_SETSTATICFIELD(jboolean, bool, Boolean, 'Z', z | |
3179 , HOTSPOT_JNI_SETBOOLEANFIELD_ENTRY(env, clazz, (uintptr_t)fieldID, value), | |
3180 HOTSPOT_JNI_SETBOOLEANFIELD_RETURN()) | |
3181 DEFINE_SETSTATICFIELD(jbyte, byte, Byte, 'B', b | |
3182 , HOTSPOT_JNI_SETSTATICBYTEFIELD_ENTRY(env, clazz, (uintptr_t) fieldID, value), | |
3183 HOTSPOT_JNI_SETSTATICBYTEFIELD_RETURN()) | |
3184 DEFINE_SETSTATICFIELD(jchar, char, Char, 'C', c | |
3185 , HOTSPOT_JNI_SETSTATICCHARFIELD_ENTRY(env, clazz, (uintptr_t) fieldID, value), | |
3186 HOTSPOT_JNI_SETSTATICCHARFIELD_RETURN()) | |
3187 DEFINE_SETSTATICFIELD(jshort, short, Short, 'S', s | |
3188 , HOTSPOT_JNI_SETSTATICSHORTFIELD_ENTRY(env, clazz, (uintptr_t) fieldID, value), | |
3189 HOTSPOT_JNI_SETSTATICSHORTFIELD_RETURN()) | |
3190 DEFINE_SETSTATICFIELD(jint, int, Int, 'I', i | |
3191 , HOTSPOT_JNI_SETSTATICINTFIELD_ENTRY(env, clazz, (uintptr_t) fieldID, value), | |
3192 HOTSPOT_JNI_SETSTATICINTFIELD_RETURN()) | |
3193 DEFINE_SETSTATICFIELD(jlong, long, Long, 'J', j | |
3194 , HOTSPOT_JNI_SETSTATICLONGFIELD_ENTRY(env, clazz, (uintptr_t) fieldID, value), | |
3195 HOTSPOT_JNI_SETSTATICLONGFIELD_RETURN()) | |
3196 // Float and double probes don't return value because dtrace doesn't currently support it | |
3197 DEFINE_SETSTATICFIELD(jfloat, float, Float, 'F', f | |
3198 , HOTSPOT_JNI_SETSTATICFLOATFIELD_ENTRY(env, clazz, (uintptr_t) fieldID), | |
3199 HOTSPOT_JNI_SETSTATICFLOATFIELD_RETURN()) | |
3200 DEFINE_SETSTATICFIELD(jdouble, double, Double, 'D', d | |
3201 , HOTSPOT_JNI_SETSTATICDOUBLEFIELD_ENTRY(env, clazz, (uintptr_t) fieldID), | |
3202 HOTSPOT_JNI_SETSTATICDOUBLEFIELD_RETURN()) | |
3203 #endif /* USDT2 */ | |
2037 | 3204 |
2038 // | 3205 // |
2039 // String Operations | 3206 // String Operations |
2040 // | 3207 // |
2041 | 3208 |
2042 // Unicode Interface | 3209 // Unicode Interface |
2043 | 3210 |
3211 #ifndef USDT2 | |
2044 DT_RETURN_MARK_DECL(NewString, jstring); | 3212 DT_RETURN_MARK_DECL(NewString, jstring); |
3213 #else /* USDT2 */ | |
3214 DT_RETURN_MARK_DECL(NewString, jstring | |
3215 , HOTSPOT_JNI_NEWSTRING_RETURN(_ret_ref)); | |
3216 #endif /* USDT2 */ | |
2045 | 3217 |
2046 JNI_ENTRY(jstring, jni_NewString(JNIEnv *env, const jchar *unicodeChars, jsize len)) | 3218 JNI_ENTRY(jstring, jni_NewString(JNIEnv *env, const jchar *unicodeChars, jsize len)) |
2047 JNIWrapper("NewString"); | 3219 JNIWrapper("NewString"); |
3220 #ifndef USDT2 | |
2048 DTRACE_PROBE3(hotspot_jni, NewString__entry, env, unicodeChars, len); | 3221 DTRACE_PROBE3(hotspot_jni, NewString__entry, env, unicodeChars, len); |
3222 #else /* USDT2 */ | |
3223 HOTSPOT_JNI_NEWSTRING_ENTRY( | |
3224 env, (uint16_t *) unicodeChars, len); | |
3225 #endif /* USDT2 */ | |
2049 jstring ret = NULL; | 3226 jstring ret = NULL; |
2050 DT_RETURN_MARK(NewString, jstring, (const jstring&)ret); | 3227 DT_RETURN_MARK(NewString, jstring, (const jstring&)ret); |
2051 oop string=java_lang_String::create_oop_from_unicode((jchar*) unicodeChars, len, CHECK_NULL); | 3228 oop string=java_lang_String::create_oop_from_unicode((jchar*) unicodeChars, len, CHECK_NULL); |
2052 ret = (jstring) JNIHandles::make_local(env, string); | 3229 ret = (jstring) JNIHandles::make_local(env, string); |
2053 return ret; | 3230 return ret; |
2054 JNI_END | 3231 JNI_END |
2055 | 3232 |
2056 | 3233 |
2057 JNI_QUICK_ENTRY(jsize, jni_GetStringLength(JNIEnv *env, jstring string)) | 3234 JNI_QUICK_ENTRY(jsize, jni_GetStringLength(JNIEnv *env, jstring string)) |
2058 JNIWrapper("GetStringLength"); | 3235 JNIWrapper("GetStringLength"); |
3236 #ifndef USDT2 | |
2059 DTRACE_PROBE2(hotspot_jni, GetStringLength__entry, env, string); | 3237 DTRACE_PROBE2(hotspot_jni, GetStringLength__entry, env, string); |
3238 #else /* USDT2 */ | |
3239 HOTSPOT_JNI_GETSTRINGLENGTH_ENTRY( | |
3240 env, string); | |
3241 #endif /* USDT2 */ | |
2060 jsize ret = java_lang_String::length(JNIHandles::resolve_non_null(string)); | 3242 jsize ret = java_lang_String::length(JNIHandles::resolve_non_null(string)); |
3243 #ifndef USDT2 | |
2061 DTRACE_PROBE1(hotspot_jni, GetStringLength__return, ret); | 3244 DTRACE_PROBE1(hotspot_jni, GetStringLength__return, ret); |
3245 #else /* USDT2 */ | |
3246 HOTSPOT_JNI_GETSTRINGLENGTH_RETURN( | |
3247 ret); | |
3248 #endif /* USDT2 */ | |
2062 return ret; | 3249 return ret; |
2063 JNI_END | 3250 JNI_END |
2064 | 3251 |
2065 | 3252 |
2066 JNI_QUICK_ENTRY(const jchar*, jni_GetStringChars( | 3253 JNI_QUICK_ENTRY(const jchar*, jni_GetStringChars( |
2067 JNIEnv *env, jstring string, jboolean *isCopy)) | 3254 JNIEnv *env, jstring string, jboolean *isCopy)) |
2068 JNIWrapper("GetStringChars"); | 3255 JNIWrapper("GetStringChars"); |
3256 #ifndef USDT2 | |
2069 DTRACE_PROBE3(hotspot_jni, GetStringChars__entry, env, string, isCopy); | 3257 DTRACE_PROBE3(hotspot_jni, GetStringChars__entry, env, string, isCopy); |
3258 #else /* USDT2 */ | |
3259 HOTSPOT_JNI_GETSTRINGCHARS_ENTRY( | |
3260 env, string, (uintptr_t *) isCopy); | |
3261 #endif /* USDT2 */ | |
2070 //%note jni_5 | 3262 //%note jni_5 |
2071 if (isCopy != NULL) { | 3263 if (isCopy != NULL) { |
2072 *isCopy = JNI_TRUE; | 3264 *isCopy = JNI_TRUE; |
2073 } | 3265 } |
2074 oop s = JNIHandles::resolve_non_null(string); | 3266 oop s = JNIHandles::resolve_non_null(string); |
2078 jchar* buf = NEW_C_HEAP_ARRAY(jchar, s_len + 1); // add one for zero termination | 3270 jchar* buf = NEW_C_HEAP_ARRAY(jchar, s_len + 1); // add one for zero termination |
2079 if (s_len > 0) { | 3271 if (s_len > 0) { |
2080 memcpy(buf, s_value->char_at_addr(s_offset), sizeof(jchar)*s_len); | 3272 memcpy(buf, s_value->char_at_addr(s_offset), sizeof(jchar)*s_len); |
2081 } | 3273 } |
2082 buf[s_len] = 0; | 3274 buf[s_len] = 0; |
3275 #ifndef USDT2 | |
2083 DTRACE_PROBE1(hotspot_jni, GetStringChars__return, buf); | 3276 DTRACE_PROBE1(hotspot_jni, GetStringChars__return, buf); |
3277 #else /* USDT2 */ | |
3278 HOTSPOT_JNI_GETSTRINGCHARS_RETURN( | |
3279 buf); | |
3280 #endif /* USDT2 */ | |
2084 return buf; | 3281 return buf; |
2085 JNI_END | 3282 JNI_END |
2086 | 3283 |
2087 | 3284 |
2088 JNI_QUICK_ENTRY(void, jni_ReleaseStringChars(JNIEnv *env, jstring str, const jchar *chars)) | 3285 JNI_QUICK_ENTRY(void, jni_ReleaseStringChars(JNIEnv *env, jstring str, const jchar *chars)) |
2089 JNIWrapper("ReleaseStringChars"); | 3286 JNIWrapper("ReleaseStringChars"); |
3287 #ifndef USDT2 | |
2090 DTRACE_PROBE3(hotspot_jni, ReleaseStringChars__entry, env, str, chars); | 3288 DTRACE_PROBE3(hotspot_jni, ReleaseStringChars__entry, env, str, chars); |
3289 #else /* USDT2 */ | |
3290 HOTSPOT_JNI_RELEASESTRINGCHARS_ENTRY( | |
3291 env, str, (uint16_t *) chars); | |
3292 #endif /* USDT2 */ | |
2091 //%note jni_6 | 3293 //%note jni_6 |
2092 if (chars != NULL) { | 3294 if (chars != NULL) { |
2093 // Since String objects are supposed to be immutable, don't copy any | 3295 // Since String objects are supposed to be immutable, don't copy any |
2094 // new data back. A bad user will have to go after the char array. | 3296 // new data back. A bad user will have to go after the char array. |
2095 FreeHeap((void*) chars); | 3297 FreeHeap((void*) chars); |
2096 } | 3298 } |
3299 #ifndef USDT2 | |
2097 DTRACE_PROBE(hotspot_jni, ReleaseStringChars__return); | 3300 DTRACE_PROBE(hotspot_jni, ReleaseStringChars__return); |
3301 #else /* USDT2 */ | |
3302 HOTSPOT_JNI_RELEASESTRINGCHARS_RETURN( | |
3303 ); | |
3304 #endif /* USDT2 */ | |
2098 JNI_END | 3305 JNI_END |
2099 | 3306 |
2100 | 3307 |
2101 // UTF Interface | 3308 // UTF Interface |
2102 | 3309 |
3310 #ifndef USDT2 | |
2103 DT_RETURN_MARK_DECL(NewStringUTF, jstring); | 3311 DT_RETURN_MARK_DECL(NewStringUTF, jstring); |
3312 #else /* USDT2 */ | |
3313 DT_RETURN_MARK_DECL(NewStringUTF, jstring | |
3314 , HOTSPOT_JNI_NEWSTRINGUTF_RETURN(_ret_ref)); | |
3315 #endif /* USDT2 */ | |
2104 | 3316 |
2105 JNI_ENTRY(jstring, jni_NewStringUTF(JNIEnv *env, const char *bytes)) | 3317 JNI_ENTRY(jstring, jni_NewStringUTF(JNIEnv *env, const char *bytes)) |
2106 JNIWrapper("NewStringUTF"); | 3318 JNIWrapper("NewStringUTF"); |
3319 #ifndef USDT2 | |
2107 DTRACE_PROBE2(hotspot_jni, NewStringUTF__entry, env, bytes); | 3320 DTRACE_PROBE2(hotspot_jni, NewStringUTF__entry, env, bytes); |
3321 #else /* USDT2 */ | |
3322 HOTSPOT_JNI_NEWSTRINGUTF_ENTRY( | |
3323 env, (char *) bytes); | |
3324 #endif /* USDT2 */ | |
2108 jstring ret; | 3325 jstring ret; |
2109 DT_RETURN_MARK(NewStringUTF, jstring, (const jstring&)ret); | 3326 DT_RETURN_MARK(NewStringUTF, jstring, (const jstring&)ret); |
2110 | 3327 |
2111 oop result = java_lang_String::create_oop_from_str((char*) bytes, CHECK_NULL); | 3328 oop result = java_lang_String::create_oop_from_str((char*) bytes, CHECK_NULL); |
2112 ret = (jstring) JNIHandles::make_local(env, result); | 3329 ret = (jstring) JNIHandles::make_local(env, result); |
2114 JNI_END | 3331 JNI_END |
2115 | 3332 |
2116 | 3333 |
2117 JNI_ENTRY(jsize, jni_GetStringUTFLength(JNIEnv *env, jstring string)) | 3334 JNI_ENTRY(jsize, jni_GetStringUTFLength(JNIEnv *env, jstring string)) |
2118 JNIWrapper("GetStringUTFLength"); | 3335 JNIWrapper("GetStringUTFLength"); |
3336 #ifndef USDT2 | |
2119 DTRACE_PROBE2(hotspot_jni, GetStringUTFLength__entry, env, string); | 3337 DTRACE_PROBE2(hotspot_jni, GetStringUTFLength__entry, env, string); |
3338 #else /* USDT2 */ | |
3339 HOTSPOT_JNI_GETSTRINGUTFLENGTH_ENTRY( | |
3340 env, string); | |
3341 #endif /* USDT2 */ | |
2120 jsize ret = java_lang_String::utf8_length(JNIHandles::resolve_non_null(string)); | 3342 jsize ret = java_lang_String::utf8_length(JNIHandles::resolve_non_null(string)); |
3343 #ifndef USDT2 | |
2121 DTRACE_PROBE1(hotspot_jni, GetStringUTFLength__return, ret); | 3344 DTRACE_PROBE1(hotspot_jni, GetStringUTFLength__return, ret); |
3345 #else /* USDT2 */ | |
3346 HOTSPOT_JNI_GETSTRINGUTFLENGTH_RETURN( | |
3347 ret); | |
3348 #endif /* USDT2 */ | |
2122 return ret; | 3349 return ret; |
2123 JNI_END | 3350 JNI_END |
2124 | 3351 |
2125 | 3352 |
2126 JNI_ENTRY(const char*, jni_GetStringUTFChars(JNIEnv *env, jstring string, jboolean *isCopy)) | 3353 JNI_ENTRY(const char*, jni_GetStringUTFChars(JNIEnv *env, jstring string, jboolean *isCopy)) |
2127 JNIWrapper("GetStringUTFChars"); | 3354 JNIWrapper("GetStringUTFChars"); |
3355 #ifndef USDT2 | |
2128 DTRACE_PROBE3(hotspot_jni, GetStringUTFChars__entry, env, string, isCopy); | 3356 DTRACE_PROBE3(hotspot_jni, GetStringUTFChars__entry, env, string, isCopy); |
3357 #else /* USDT2 */ | |
3358 HOTSPOT_JNI_GETSTRINGUTFCHARS_ENTRY( | |
3359 env, string, (uintptr_t *) isCopy); | |
3360 #endif /* USDT2 */ | |
2129 oop java_string = JNIHandles::resolve_non_null(string); | 3361 oop java_string = JNIHandles::resolve_non_null(string); |
2130 size_t length = java_lang_String::utf8_length(java_string); | 3362 size_t length = java_lang_String::utf8_length(java_string); |
2131 char* result = AllocateHeap(length + 1, "GetStringUTFChars"); | 3363 char* result = AllocateHeap(length + 1, "GetStringUTFChars"); |
2132 java_lang_String::as_utf8_string(java_string, result, (int) length + 1); | 3364 java_lang_String::as_utf8_string(java_string, result, (int) length + 1); |
2133 if (isCopy != NULL) *isCopy = JNI_TRUE; | 3365 if (isCopy != NULL) *isCopy = JNI_TRUE; |
3366 #ifndef USDT2 | |
2134 DTRACE_PROBE1(hotspot_jni, GetStringUTFChars__return, result); | 3367 DTRACE_PROBE1(hotspot_jni, GetStringUTFChars__return, result); |
3368 #else /* USDT2 */ | |
3369 HOTSPOT_JNI_GETSTRINGUTFCHARS_RETURN( | |
3370 result); | |
3371 #endif /* USDT2 */ | |
2135 return result; | 3372 return result; |
2136 JNI_END | 3373 JNI_END |
2137 | 3374 |
2138 | 3375 |
2139 JNI_LEAF(void, jni_ReleaseStringUTFChars(JNIEnv *env, jstring str, const char *chars)) | 3376 JNI_LEAF(void, jni_ReleaseStringUTFChars(JNIEnv *env, jstring str, const char *chars)) |
2140 JNIWrapper("ReleaseStringUTFChars"); | 3377 JNIWrapper("ReleaseStringUTFChars"); |
3378 #ifndef USDT2 | |
2141 DTRACE_PROBE3(hotspot_jni, ReleaseStringUTFChars__entry, env, str, chars); | 3379 DTRACE_PROBE3(hotspot_jni, ReleaseStringUTFChars__entry, env, str, chars); |
3380 #else /* USDT2 */ | |
3381 HOTSPOT_JNI_RELEASESTRINGUTFCHARS_ENTRY( | |
3382 env, str, (char *) chars); | |
3383 #endif /* USDT2 */ | |
2142 if (chars != NULL) { | 3384 if (chars != NULL) { |
2143 FreeHeap((char*) chars); | 3385 FreeHeap((char*) chars); |
2144 } | 3386 } |
3387 #ifndef USDT2 | |
2145 DTRACE_PROBE(hotspot_jni, ReleaseStringUTFChars__return); | 3388 DTRACE_PROBE(hotspot_jni, ReleaseStringUTFChars__return); |
3389 #else /* USDT2 */ | |
3390 HOTSPOT_JNI_RELEASESTRINGUTFCHARS_RETURN( | |
3391 ); | |
3392 #endif /* USDT2 */ | |
2146 JNI_END | 3393 JNI_END |
2147 | 3394 |
2148 | 3395 |
2149 JNI_QUICK_ENTRY(jsize, jni_GetArrayLength(JNIEnv *env, jarray array)) | 3396 JNI_QUICK_ENTRY(jsize, jni_GetArrayLength(JNIEnv *env, jarray array)) |
2150 JNIWrapper("GetArrayLength"); | 3397 JNIWrapper("GetArrayLength"); |
3398 #ifndef USDT2 | |
2151 DTRACE_PROBE2(hotspot_jni, GetArrayLength__entry, env, array); | 3399 DTRACE_PROBE2(hotspot_jni, GetArrayLength__entry, env, array); |
3400 #else /* USDT2 */ | |
3401 HOTSPOT_JNI_GETARRAYLENGTH_ENTRY( | |
3402 env, array); | |
3403 #endif /* USDT2 */ | |
2152 arrayOop a = arrayOop(JNIHandles::resolve_non_null(array)); | 3404 arrayOop a = arrayOop(JNIHandles::resolve_non_null(array)); |
2153 assert(a->is_array(), "must be array"); | 3405 assert(a->is_array(), "must be array"); |
2154 jsize ret = a->length(); | 3406 jsize ret = a->length(); |
3407 #ifndef USDT2 | |
2155 DTRACE_PROBE1(hotspot_jni, GetArrayLength__return, ret); | 3408 DTRACE_PROBE1(hotspot_jni, GetArrayLength__return, ret); |
3409 #else /* USDT2 */ | |
3410 HOTSPOT_JNI_GETARRAYLENGTH_RETURN( | |
3411 ret); | |
3412 #endif /* USDT2 */ | |
2156 return ret; | 3413 return ret; |
2157 JNI_END | 3414 JNI_END |
2158 | 3415 |
2159 | 3416 |
2160 // | 3417 // |
2161 // Object Array Operations | 3418 // Object Array Operations |
2162 // | 3419 // |
2163 | 3420 |
3421 #ifndef USDT2 | |
2164 DT_RETURN_MARK_DECL(NewObjectArray, jobjectArray); | 3422 DT_RETURN_MARK_DECL(NewObjectArray, jobjectArray); |
3423 #else /* USDT2 */ | |
3424 DT_RETURN_MARK_DECL(NewObjectArray, jobjectArray | |
3425 , HOTSPOT_JNI_NEWOBJECTARRAY_RETURN(_ret_ref)); | |
3426 #endif /* USDT2 */ | |
2165 | 3427 |
2166 JNI_ENTRY(jobjectArray, jni_NewObjectArray(JNIEnv *env, jsize length, jclass elementClass, jobject initialElement)) | 3428 JNI_ENTRY(jobjectArray, jni_NewObjectArray(JNIEnv *env, jsize length, jclass elementClass, jobject initialElement)) |
2167 JNIWrapper("NewObjectArray"); | 3429 JNIWrapper("NewObjectArray"); |
3430 #ifndef USDT2 | |
2168 DTRACE_PROBE4(hotspot_jni, NewObjectArray__entry, env, length, elementClass, initialElement); | 3431 DTRACE_PROBE4(hotspot_jni, NewObjectArray__entry, env, length, elementClass, initialElement); |
3432 #else /* USDT2 */ | |
3433 HOTSPOT_JNI_NEWOBJECTARRAY_ENTRY( | |
3434 env, length, elementClass, initialElement); | |
3435 #endif /* USDT2 */ | |
2169 jobjectArray ret = NULL; | 3436 jobjectArray ret = NULL; |
2170 DT_RETURN_MARK(NewObjectArray, jobjectArray, (const jobjectArray&)ret); | 3437 DT_RETURN_MARK(NewObjectArray, jobjectArray, (const jobjectArray&)ret); |
2171 KlassHandle ek(THREAD, java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(elementClass))); | 3438 KlassHandle ek(THREAD, java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(elementClass))); |
2172 klassOop ako = Klass::cast(ek())->array_klass(CHECK_NULL); | 3439 klassOop ako = Klass::cast(ek())->array_klass(CHECK_NULL); |
2173 KlassHandle ak = KlassHandle(THREAD, ako); | 3440 KlassHandle ak = KlassHandle(THREAD, ako); |
2181 } | 3448 } |
2182 ret = (jobjectArray) JNIHandles::make_local(env, result); | 3449 ret = (jobjectArray) JNIHandles::make_local(env, result); |
2183 return ret; | 3450 return ret; |
2184 JNI_END | 3451 JNI_END |
2185 | 3452 |
3453 #ifndef USDT2 | |
2186 DT_RETURN_MARK_DECL(GetObjectArrayElement, jobject); | 3454 DT_RETURN_MARK_DECL(GetObjectArrayElement, jobject); |
3455 #else /* USDT2 */ | |
3456 DT_RETURN_MARK_DECL(GetObjectArrayElement, jobject | |
3457 , HOTSPOT_JNI_GETOBJECTARRAYELEMENT_RETURN(_ret_ref)); | |
3458 #endif /* USDT2 */ | |
2187 | 3459 |
2188 JNI_ENTRY(jobject, jni_GetObjectArrayElement(JNIEnv *env, jobjectArray array, jsize index)) | 3460 JNI_ENTRY(jobject, jni_GetObjectArrayElement(JNIEnv *env, jobjectArray array, jsize index)) |
2189 JNIWrapper("GetObjectArrayElement"); | 3461 JNIWrapper("GetObjectArrayElement"); |
3462 #ifndef USDT2 | |
2190 DTRACE_PROBE3(hotspot_jni, GetObjectArrayElement__entry, env, array, index); | 3463 DTRACE_PROBE3(hotspot_jni, GetObjectArrayElement__entry, env, array, index); |
3464 #else /* USDT2 */ | |
3465 HOTSPOT_JNI_GETOBJECTARRAYELEMENT_ENTRY( | |
3466 env, array, index); | |
3467 #endif /* USDT2 */ | |
2191 jobject ret = NULL; | 3468 jobject ret = NULL; |
2192 DT_RETURN_MARK(GetObjectArrayElement, jobject, (const jobject&)ret); | 3469 DT_RETURN_MARK(GetObjectArrayElement, jobject, (const jobject&)ret); |
2193 objArrayOop a = objArrayOop(JNIHandles::resolve_non_null(array)); | 3470 objArrayOop a = objArrayOop(JNIHandles::resolve_non_null(array)); |
2194 if (a->is_within_bounds(index)) { | 3471 if (a->is_within_bounds(index)) { |
2195 ret = JNIHandles::make_local(env, a->obj_at(index)); | 3472 ret = JNIHandles::make_local(env, a->obj_at(index)); |
2199 sprintf(buf, "%d", index); | 3476 sprintf(buf, "%d", index); |
2200 THROW_MSG_0(vmSymbols::java_lang_ArrayIndexOutOfBoundsException(), buf); | 3477 THROW_MSG_0(vmSymbols::java_lang_ArrayIndexOutOfBoundsException(), buf); |
2201 } | 3478 } |
2202 JNI_END | 3479 JNI_END |
2203 | 3480 |
3481 #ifndef USDT2 | |
2204 DT_VOID_RETURN_MARK_DECL(SetObjectArrayElement); | 3482 DT_VOID_RETURN_MARK_DECL(SetObjectArrayElement); |
3483 #else /* USDT2 */ | |
3484 DT_VOID_RETURN_MARK_DECL(SetObjectArrayElement | |
3485 , HOTSPOT_JNI_SETOBJECTARRAYELEMENT_RETURN()); | |
3486 #endif /* USDT2 */ | |
2205 | 3487 |
2206 JNI_ENTRY(void, jni_SetObjectArrayElement(JNIEnv *env, jobjectArray array, jsize index, jobject value)) | 3488 JNI_ENTRY(void, jni_SetObjectArrayElement(JNIEnv *env, jobjectArray array, jsize index, jobject value)) |
2207 JNIWrapper("SetObjectArrayElement"); | 3489 JNIWrapper("SetObjectArrayElement"); |
3490 #ifndef USDT2 | |
2208 DTRACE_PROBE4(hotspot_jni, SetObjectArrayElement__entry, env, array, index, value); | 3491 DTRACE_PROBE4(hotspot_jni, SetObjectArrayElement__entry, env, array, index, value); |
3492 #else /* USDT2 */ | |
3493 HOTSPOT_JNI_SETOBJECTARRAYELEMENT_ENTRY( | |
3494 env, array, index, value); | |
3495 #endif /* USDT2 */ | |
2209 DT_VOID_RETURN_MARK(SetObjectArrayElement); | 3496 DT_VOID_RETURN_MARK(SetObjectArrayElement); |
2210 | 3497 |
2211 objArrayOop a = objArrayOop(JNIHandles::resolve_non_null(array)); | 3498 objArrayOop a = objArrayOop(JNIHandles::resolve_non_null(array)); |
2212 oop v = JNIHandles::resolve(value); | 3499 oop v = JNIHandles::resolve(value); |
2213 if (a->is_within_bounds(index)) { | 3500 if (a->is_within_bounds(index)) { |
2222 THROW_MSG(vmSymbols::java_lang_ArrayIndexOutOfBoundsException(), buf); | 3509 THROW_MSG(vmSymbols::java_lang_ArrayIndexOutOfBoundsException(), buf); |
2223 } | 3510 } |
2224 JNI_END | 3511 JNI_END |
2225 | 3512 |
2226 | 3513 |
3514 #ifndef USDT2 | |
2227 #define DEFINE_NEWSCALARARRAY(Return,Allocator,Result) \ | 3515 #define DEFINE_NEWSCALARARRAY(Return,Allocator,Result) \ |
2228 \ | 3516 \ |
2229 DT_RETURN_MARK_DECL(New##Result##Array, Return);\ | 3517 DT_RETURN_MARK_DECL(New##Result##Array, Return); \ |
2230 \ | 3518 \ |
2231 JNI_ENTRY(Return, \ | 3519 JNI_ENTRY(Return, \ |
2232 jni_New##Result##Array(JNIEnv *env, jsize len)) \ | 3520 jni_New##Result##Array(JNIEnv *env, jsize len)) \ |
2233 JNIWrapper("New" XSTR(Result) "Array"); \ | 3521 JNIWrapper("New" XSTR(Result) "Array"); \ |
2234 DTRACE_PROBE2(hotspot_jni, New##Result##Array__entry, env, len);\ | 3522 DTRACE_PROBE2(hotspot_jni, New##Result##Array__entry, env, len);\ |
2247 DEFINE_NEWSCALARARRAY(jintArray, new_intArray, Int) | 3535 DEFINE_NEWSCALARARRAY(jintArray, new_intArray, Int) |
2248 DEFINE_NEWSCALARARRAY(jlongArray, new_longArray, Long) | 3536 DEFINE_NEWSCALARARRAY(jlongArray, new_longArray, Long) |
2249 DEFINE_NEWSCALARARRAY(jfloatArray, new_singleArray, Float) | 3537 DEFINE_NEWSCALARARRAY(jfloatArray, new_singleArray, Float) |
2250 DEFINE_NEWSCALARARRAY(jdoubleArray, new_doubleArray, Double) | 3538 DEFINE_NEWSCALARARRAY(jdoubleArray, new_doubleArray, Double) |
2251 | 3539 |
3540 #else /* USDT2 */ | |
3541 | |
3542 #define DEFINE_NEWSCALARARRAY(Return,Allocator,Result \ | |
3543 ,EntryProbe,ReturnProbe) \ | |
3544 \ | |
3545 DT_RETURN_MARK_DECL(New##Result##Array, Return \ | |
3546 , ReturnProbe); \ | |
3547 \ | |
3548 JNI_ENTRY(Return, \ | |
3549 jni_New##Result##Array(JNIEnv *env, jsize len)) \ | |
3550 JNIWrapper("New" XSTR(Result) "Array"); \ | |
3551 EntryProbe; \ | |
3552 Return ret = NULL;\ | |
3553 DT_RETURN_MARK(New##Result##Array, Return, (const Return&)ret);\ | |
3554 \ | |
3555 oop obj= oopFactory::Allocator(len, CHECK_0); \ | |
3556 ret = (Return) JNIHandles::make_local(env, obj); \ | |
3557 return ret;\ | |
3558 JNI_END | |
3559 | |
3560 DEFINE_NEWSCALARARRAY(jbooleanArray, new_boolArray, Boolean, | |
3561 HOTSPOT_JNI_NEWBOOLEANARRAY_ENTRY(env, len), | |
3562 HOTSPOT_JNI_NEWBOOLEANARRAY_RETURN(_ret_ref)) | |
3563 DEFINE_NEWSCALARARRAY(jbyteArray, new_byteArray, Byte, | |
3564 HOTSPOT_JNI_NEWBYTEARRAY_ENTRY(env, len), | |
3565 HOTSPOT_JNI_NEWBYTEARRAY_RETURN(_ret_ref)) | |
3566 DEFINE_NEWSCALARARRAY(jshortArray, new_shortArray, Short, | |
3567 HOTSPOT_JNI_NEWSHORTARRAY_ENTRY(env, len), | |
3568 HOTSPOT_JNI_NEWSHORTARRAY_RETURN(_ret_ref)) | |
3569 DEFINE_NEWSCALARARRAY(jcharArray, new_charArray, Char, | |
3570 HOTSPOT_JNI_NEWCHARARRAY_ENTRY(env, len), | |
3571 HOTSPOT_JNI_NEWCHARARRAY_RETURN(_ret_ref)) | |
3572 DEFINE_NEWSCALARARRAY(jintArray, new_intArray, Int, | |
3573 HOTSPOT_JNI_NEWINTARRAY_ENTRY(env, len), | |
3574 HOTSPOT_JNI_NEWINTARRAY_RETURN(_ret_ref)) | |
3575 DEFINE_NEWSCALARARRAY(jlongArray, new_longArray, Long, | |
3576 HOTSPOT_JNI_NEWLONGARRAY_ENTRY(env, len), | |
3577 HOTSPOT_JNI_NEWLONGARRAY_RETURN(_ret_ref)) | |
3578 DEFINE_NEWSCALARARRAY(jfloatArray, new_singleArray, Float, | |
3579 HOTSPOT_JNI_NEWFLOATARRAY_ENTRY(env, len), | |
3580 HOTSPOT_JNI_NEWFLOATARRAY_RETURN(_ret_ref)) | |
3581 DEFINE_NEWSCALARARRAY(jdoubleArray, new_doubleArray, Double, | |
3582 HOTSPOT_JNI_NEWDOUBLEARRAY_ENTRY(env, len), | |
3583 HOTSPOT_JNI_NEWDOUBLEARRAY_RETURN(_ret_ref)) | |
3584 #endif /* USDT2 */ | |
2252 | 3585 |
2253 // Return an address which will fault if the caller writes to it. | 3586 // Return an address which will fault if the caller writes to it. |
2254 | 3587 |
2255 static char* get_bad_address() { | 3588 static char* get_bad_address() { |
2256 static char* bad_address = NULL; | 3589 static char* bad_address = NULL; |
2264 } | 3597 } |
2265 return bad_address; | 3598 return bad_address; |
2266 } | 3599 } |
2267 | 3600 |
2268 | 3601 |
3602 #ifndef USDT2 | |
2269 #define DEFINE_GETSCALARARRAYELEMENTS(ElementTag,ElementType,Result, Tag) \ | 3603 #define DEFINE_GETSCALARARRAYELEMENTS(ElementTag,ElementType,Result, Tag) \ |
2270 \ | 3604 \ |
2271 JNI_QUICK_ENTRY(ElementType*, \ | 3605 JNI_QUICK_ENTRY(ElementType*, \ |
2272 jni_Get##Result##ArrayElements(JNIEnv *env, ElementType##Array array, jboolean *isCopy)) \ | 3606 jni_Get##Result##ArrayElements(JNIEnv *env, ElementType##Array array, jboolean *isCopy)) \ |
2273 JNIWrapper("Get" XSTR(Result) "ArrayElements"); \ | 3607 JNIWrapper("Get" XSTR(Result) "ArrayElements"); \ |
2298 DEFINE_GETSCALARARRAYELEMENTS(T_INT, jint, Int, int) | 3632 DEFINE_GETSCALARARRAYELEMENTS(T_INT, jint, Int, int) |
2299 DEFINE_GETSCALARARRAYELEMENTS(T_LONG, jlong, Long, long) | 3633 DEFINE_GETSCALARARRAYELEMENTS(T_LONG, jlong, Long, long) |
2300 DEFINE_GETSCALARARRAYELEMENTS(T_FLOAT, jfloat, Float, float) | 3634 DEFINE_GETSCALARARRAYELEMENTS(T_FLOAT, jfloat, Float, float) |
2301 DEFINE_GETSCALARARRAYELEMENTS(T_DOUBLE, jdouble, Double, double) | 3635 DEFINE_GETSCALARARRAYELEMENTS(T_DOUBLE, jdouble, Double, double) |
2302 | 3636 |
2303 | 3637 #else /* USDT2 */ |
3638 | |
3639 #define DEFINE_GETSCALARARRAYELEMENTS(ElementTag,ElementType,Result, Tag \ | |
3640 , EntryProbe, ReturnProbe) \ | |
3641 \ | |
3642 JNI_QUICK_ENTRY(ElementType*, \ | |
3643 jni_Get##Result##ArrayElements(JNIEnv *env, ElementType##Array array, jboolean *isCopy)) \ | |
3644 JNIWrapper("Get" XSTR(Result) "ArrayElements"); \ | |
3645 EntryProbe; \ | |
3646 /* allocate an chunk of memory in c land */ \ | |
3647 typeArrayOop a = typeArrayOop(JNIHandles::resolve_non_null(array)); \ | |
3648 ElementType* result; \ | |
3649 int len = a->length(); \ | |
3650 if (len == 0) { \ | |
3651 /* Empty array: legal but useless, can't return NULL. \ | |
3652 * Return a pointer to something useless. \ | |
3653 * Avoid asserts in typeArrayOop. */ \ | |
3654 result = (ElementType*)get_bad_address(); \ | |
3655 } else { \ | |
3656 result = NEW_C_HEAP_ARRAY(ElementType, len); \ | |
3657 /* copy the array to the c chunk */ \ | |
3658 memcpy(result, a->Tag##_at_addr(0), sizeof(ElementType)*len); \ | |
3659 } \ | |
3660 if (isCopy) *isCopy = JNI_TRUE; \ | |
3661 ReturnProbe; \ | |
3662 return result; \ | |
3663 JNI_END | |
3664 | |
3665 DEFINE_GETSCALARARRAYELEMENTS(T_BOOLEAN, jboolean, Boolean, bool | |
3666 , HOTSPOT_JNI_GETBOOLEANARRAYELEMENTS_ENTRY(env, array, (uintptr_t *) isCopy), | |
3667 HOTSPOT_JNI_GETBOOLEANARRAYELEMENTS_RETURN((uintptr_t*)result)) | |
3668 DEFINE_GETSCALARARRAYELEMENTS(T_BYTE, jbyte, Byte, byte | |
3669 , HOTSPOT_JNI_GETBYTEARRAYELEMENTS_ENTRY(env, array, (uintptr_t *) isCopy), | |
3670 HOTSPOT_JNI_GETBYTEARRAYELEMENTS_RETURN((char*)result)) | |
3671 DEFINE_GETSCALARARRAYELEMENTS(T_SHORT, jshort, Short, short | |
3672 , HOTSPOT_JNI_GETSHORTARRAYELEMENTS_ENTRY(env, (uint16_t*) array, (uintptr_t *) isCopy), | |
3673 HOTSPOT_JNI_GETSHORTARRAYELEMENTS_RETURN((uint16_t*)result)) | |
3674 DEFINE_GETSCALARARRAYELEMENTS(T_CHAR, jchar, Char, char | |
3675 , HOTSPOT_JNI_GETCHARARRAYELEMENTS_ENTRY(env, (uint16_t*) array, (uintptr_t *) isCopy), | |
3676 HOTSPOT_JNI_GETCHARARRAYELEMENTS_RETURN(result)) | |
3677 DEFINE_GETSCALARARRAYELEMENTS(T_INT, jint, Int, int | |
3678 , HOTSPOT_JNI_GETINTARRAYELEMENTS_ENTRY(env, array, (uintptr_t *) isCopy), | |
3679 HOTSPOT_JNI_GETINTARRAYELEMENTS_RETURN((uint32_t*)result)) | |
3680 DEFINE_GETSCALARARRAYELEMENTS(T_LONG, jlong, Long, long | |
3681 , HOTSPOT_JNI_GETLONGARRAYELEMENTS_ENTRY(env, array, (uintptr_t *) isCopy), | |
3682 HOTSPOT_JNI_GETLONGARRAYELEMENTS_RETURN(((uintptr_t*)result))) | |
3683 // Float and double probes don't return value because dtrace doesn't currently support it | |
3684 DEFINE_GETSCALARARRAYELEMENTS(T_FLOAT, jfloat, Float, float | |
3685 , HOTSPOT_JNI_GETFLOATARRAYELEMENTS_ENTRY(env, array, (uintptr_t *) isCopy), | |
3686 HOTSPOT_JNI_GETFLOATARRAYELEMENTS_RETURN(result)) | |
3687 DEFINE_GETSCALARARRAYELEMENTS(T_DOUBLE, jdouble, Double, double | |
3688 , HOTSPOT_JNI_GETDOUBLEARRAYELEMENTS_ENTRY(env, array, (uintptr_t *) isCopy), | |
3689 HOTSPOT_JNI_GETDOUBLEARRAYELEMENTS_RETURN(result)) | |
3690 #endif /* USDT2 */ | |
3691 | |
3692 #ifndef USDT2 | |
2304 #define DEFINE_RELEASESCALARARRAYELEMENTS(ElementTag,ElementType,Result,Tag) \ | 3693 #define DEFINE_RELEASESCALARARRAYELEMENTS(ElementTag,ElementType,Result,Tag) \ |
2305 \ | 3694 \ |
2306 JNI_QUICK_ENTRY(void, \ | 3695 JNI_QUICK_ENTRY(void, \ |
2307 jni_Release##Result##ArrayElements(JNIEnv *env, ElementType##Array array, \ | 3696 jni_Release##Result##ArrayElements(JNIEnv *env, ElementType##Array array, \ |
2308 ElementType *buf, jint mode)) \ | 3697 ElementType *buf, jint mode)) \ |
2328 DEFINE_RELEASESCALARARRAYELEMENTS(T_INT, jint, Int, int) | 3717 DEFINE_RELEASESCALARARRAYELEMENTS(T_INT, jint, Int, int) |
2329 DEFINE_RELEASESCALARARRAYELEMENTS(T_LONG, jlong, Long, long) | 3718 DEFINE_RELEASESCALARARRAYELEMENTS(T_LONG, jlong, Long, long) |
2330 DEFINE_RELEASESCALARARRAYELEMENTS(T_FLOAT, jfloat, Float, float) | 3719 DEFINE_RELEASESCALARARRAYELEMENTS(T_FLOAT, jfloat, Float, float) |
2331 DEFINE_RELEASESCALARARRAYELEMENTS(T_DOUBLE, jdouble, Double, double) | 3720 DEFINE_RELEASESCALARARRAYELEMENTS(T_DOUBLE, jdouble, Double, double) |
2332 | 3721 |
3722 #else /* USDT2 */ | |
3723 | |
3724 #define DEFINE_RELEASESCALARARRAYELEMENTS(ElementTag,ElementType,Result,Tag \ | |
3725 , EntryProbe, ReturnProbe);\ | |
3726 \ | |
3727 JNI_QUICK_ENTRY(void, \ | |
3728 jni_Release##Result##ArrayElements(JNIEnv *env, ElementType##Array array, \ | |
3729 ElementType *buf, jint mode)) \ | |
3730 JNIWrapper("Release" XSTR(Result) "ArrayElements"); \ | |
3731 EntryProbe; \ | |
3732 typeArrayOop a = typeArrayOop(JNIHandles::resolve_non_null(array)); \ | |
3733 int len = a->length(); \ | |
3734 if (len != 0) { /* Empty array: nothing to free or copy. */ \ | |
3735 if ((mode == 0) || (mode == JNI_COMMIT)) { \ | |
3736 memcpy(a->Tag##_at_addr(0), buf, sizeof(ElementType)*len); \ | |
3737 } \ | |
3738 if ((mode == 0) || (mode == JNI_ABORT)) { \ | |
3739 FreeHeap(buf); \ | |
3740 } \ | |
3741 } \ | |
3742 ReturnProbe; \ | |
3743 JNI_END | |
3744 | |
3745 DEFINE_RELEASESCALARARRAYELEMENTS(T_BOOLEAN, jboolean, Boolean, bool | |
3746 , HOTSPOT_JNI_RELEASEBOOLEANARRAYELEMENTS_ENTRY(env, array, (uintptr_t *) buf, mode), | |
3747 HOTSPOT_JNI_RELEASEBOOLEANARRAYELEMENTS_RETURN()) | |
3748 DEFINE_RELEASESCALARARRAYELEMENTS(T_BYTE, jbyte, Byte, byte | |
3749 , HOTSPOT_JNI_RELEASEBYTEARRAYELEMENTS_ENTRY(env, array, (char *) buf, mode), | |
3750 HOTSPOT_JNI_RELEASEBYTEARRAYELEMENTS_RETURN()) | |
3751 DEFINE_RELEASESCALARARRAYELEMENTS(T_SHORT, jshort, Short, short | |
3752 , HOTSPOT_JNI_RELEASESHORTARRAYELEMENTS_ENTRY(env, array, (uint16_t *) buf, mode), | |
3753 HOTSPOT_JNI_RELEASESHORTARRAYELEMENTS_RETURN()) | |
3754 DEFINE_RELEASESCALARARRAYELEMENTS(T_CHAR, jchar, Char, char | |
3755 , HOTSPOT_JNI_RELEASECHARARRAYELEMENTS_ENTRY(env, array, (uint16_t *) buf, mode), | |
3756 HOTSPOT_JNI_RELEASECHARARRAYELEMENTS_RETURN()) | |
3757 DEFINE_RELEASESCALARARRAYELEMENTS(T_INT, jint, Int, int | |
3758 , HOTSPOT_JNI_RELEASEINTARRAYELEMENTS_ENTRY(env, array, (uint32_t *) buf, mode), | |
3759 HOTSPOT_JNI_RELEASEINTARRAYELEMENTS_RETURN()) | |
3760 DEFINE_RELEASESCALARARRAYELEMENTS(T_LONG, jlong, Long, long | |
3761 , HOTSPOT_JNI_RELEASELONGARRAYELEMENTS_ENTRY(env, array, (uintptr_t *) buf, mode), | |
3762 HOTSPOT_JNI_RELEASELONGARRAYELEMENTS_RETURN()) | |
3763 DEFINE_RELEASESCALARARRAYELEMENTS(T_FLOAT, jfloat, Float, float | |
3764 , HOTSPOT_JNI_RELEASEFLOATARRAYELEMENTS_ENTRY(env, array, (float *) buf, mode), | |
3765 HOTSPOT_JNI_RELEASEFLOATARRAYELEMENTS_RETURN()) | |
3766 DEFINE_RELEASESCALARARRAYELEMENTS(T_DOUBLE, jdouble, Double, double | |
3767 , HOTSPOT_JNI_RELEASEDOUBLEARRAYELEMENTS_ENTRY(env, array, (double *) buf, mode), | |
3768 HOTSPOT_JNI_RELEASEDOUBLEARRAYELEMENTS_RETURN()) | |
3769 #endif /* USDT2 */ | |
3770 | |
3771 #ifndef USDT2 | |
2333 #define DEFINE_GETSCALARARRAYREGION(ElementTag,ElementType,Result, Tag) \ | 3772 #define DEFINE_GETSCALARARRAYREGION(ElementTag,ElementType,Result, Tag) \ |
2334 DT_VOID_RETURN_MARK_DECL(Get##Result##ArrayRegion);\ | 3773 DT_VOID_RETURN_MARK_DECL(Get##Result##ArrayRegion);\ |
2335 \ | 3774 \ |
2336 JNI_ENTRY(void, \ | 3775 JNI_ENTRY(void, \ |
2337 jni_Get##Result##ArrayRegion(JNIEnv *env, ElementType##Array array, jsize start, \ | 3776 jni_Get##Result##ArrayRegion(JNIEnv *env, ElementType##Array array, jsize start, \ |
2359 DEFINE_GETSCALARARRAYREGION(T_INT, jint, Int, int) | 3798 DEFINE_GETSCALARARRAYREGION(T_INT, jint, Int, int) |
2360 DEFINE_GETSCALARARRAYREGION(T_LONG, jlong, Long, long) | 3799 DEFINE_GETSCALARARRAYREGION(T_LONG, jlong, Long, long) |
2361 DEFINE_GETSCALARARRAYREGION(T_FLOAT, jfloat, Float, float) | 3800 DEFINE_GETSCALARARRAYREGION(T_FLOAT, jfloat, Float, float) |
2362 DEFINE_GETSCALARARRAYREGION(T_DOUBLE, jdouble, Double, double) | 3801 DEFINE_GETSCALARARRAYREGION(T_DOUBLE, jdouble, Double, double) |
2363 | 3802 |
3803 #else /* USDT2 */ | |
3804 | |
3805 #define DEFINE_GETSCALARARRAYREGION(ElementTag,ElementType,Result, Tag \ | |
3806 , EntryProbe, ReturnProbe); \ | |
3807 DT_VOID_RETURN_MARK_DECL(Get##Result##ArrayRegion \ | |
3808 , ReturnProbe); \ | |
3809 \ | |
3810 JNI_ENTRY(void, \ | |
3811 jni_Get##Result##ArrayRegion(JNIEnv *env, ElementType##Array array, jsize start, \ | |
3812 jsize len, ElementType *buf)) \ | |
3813 JNIWrapper("Get" XSTR(Result) "ArrayRegion"); \ | |
3814 EntryProbe; \ | |
3815 DT_VOID_RETURN_MARK(Get##Result##ArrayRegion); \ | |
3816 typeArrayOop src = typeArrayOop(JNIHandles::resolve_non_null(array)); \ | |
3817 if (start < 0 || len < 0 || ((unsigned int)start + (unsigned int)len > (unsigned int)src->length())) { \ | |
3818 THROW(vmSymbols::java_lang_ArrayIndexOutOfBoundsException()); \ | |
3819 } else { \ | |
3820 if (len > 0) { \ | |
3821 int sc = typeArrayKlass::cast(src->klass())->log2_element_size(); \ | |
3822 memcpy((u_char*) buf, \ | |
3823 (u_char*) src->Tag##_at_addr(start), \ | |
3824 len << sc); \ | |
3825 } \ | |
3826 } \ | |
3827 JNI_END | |
3828 | |
3829 DEFINE_GETSCALARARRAYREGION(T_BOOLEAN, jboolean,Boolean, bool | |
3830 , HOTSPOT_JNI_GETBOOLEANARRAYREGION_ENTRY(env, array, start, len, (uintptr_t *) buf), | |
3831 HOTSPOT_JNI_GETBOOLEANARRAYREGION_RETURN()); | |
3832 DEFINE_GETSCALARARRAYREGION(T_BYTE, jbyte, Byte, byte | |
3833 , HOTSPOT_JNI_GETBYTEARRAYREGION_ENTRY(env, array, start, len, (char *) buf), | |
3834 HOTSPOT_JNI_GETBYTEARRAYREGION_RETURN()); | |
3835 DEFINE_GETSCALARARRAYREGION(T_SHORT, jshort, Short, short | |
3836 , HOTSPOT_JNI_GETSHORTARRAYREGION_ENTRY(env, array, start, len, (uint16_t *) buf), | |
3837 HOTSPOT_JNI_GETSHORTARRAYREGION_RETURN()); | |
3838 DEFINE_GETSCALARARRAYREGION(T_CHAR, jchar, Char, char | |
3839 , HOTSPOT_JNI_GETCHARARRAYREGION_ENTRY(env, array, start, len, (uint16_t*) buf), | |
3840 HOTSPOT_JNI_GETCHARARRAYREGION_RETURN()); | |
3841 DEFINE_GETSCALARARRAYREGION(T_INT, jint, Int, int | |
3842 , HOTSPOT_JNI_GETINTARRAYREGION_ENTRY(env, array, start, len, (uint32_t*) buf), | |
3843 HOTSPOT_JNI_GETINTARRAYREGION_RETURN()); | |
3844 DEFINE_GETSCALARARRAYREGION(T_LONG, jlong, Long, long | |
3845 , HOTSPOT_JNI_GETLONGARRAYREGION_ENTRY(env, array, start, len, (uintptr_t *) buf), | |
3846 HOTSPOT_JNI_GETLONGARRAYREGION_RETURN()); | |
3847 DEFINE_GETSCALARARRAYREGION(T_FLOAT, jfloat, Float, float | |
3848 , HOTSPOT_JNI_GETFLOATARRAYREGION_ENTRY(env, array, start, len, (float *) buf), | |
3849 HOTSPOT_JNI_GETFLOATARRAYREGION_RETURN()); | |
3850 DEFINE_GETSCALARARRAYREGION(T_DOUBLE, jdouble, Double, double | |
3851 , HOTSPOT_JNI_GETDOUBLEARRAYREGION_ENTRY(env, array, start, len, (double *) buf), | |
3852 HOTSPOT_JNI_GETDOUBLEARRAYREGION_RETURN()); | |
3853 #endif /* USDT2 */ | |
3854 | |
3855 #ifndef USDT2 | |
2364 #define DEFINE_SETSCALARARRAYREGION(ElementTag,ElementType,Result, Tag) \ | 3856 #define DEFINE_SETSCALARARRAYREGION(ElementTag,ElementType,Result, Tag) \ |
2365 DT_VOID_RETURN_MARK_DECL(Set##Result##ArrayRegion);\ | 3857 DT_VOID_RETURN_MARK_DECL(Set##Result##ArrayRegion);\ |
2366 \ | 3858 \ |
2367 JNI_ENTRY(void, \ | 3859 JNI_ENTRY(void, \ |
2368 jni_Set##Result##ArrayRegion(JNIEnv *env, ElementType##Array array, jsize start, \ | 3860 jni_Set##Result##ArrayRegion(JNIEnv *env, ElementType##Array array, jsize start, \ |
2389 DEFINE_SETSCALARARRAYREGION(T_CHAR, jchar, Char, char) | 3881 DEFINE_SETSCALARARRAYREGION(T_CHAR, jchar, Char, char) |
2390 DEFINE_SETSCALARARRAYREGION(T_INT, jint, Int, int) | 3882 DEFINE_SETSCALARARRAYREGION(T_INT, jint, Int, int) |
2391 DEFINE_SETSCALARARRAYREGION(T_LONG, jlong, Long, long) | 3883 DEFINE_SETSCALARARRAYREGION(T_LONG, jlong, Long, long) |
2392 DEFINE_SETSCALARARRAYREGION(T_FLOAT, jfloat, Float, float) | 3884 DEFINE_SETSCALARARRAYREGION(T_FLOAT, jfloat, Float, float) |
2393 DEFINE_SETSCALARARRAYREGION(T_DOUBLE, jdouble, Double, double) | 3885 DEFINE_SETSCALARARRAYREGION(T_DOUBLE, jdouble, Double, double) |
3886 | |
3887 #else /* USDT2 */ | |
3888 | |
3889 #define DEFINE_SETSCALARARRAYREGION(ElementTag,ElementType,Result, Tag \ | |
3890 , EntryProbe, ReturnProbe); \ | |
3891 DT_VOID_RETURN_MARK_DECL(Set##Result##ArrayRegion \ | |
3892 ,ReturnProbe); \ | |
3893 \ | |
3894 JNI_ENTRY(void, \ | |
3895 jni_Set##Result##ArrayRegion(JNIEnv *env, ElementType##Array array, jsize start, \ | |
3896 jsize len, const ElementType *buf)) \ | |
3897 JNIWrapper("Set" XSTR(Result) "ArrayRegion"); \ | |
3898 EntryProbe; \ | |
3899 DT_VOID_RETURN_MARK(Set##Result##ArrayRegion); \ | |
3900 typeArrayOop dst = typeArrayOop(JNIHandles::resolve_non_null(array)); \ | |
3901 if (start < 0 || len < 0 || ((unsigned int)start + (unsigned int)len > (unsigned int)dst->length())) { \ | |
3902 THROW(vmSymbols::java_lang_ArrayIndexOutOfBoundsException()); \ | |
3903 } else { \ | |
3904 if (len > 0) { \ | |
3905 int sc = typeArrayKlass::cast(dst->klass())->log2_element_size(); \ | |
3906 memcpy((u_char*) dst->Tag##_at_addr(start), \ | |
3907 (u_char*) buf, \ | |
3908 len << sc); \ | |
3909 } \ | |
3910 } \ | |
3911 JNI_END | |
3912 | |
3913 DEFINE_SETSCALARARRAYREGION(T_BOOLEAN, jboolean, Boolean, bool | |
3914 , HOTSPOT_JNI_SETBOOLEANARRAYREGION_ENTRY(env, array, start, len, (uintptr_t *)buf), | |
3915 HOTSPOT_JNI_SETBOOLEANARRAYREGION_RETURN()) | |
3916 DEFINE_SETSCALARARRAYREGION(T_BYTE, jbyte, Byte, byte | |
3917 , HOTSPOT_JNI_SETBYTEARRAYREGION_ENTRY(env, array, start, len, (char *) buf), | |
3918 HOTSPOT_JNI_SETBYTEARRAYREGION_RETURN()) | |
3919 DEFINE_SETSCALARARRAYREGION(T_SHORT, jshort, Short, short | |
3920 , HOTSPOT_JNI_SETSHORTARRAYREGION_ENTRY(env, array, start, len, (uint16_t *) buf), | |
3921 HOTSPOT_JNI_SETSHORTARRAYREGION_RETURN()) | |
3922 DEFINE_SETSCALARARRAYREGION(T_CHAR, jchar, Char, char | |
3923 , HOTSPOT_JNI_SETCHARARRAYREGION_ENTRY(env, array, start, len, (uint16_t *) buf), | |
3924 HOTSPOT_JNI_SETCHARARRAYREGION_RETURN()) | |
3925 DEFINE_SETSCALARARRAYREGION(T_INT, jint, Int, int | |
3926 , HOTSPOT_JNI_SETINTARRAYREGION_ENTRY(env, array, start, len, (uint32_t *) buf), | |
3927 HOTSPOT_JNI_SETINTARRAYREGION_RETURN()) | |
3928 DEFINE_SETSCALARARRAYREGION(T_LONG, jlong, Long, long | |
3929 , HOTSPOT_JNI_SETLONGARRAYREGION_ENTRY(env, array, start, len, (uintptr_t *) buf), | |
3930 HOTSPOT_JNI_SETLONGARRAYREGION_RETURN()) | |
3931 DEFINE_SETSCALARARRAYREGION(T_FLOAT, jfloat, Float, float | |
3932 , HOTSPOT_JNI_SETFLOATARRAYREGION_ENTRY(env, array, start, len, (float *) buf), | |
3933 HOTSPOT_JNI_SETFLOATARRAYREGION_RETURN()) | |
3934 DEFINE_SETSCALARARRAYREGION(T_DOUBLE, jdouble, Double, double | |
3935 , HOTSPOT_JNI_SETDOUBLEARRAYREGION_ENTRY(env, array, start, len, (double *) buf), | |
3936 HOTSPOT_JNI_SETDOUBLEARRAYREGION_RETURN()) | |
3937 #endif /* USDT2 */ | |
2394 | 3938 |
2395 | 3939 |
2396 // | 3940 // |
2397 // Interception of natives | 3941 // Interception of natives |
2398 // | 3942 // |
2471 method->name()->as_C_string()); | 4015 method->name()->as_C_string()); |
2472 } | 4016 } |
2473 return true; | 4017 return true; |
2474 } | 4018 } |
2475 | 4019 |
4020 #ifndef USDT2 | |
2476 DT_RETURN_MARK_DECL(RegisterNatives, jint); | 4021 DT_RETURN_MARK_DECL(RegisterNatives, jint); |
4022 #else /* USDT2 */ | |
4023 DT_RETURN_MARK_DECL(RegisterNatives, jint | |
4024 , HOTSPOT_JNI_REGISTERNATIVES_RETURN(_ret_ref)); | |
4025 #endif /* USDT2 */ | |
2477 | 4026 |
2478 JNI_ENTRY(jint, jni_RegisterNatives(JNIEnv *env, jclass clazz, | 4027 JNI_ENTRY(jint, jni_RegisterNatives(JNIEnv *env, jclass clazz, |
2479 const JNINativeMethod *methods, | 4028 const JNINativeMethod *methods, |
2480 jint nMethods)) | 4029 jint nMethods)) |
2481 JNIWrapper("RegisterNatives"); | 4030 JNIWrapper("RegisterNatives"); |
4031 #ifndef USDT2 | |
2482 DTRACE_PROBE4(hotspot_jni, RegisterNatives__entry, env, clazz, methods, nMethods); | 4032 DTRACE_PROBE4(hotspot_jni, RegisterNatives__entry, env, clazz, methods, nMethods); |
4033 #else /* USDT2 */ | |
4034 HOTSPOT_JNI_REGISTERNATIVES_ENTRY( | |
4035 env, clazz, (void *) methods, nMethods); | |
4036 #endif /* USDT2 */ | |
2483 jint ret = 0; | 4037 jint ret = 0; |
2484 DT_RETURN_MARK(RegisterNatives, jint, (const jint&)ret); | 4038 DT_RETURN_MARK(RegisterNatives, jint, (const jint&)ret); |
2485 | 4039 |
2486 KlassHandle h_k(thread, java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(clazz))); | 4040 KlassHandle h_k(thread, java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(clazz))); |
2487 | 4041 |
2515 JNI_END | 4069 JNI_END |
2516 | 4070 |
2517 | 4071 |
2518 JNI_ENTRY(jint, jni_UnregisterNatives(JNIEnv *env, jclass clazz)) | 4072 JNI_ENTRY(jint, jni_UnregisterNatives(JNIEnv *env, jclass clazz)) |
2519 JNIWrapper("UnregisterNatives"); | 4073 JNIWrapper("UnregisterNatives"); |
4074 #ifndef USDT2 | |
2520 DTRACE_PROBE2(hotspot_jni, UnregisterNatives__entry, env, clazz); | 4075 DTRACE_PROBE2(hotspot_jni, UnregisterNatives__entry, env, clazz); |
4076 #else /* USDT2 */ | |
4077 HOTSPOT_JNI_UNREGISTERNATIVES_ENTRY( | |
4078 env, clazz); | |
4079 #endif /* USDT2 */ | |
2521 klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(clazz)); | 4080 klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(clazz)); |
2522 //%note jni_2 | 4081 //%note jni_2 |
2523 if (Klass::cast(k)->oop_is_instance()) { | 4082 if (Klass::cast(k)->oop_is_instance()) { |
2524 for (int index = 0; index < instanceKlass::cast(k)->methods()->length(); index++) { | 4083 for (int index = 0; index < instanceKlass::cast(k)->methods()->length(); index++) { |
2525 methodOop m = methodOop(instanceKlass::cast(k)->methods()->obj_at(index)); | 4084 methodOop m = methodOop(instanceKlass::cast(k)->methods()->obj_at(index)); |
2527 m->clear_native_function(); | 4086 m->clear_native_function(); |
2528 m->set_signature_handler(NULL); | 4087 m->set_signature_handler(NULL); |
2529 } | 4088 } |
2530 } | 4089 } |
2531 } | 4090 } |
4091 #ifndef USDT2 | |
2532 DTRACE_PROBE1(hotspot_jni, UnregisterNatives__return, 0); | 4092 DTRACE_PROBE1(hotspot_jni, UnregisterNatives__return, 0); |
4093 #else /* USDT2 */ | |
4094 HOTSPOT_JNI_UNREGISTERNATIVES_RETURN( | |
4095 0); | |
4096 #endif /* USDT2 */ | |
2533 return 0; | 4097 return 0; |
2534 JNI_END | 4098 JNI_END |
2535 | 4099 |
2536 // | 4100 // |
2537 // Monitor functions | 4101 // Monitor functions |
2538 // | 4102 // |
2539 | 4103 |
4104 #ifndef USDT2 | |
2540 DT_RETURN_MARK_DECL(MonitorEnter, jint); | 4105 DT_RETURN_MARK_DECL(MonitorEnter, jint); |
4106 #else /* USDT2 */ | |
4107 DT_RETURN_MARK_DECL(MonitorEnter, jint | |
4108 , HOTSPOT_JNI_MONITORENTER_RETURN(_ret_ref)); | |
4109 #endif /* USDT2 */ | |
2541 | 4110 |
2542 JNI_ENTRY(jint, jni_MonitorEnter(JNIEnv *env, jobject jobj)) | 4111 JNI_ENTRY(jint, jni_MonitorEnter(JNIEnv *env, jobject jobj)) |
4112 #ifndef USDT2 | |
2543 DTRACE_PROBE2(hotspot_jni, MonitorEnter__entry, env, jobj); | 4113 DTRACE_PROBE2(hotspot_jni, MonitorEnter__entry, env, jobj); |
4114 #else /* USDT2 */ | |
4115 HOTSPOT_JNI_MONITORENTER_ENTRY( | |
4116 env, jobj); | |
4117 #endif /* USDT2 */ | |
2544 jint ret = JNI_ERR; | 4118 jint ret = JNI_ERR; |
2545 DT_RETURN_MARK(MonitorEnter, jint, (const jint&)ret); | 4119 DT_RETURN_MARK(MonitorEnter, jint, (const jint&)ret); |
2546 | 4120 |
2547 // If the object is null, we can't do anything with it | 4121 // If the object is null, we can't do anything with it |
2548 if (jobj == NULL) { | 4122 if (jobj == NULL) { |
2553 ObjectSynchronizer::jni_enter(obj, CHECK_(JNI_ERR)); | 4127 ObjectSynchronizer::jni_enter(obj, CHECK_(JNI_ERR)); |
2554 ret = JNI_OK; | 4128 ret = JNI_OK; |
2555 return ret; | 4129 return ret; |
2556 JNI_END | 4130 JNI_END |
2557 | 4131 |
4132 #ifndef USDT2 | |
2558 DT_RETURN_MARK_DECL(MonitorExit, jint); | 4133 DT_RETURN_MARK_DECL(MonitorExit, jint); |
4134 #else /* USDT2 */ | |
4135 DT_RETURN_MARK_DECL(MonitorExit, jint | |
4136 , HOTSPOT_JNI_MONITOREXIT_RETURN(_ret_ref)); | |
4137 #endif /* USDT2 */ | |
2559 | 4138 |
2560 JNI_ENTRY(jint, jni_MonitorExit(JNIEnv *env, jobject jobj)) | 4139 JNI_ENTRY(jint, jni_MonitorExit(JNIEnv *env, jobject jobj)) |
4140 #ifndef USDT2 | |
2561 DTRACE_PROBE2(hotspot_jni, MonitorExit__entry, env, jobj); | 4141 DTRACE_PROBE2(hotspot_jni, MonitorExit__entry, env, jobj); |
4142 #else /* USDT2 */ | |
4143 HOTSPOT_JNI_MONITOREXIT_ENTRY( | |
4144 env, jobj); | |
4145 #endif /* USDT2 */ | |
2562 jint ret = JNI_ERR; | 4146 jint ret = JNI_ERR; |
2563 DT_RETURN_MARK(MonitorExit, jint, (const jint&)ret); | 4147 DT_RETURN_MARK(MonitorExit, jint, (const jint&)ret); |
2564 | 4148 |
2565 // Don't do anything with a null object | 4149 // Don't do anything with a null object |
2566 if (jobj == NULL) { | 4150 if (jobj == NULL) { |
2576 | 4160 |
2577 // | 4161 // |
2578 // Extensions | 4162 // Extensions |
2579 // | 4163 // |
2580 | 4164 |
4165 #ifndef USDT2 | |
2581 DT_VOID_RETURN_MARK_DECL(GetStringRegion); | 4166 DT_VOID_RETURN_MARK_DECL(GetStringRegion); |
4167 #else /* USDT2 */ | |
4168 DT_VOID_RETURN_MARK_DECL(GetStringRegion | |
4169 , HOTSPOT_JNI_GETSTRINGREGION_RETURN()); | |
4170 #endif /* USDT2 */ | |
2582 | 4171 |
2583 JNI_ENTRY(void, jni_GetStringRegion(JNIEnv *env, jstring string, jsize start, jsize len, jchar *buf)) | 4172 JNI_ENTRY(void, jni_GetStringRegion(JNIEnv *env, jstring string, jsize start, jsize len, jchar *buf)) |
2584 JNIWrapper("GetStringRegion"); | 4173 JNIWrapper("GetStringRegion"); |
4174 #ifndef USDT2 | |
2585 DTRACE_PROBE5(hotspot_jni, GetStringRegion__entry, env, string, start, len, buf); | 4175 DTRACE_PROBE5(hotspot_jni, GetStringRegion__entry, env, string, start, len, buf); |
4176 #else /* USDT2 */ | |
4177 HOTSPOT_JNI_GETSTRINGREGION_ENTRY( | |
4178 env, string, start, len, buf); | |
4179 #endif /* USDT2 */ | |
2586 DT_VOID_RETURN_MARK(GetStringRegion); | 4180 DT_VOID_RETURN_MARK(GetStringRegion); |
2587 oop s = JNIHandles::resolve_non_null(string); | 4181 oop s = JNIHandles::resolve_non_null(string); |
2588 int s_len = java_lang_String::length(s); | 4182 int s_len = java_lang_String::length(s); |
2589 if (start < 0 || len < 0 || start + len > s_len) { | 4183 if (start < 0 || len < 0 || start + len > s_len) { |
2590 THROW(vmSymbols::java_lang_StringIndexOutOfBoundsException()); | 4184 THROW(vmSymbols::java_lang_StringIndexOutOfBoundsException()); |
2595 memcpy(buf, s_value->char_at_addr(s_offset+start), sizeof(jchar)*len); | 4189 memcpy(buf, s_value->char_at_addr(s_offset+start), sizeof(jchar)*len); |
2596 } | 4190 } |
2597 } | 4191 } |
2598 JNI_END | 4192 JNI_END |
2599 | 4193 |
4194 #ifndef USDT2 | |
2600 DT_VOID_RETURN_MARK_DECL(GetStringUTFRegion); | 4195 DT_VOID_RETURN_MARK_DECL(GetStringUTFRegion); |
4196 #else /* USDT2 */ | |
4197 DT_VOID_RETURN_MARK_DECL(GetStringUTFRegion | |
4198 , HOTSPOT_JNI_GETSTRINGUTFREGION_RETURN()); | |
4199 #endif /* USDT2 */ | |
2601 | 4200 |
2602 JNI_ENTRY(void, jni_GetStringUTFRegion(JNIEnv *env, jstring string, jsize start, jsize len, char *buf)) | 4201 JNI_ENTRY(void, jni_GetStringUTFRegion(JNIEnv *env, jstring string, jsize start, jsize len, char *buf)) |
2603 JNIWrapper("GetStringUTFRegion"); | 4202 JNIWrapper("GetStringUTFRegion"); |
4203 #ifndef USDT2 | |
2604 DTRACE_PROBE5(hotspot_jni, GetStringUTFRegion__entry, env, string, start, len, buf); | 4204 DTRACE_PROBE5(hotspot_jni, GetStringUTFRegion__entry, env, string, start, len, buf); |
4205 #else /* USDT2 */ | |
4206 HOTSPOT_JNI_GETSTRINGUTFREGION_ENTRY( | |
4207 env, string, start, len, buf); | |
4208 #endif /* USDT2 */ | |
2605 DT_VOID_RETURN_MARK(GetStringUTFRegion); | 4209 DT_VOID_RETURN_MARK(GetStringUTFRegion); |
2606 oop s = JNIHandles::resolve_non_null(string); | 4210 oop s = JNIHandles::resolve_non_null(string); |
2607 int s_len = java_lang_String::length(s); | 4211 int s_len = java_lang_String::length(s); |
2608 if (start < 0 || len < 0 || start + len > s_len) { | 4212 if (start < 0 || len < 0 || start + len > s_len) { |
2609 THROW(vmSymbols::java_lang_StringIndexOutOfBoundsException()); | 4213 THROW(vmSymbols::java_lang_StringIndexOutOfBoundsException()); |
2625 JNI_END | 4229 JNI_END |
2626 | 4230 |
2627 | 4231 |
2628 JNI_ENTRY(void*, jni_GetPrimitiveArrayCritical(JNIEnv *env, jarray array, jboolean *isCopy)) | 4232 JNI_ENTRY(void*, jni_GetPrimitiveArrayCritical(JNIEnv *env, jarray array, jboolean *isCopy)) |
2629 JNIWrapper("GetPrimitiveArrayCritical"); | 4233 JNIWrapper("GetPrimitiveArrayCritical"); |
4234 #ifndef USDT2 | |
2630 DTRACE_PROBE3(hotspot_jni, GetPrimitiveArrayCritical__entry, env, array, isCopy); | 4235 DTRACE_PROBE3(hotspot_jni, GetPrimitiveArrayCritical__entry, env, array, isCopy); |
4236 #else /* USDT2 */ | |
4237 HOTSPOT_JNI_GETPRIMITIVEARRAYCRITICAL_ENTRY( | |
4238 env, array, (uintptr_t *) isCopy); | |
4239 #endif /* USDT2 */ | |
2631 GC_locker::lock_critical(thread); | 4240 GC_locker::lock_critical(thread); |
2632 if (isCopy != NULL) { | 4241 if (isCopy != NULL) { |
2633 *isCopy = JNI_FALSE; | 4242 *isCopy = JNI_FALSE; |
2634 } | 4243 } |
2635 oop a = JNIHandles::resolve_non_null(array); | 4244 oop a = JNIHandles::resolve_non_null(array); |
2639 type = T_OBJECT; | 4248 type = T_OBJECT; |
2640 } else { | 4249 } else { |
2641 type = typeArrayKlass::cast(a->klass())->element_type(); | 4250 type = typeArrayKlass::cast(a->klass())->element_type(); |
2642 } | 4251 } |
2643 void* ret = arrayOop(a)->base(type); | 4252 void* ret = arrayOop(a)->base(type); |
4253 #ifndef USDT2 | |
2644 DTRACE_PROBE1(hotspot_jni, GetPrimitiveArrayCritical__return, ret); | 4254 DTRACE_PROBE1(hotspot_jni, GetPrimitiveArrayCritical__return, ret); |
4255 #else /* USDT2 */ | |
4256 HOTSPOT_JNI_GETPRIMITIVEARRAYCRITICAL_RETURN( | |
4257 ret); | |
4258 #endif /* USDT2 */ | |
2645 return ret; | 4259 return ret; |
2646 JNI_END | 4260 JNI_END |
2647 | 4261 |
2648 | 4262 |
2649 JNI_ENTRY(void, jni_ReleasePrimitiveArrayCritical(JNIEnv *env, jarray array, void *carray, jint mode)) | 4263 JNI_ENTRY(void, jni_ReleasePrimitiveArrayCritical(JNIEnv *env, jarray array, void *carray, jint mode)) |
2650 JNIWrapper("ReleasePrimitiveArrayCritical"); | 4264 JNIWrapper("ReleasePrimitiveArrayCritical"); |
4265 #ifndef USDT2 | |
2651 DTRACE_PROBE4(hotspot_jni, ReleasePrimitiveArrayCritical__entry, env, array, carray, mode); | 4266 DTRACE_PROBE4(hotspot_jni, ReleasePrimitiveArrayCritical__entry, env, array, carray, mode); |
4267 #else /* USDT2 */ | |
4268 HOTSPOT_JNI_RELEASEPRIMITIVEARRAYCRITICAL_ENTRY( | |
4269 env, array, carray, mode); | |
4270 #endif /* USDT2 */ | |
2652 // The array, carray and mode arguments are ignored | 4271 // The array, carray and mode arguments are ignored |
2653 GC_locker::unlock_critical(thread); | 4272 GC_locker::unlock_critical(thread); |
4273 #ifndef USDT2 | |
2654 DTRACE_PROBE(hotspot_jni, ReleasePrimitiveArrayCritical__return); | 4274 DTRACE_PROBE(hotspot_jni, ReleasePrimitiveArrayCritical__return); |
4275 #else /* USDT2 */ | |
4276 HOTSPOT_JNI_RELEASEPRIMITIVEARRAYCRITICAL_RETURN( | |
4277 ); | |
4278 #endif /* USDT2 */ | |
2655 JNI_END | 4279 JNI_END |
2656 | 4280 |
2657 | 4281 |
2658 JNI_ENTRY(const jchar*, jni_GetStringCritical(JNIEnv *env, jstring string, jboolean *isCopy)) | 4282 JNI_ENTRY(const jchar*, jni_GetStringCritical(JNIEnv *env, jstring string, jboolean *isCopy)) |
2659 JNIWrapper("GetStringCritical"); | 4283 JNIWrapper("GetStringCritical"); |
4284 #ifndef USDT2 | |
2660 DTRACE_PROBE3(hotspot_jni, GetStringCritical__entry, env, string, isCopy); | 4285 DTRACE_PROBE3(hotspot_jni, GetStringCritical__entry, env, string, isCopy); |
4286 #else /* USDT2 */ | |
4287 HOTSPOT_JNI_GETSTRINGCRITICAL_ENTRY( | |
4288 env, string, (uintptr_t *) isCopy); | |
4289 #endif /* USDT2 */ | |
2661 GC_locker::lock_critical(thread); | 4290 GC_locker::lock_critical(thread); |
2662 if (isCopy != NULL) { | 4291 if (isCopy != NULL) { |
2663 *isCopy = JNI_FALSE; | 4292 *isCopy = JNI_FALSE; |
2664 } | 4293 } |
2665 oop s = JNIHandles::resolve_non_null(string); | 4294 oop s = JNIHandles::resolve_non_null(string); |
2670 if (s_len > 0) { | 4299 if (s_len > 0) { |
2671 ret = s_value->char_at_addr(s_offset); | 4300 ret = s_value->char_at_addr(s_offset); |
2672 } else { | 4301 } else { |
2673 ret = (jchar*) s_value->base(T_CHAR); | 4302 ret = (jchar*) s_value->base(T_CHAR); |
2674 } | 4303 } |
4304 #ifndef USDT2 | |
2675 DTRACE_PROBE1(hotspot_jni, GetStringCritical__return, ret); | 4305 DTRACE_PROBE1(hotspot_jni, GetStringCritical__return, ret); |
4306 #else /* USDT2 */ | |
4307 HOTSPOT_JNI_GETSTRINGCRITICAL_RETURN( | |
4308 (uint16_t *) ret); | |
4309 #endif /* USDT2 */ | |
2676 return ret; | 4310 return ret; |
2677 JNI_END | 4311 JNI_END |
2678 | 4312 |
2679 | 4313 |
2680 JNI_ENTRY(void, jni_ReleaseStringCritical(JNIEnv *env, jstring str, const jchar *chars)) | 4314 JNI_ENTRY(void, jni_ReleaseStringCritical(JNIEnv *env, jstring str, const jchar *chars)) |
2681 JNIWrapper("ReleaseStringCritical"); | 4315 JNIWrapper("ReleaseStringCritical"); |
4316 #ifndef USDT2 | |
2682 DTRACE_PROBE3(hotspot_jni, ReleaseStringCritical__entry, env, str, chars); | 4317 DTRACE_PROBE3(hotspot_jni, ReleaseStringCritical__entry, env, str, chars); |
4318 #else /* USDT2 */ | |
4319 HOTSPOT_JNI_RELEASESTRINGCRITICAL_ENTRY( | |
4320 env, str, (uint16_t *) chars); | |
4321 #endif /* USDT2 */ | |
2683 // The str and chars arguments are ignored | 4322 // The str and chars arguments are ignored |
2684 GC_locker::unlock_critical(thread); | 4323 GC_locker::unlock_critical(thread); |
4324 #ifndef USDT2 | |
2685 DTRACE_PROBE(hotspot_jni, ReleaseStringCritical__return); | 4325 DTRACE_PROBE(hotspot_jni, ReleaseStringCritical__return); |
4326 #else /* USDT2 */ | |
4327 HOTSPOT_JNI_RELEASESTRINGCRITICAL_RETURN( | |
4328 ); | |
4329 #endif /* USDT2 */ | |
2686 JNI_END | 4330 JNI_END |
2687 | 4331 |
2688 | 4332 |
2689 JNI_ENTRY(jweak, jni_NewWeakGlobalRef(JNIEnv *env, jobject ref)) | 4333 JNI_ENTRY(jweak, jni_NewWeakGlobalRef(JNIEnv *env, jobject ref)) |
2690 JNIWrapper("jni_NewWeakGlobalRef"); | 4334 JNIWrapper("jni_NewWeakGlobalRef"); |
4335 #ifndef USDT2 | |
2691 DTRACE_PROBE2(hotspot_jni, NewWeakGlobalRef__entry, env, ref); | 4336 DTRACE_PROBE2(hotspot_jni, NewWeakGlobalRef__entry, env, ref); |
4337 #else /* USDT2 */ | |
4338 HOTSPOT_JNI_NEWWEAKGLOBALREF_ENTRY( | |
4339 env, ref); | |
4340 #endif /* USDT2 */ | |
2692 Handle ref_handle(thread, JNIHandles::resolve(ref)); | 4341 Handle ref_handle(thread, JNIHandles::resolve(ref)); |
2693 jweak ret = JNIHandles::make_weak_global(ref_handle); | 4342 jweak ret = JNIHandles::make_weak_global(ref_handle); |
4343 #ifndef USDT2 | |
2694 DTRACE_PROBE1(hotspot_jni, NewWeakGlobalRef__return, ret); | 4344 DTRACE_PROBE1(hotspot_jni, NewWeakGlobalRef__return, ret); |
4345 #else /* USDT2 */ | |
4346 HOTSPOT_JNI_NEWWEAKGLOBALREF_RETURN( | |
4347 ret); | |
4348 #endif /* USDT2 */ | |
2695 return ret; | 4349 return ret; |
2696 JNI_END | 4350 JNI_END |
2697 | 4351 |
2698 // Must be JNI_ENTRY (with HandleMark) | 4352 // Must be JNI_ENTRY (with HandleMark) |
2699 JNI_ENTRY(void, jni_DeleteWeakGlobalRef(JNIEnv *env, jweak ref)) | 4353 JNI_ENTRY(void, jni_DeleteWeakGlobalRef(JNIEnv *env, jweak ref)) |
2700 JNIWrapper("jni_DeleteWeakGlobalRef"); | 4354 JNIWrapper("jni_DeleteWeakGlobalRef"); |
4355 #ifndef USDT2 | |
2701 DTRACE_PROBE2(hotspot_jni, DeleteWeakGlobalRef__entry, env, ref); | 4356 DTRACE_PROBE2(hotspot_jni, DeleteWeakGlobalRef__entry, env, ref); |
4357 #else /* USDT2 */ | |
4358 HOTSPOT_JNI_DELETEWEAKGLOBALREF_ENTRY( | |
4359 env, ref); | |
4360 #endif /* USDT2 */ | |
2702 JNIHandles::destroy_weak_global(ref); | 4361 JNIHandles::destroy_weak_global(ref); |
4362 #ifndef USDT2 | |
2703 DTRACE_PROBE(hotspot_jni, DeleteWeakGlobalRef__return); | 4363 DTRACE_PROBE(hotspot_jni, DeleteWeakGlobalRef__return); |
4364 #else /* USDT2 */ | |
4365 HOTSPOT_JNI_DELETEWEAKGLOBALREF_RETURN( | |
4366 ); | |
4367 #endif /* USDT2 */ | |
2704 JNI_END | 4368 JNI_END |
2705 | 4369 |
2706 | 4370 |
2707 JNI_QUICK_ENTRY(jboolean, jni_ExceptionCheck(JNIEnv *env)) | 4371 JNI_QUICK_ENTRY(jboolean, jni_ExceptionCheck(JNIEnv *env)) |
2708 JNIWrapper("jni_ExceptionCheck"); | 4372 JNIWrapper("jni_ExceptionCheck"); |
4373 #ifndef USDT2 | |
2709 DTRACE_PROBE1(hotspot_jni, ExceptionCheck__entry, env); | 4374 DTRACE_PROBE1(hotspot_jni, ExceptionCheck__entry, env); |
4375 #else /* USDT2 */ | |
4376 HOTSPOT_JNI_EXCEPTIONCHECK_ENTRY( | |
4377 env); | |
4378 #endif /* USDT2 */ | |
2710 jni_check_async_exceptions(thread); | 4379 jni_check_async_exceptions(thread); |
2711 jboolean ret = (thread->has_pending_exception()) ? JNI_TRUE : JNI_FALSE; | 4380 jboolean ret = (thread->has_pending_exception()) ? JNI_TRUE : JNI_FALSE; |
4381 #ifndef USDT2 | |
2712 DTRACE_PROBE1(hotspot_jni, ExceptionCheck__return, ret); | 4382 DTRACE_PROBE1(hotspot_jni, ExceptionCheck__return, ret); |
4383 #else /* USDT2 */ | |
4384 HOTSPOT_JNI_EXCEPTIONCHECK_RETURN( | |
4385 ret); | |
4386 #endif /* USDT2 */ | |
2713 return ret; | 4387 return ret; |
2714 JNI_END | 4388 JNI_END |
2715 | 4389 |
2716 | 4390 |
2717 // Initialization state for three routines below relating to | 4391 // Initialization state for three routines below relating to |
2799 { | 4473 { |
2800 // thread_from_jni_environment() will block if VM is gone. | 4474 // thread_from_jni_environment() will block if VM is gone. |
2801 JavaThread* thread = JavaThread::thread_from_jni_environment(env); | 4475 JavaThread* thread = JavaThread::thread_from_jni_environment(env); |
2802 | 4476 |
2803 JNIWrapper("jni_NewDirectByteBuffer"); | 4477 JNIWrapper("jni_NewDirectByteBuffer"); |
4478 #ifndef USDT2 | |
2804 DTRACE_PROBE3(hotspot_jni, NewDirectByteBuffer__entry, env, address, capacity); | 4479 DTRACE_PROBE3(hotspot_jni, NewDirectByteBuffer__entry, env, address, capacity); |
4480 #else /* USDT2 */ | |
4481 HOTSPOT_JNI_NEWDIRECTBYTEBUFFER_ENTRY( | |
4482 env, address, capacity); | |
4483 #endif /* USDT2 */ | |
2805 | 4484 |
2806 if (!directBufferSupportInitializeEnded) { | 4485 if (!directBufferSupportInitializeEnded) { |
2807 if (!initializeDirectBufferSupport(env, thread)) { | 4486 if (!initializeDirectBufferSupport(env, thread)) { |
4487 #ifndef USDT2 | |
2808 DTRACE_PROBE1(hotspot_jni, NewDirectByteBuffer__return, NULL); | 4488 DTRACE_PROBE1(hotspot_jni, NewDirectByteBuffer__return, NULL); |
4489 #else /* USDT2 */ | |
4490 HOTSPOT_JNI_NEWDIRECTBYTEBUFFER_RETURN( | |
4491 NULL); | |
4492 #endif /* USDT2 */ | |
2809 return NULL; | 4493 return NULL; |
2810 } | 4494 } |
2811 } | 4495 } |
2812 | 4496 |
2813 // Being paranoid about accidental sign extension on address | 4497 // Being paranoid about accidental sign extension on address |
2814 jlong addr = (jlong) ((uintptr_t) address); | 4498 jlong addr = (jlong) ((uintptr_t) address); |
2815 // NOTE that package-private DirectByteBuffer constructor currently | 4499 // NOTE that package-private DirectByteBuffer constructor currently |
2816 // takes int capacity | 4500 // takes int capacity |
2817 jint cap = (jint) capacity; | 4501 jint cap = (jint) capacity; |
2818 jobject ret = env->NewObject(directByteBufferClass, directByteBufferConstructor, addr, cap); | 4502 jobject ret = env->NewObject(directByteBufferClass, directByteBufferConstructor, addr, cap); |
4503 #ifndef USDT2 | |
2819 DTRACE_PROBE1(hotspot_jni, NewDirectByteBuffer__return, ret); | 4504 DTRACE_PROBE1(hotspot_jni, NewDirectByteBuffer__return, ret); |
4505 #else /* USDT2 */ | |
4506 HOTSPOT_JNI_NEWDIRECTBYTEBUFFER_RETURN( | |
4507 ret); | |
4508 #endif /* USDT2 */ | |
2820 return ret; | 4509 return ret; |
2821 } | 4510 } |
2822 | 4511 |
4512 #ifndef USDT2 | |
2823 DT_RETURN_MARK_DECL(GetDirectBufferAddress, void*); | 4513 DT_RETURN_MARK_DECL(GetDirectBufferAddress, void*); |
4514 #else /* USDT2 */ | |
4515 DT_RETURN_MARK_DECL(GetDirectBufferAddress, void* | |
4516 , HOTSPOT_JNI_GETDIRECTBUFFERADDRESS_RETURN((void*) _ret_ref)); | |
4517 #endif /* USDT2 */ | |
2824 | 4518 |
2825 extern "C" void* JNICALL jni_GetDirectBufferAddress(JNIEnv *env, jobject buf) | 4519 extern "C" void* JNICALL jni_GetDirectBufferAddress(JNIEnv *env, jobject buf) |
2826 { | 4520 { |
2827 // thread_from_jni_environment() will block if VM is gone. | 4521 // thread_from_jni_environment() will block if VM is gone. |
2828 JavaThread* thread = JavaThread::thread_from_jni_environment(env); | 4522 JavaThread* thread = JavaThread::thread_from_jni_environment(env); |
2829 | 4523 |
2830 JNIWrapper("jni_GetDirectBufferAddress"); | 4524 JNIWrapper("jni_GetDirectBufferAddress"); |
4525 #ifndef USDT2 | |
2831 DTRACE_PROBE2(hotspot_jni, GetDirectBufferAddress__entry, env, buf); | 4526 DTRACE_PROBE2(hotspot_jni, GetDirectBufferAddress__entry, env, buf); |
4527 #else /* USDT2 */ | |
4528 HOTSPOT_JNI_GETDIRECTBUFFERADDRESS_ENTRY( | |
4529 env, buf); | |
4530 #endif /* USDT2 */ | |
2832 void* ret = NULL; | 4531 void* ret = NULL; |
2833 DT_RETURN_MARK(GetDirectBufferAddress, void*, (const void*&)ret); | 4532 DT_RETURN_MARK(GetDirectBufferAddress, void*, (const void*&)ret); |
2834 | 4533 |
2835 if (!directBufferSupportInitializeEnded) { | 4534 if (!directBufferSupportInitializeEnded) { |
2836 if (!initializeDirectBufferSupport(env, thread)) { | 4535 if (!initializeDirectBufferSupport(env, thread)) { |
2844 | 4543 |
2845 ret = (void*)(intptr_t)env->GetLongField(buf, directBufferAddressField); | 4544 ret = (void*)(intptr_t)env->GetLongField(buf, directBufferAddressField); |
2846 return ret; | 4545 return ret; |
2847 } | 4546 } |
2848 | 4547 |
4548 #ifndef USDT2 | |
2849 DT_RETURN_MARK_DECL(GetDirectBufferCapacity, jlong); | 4549 DT_RETURN_MARK_DECL(GetDirectBufferCapacity, jlong); |
4550 #else /* USDT2 */ | |
4551 DT_RETURN_MARK_DECL(GetDirectBufferCapacity, jlong | |
4552 , HOTSPOT_JNI_GETDIRECTBUFFERCAPACITY_RETURN(_ret_ref)); | |
4553 #endif /* USDT2 */ | |
2850 | 4554 |
2851 extern "C" jlong JNICALL jni_GetDirectBufferCapacity(JNIEnv *env, jobject buf) | 4555 extern "C" jlong JNICALL jni_GetDirectBufferCapacity(JNIEnv *env, jobject buf) |
2852 { | 4556 { |
2853 // thread_from_jni_environment() will block if VM is gone. | 4557 // thread_from_jni_environment() will block if VM is gone. |
2854 JavaThread* thread = JavaThread::thread_from_jni_environment(env); | 4558 JavaThread* thread = JavaThread::thread_from_jni_environment(env); |
2855 | 4559 |
2856 JNIWrapper("jni_GetDirectBufferCapacity"); | 4560 JNIWrapper("jni_GetDirectBufferCapacity"); |
4561 #ifndef USDT2 | |
2857 DTRACE_PROBE2(hotspot_jni, GetDirectBufferCapacity__entry, env, buf); | 4562 DTRACE_PROBE2(hotspot_jni, GetDirectBufferCapacity__entry, env, buf); |
4563 #else /* USDT2 */ | |
4564 HOTSPOT_JNI_GETDIRECTBUFFERCAPACITY_ENTRY( | |
4565 env, buf); | |
4566 #endif /* USDT2 */ | |
2858 jlong ret = -1; | 4567 jlong ret = -1; |
2859 DT_RETURN_MARK(GetDirectBufferCapacity, jlong, (const jlong&)ret); | 4568 DT_RETURN_MARK(GetDirectBufferCapacity, jlong, (const jlong&)ret); |
2860 | 4569 |
2861 if (!directBufferSupportInitializeEnded) { | 4570 if (!directBufferSupportInitializeEnded) { |
2862 if (!initializeDirectBufferSupport(env, thread)) { | 4571 if (!initializeDirectBufferSupport(env, thread)) { |
2879 } | 4588 } |
2880 | 4589 |
2881 | 4590 |
2882 JNI_LEAF(jint, jni_GetVersion(JNIEnv *env)) | 4591 JNI_LEAF(jint, jni_GetVersion(JNIEnv *env)) |
2883 JNIWrapper("GetVersion"); | 4592 JNIWrapper("GetVersion"); |
4593 #ifndef USDT2 | |
2884 DTRACE_PROBE1(hotspot_jni, GetVersion__entry, env); | 4594 DTRACE_PROBE1(hotspot_jni, GetVersion__entry, env); |
4595 #else /* USDT2 */ | |
4596 HOTSPOT_JNI_GETVERSION_ENTRY( | |
4597 env); | |
4598 #endif /* USDT2 */ | |
4599 #ifndef USDT2 | |
2885 DTRACE_PROBE1(hotspot_jni, GetVersion__return, CurrentVersion); | 4600 DTRACE_PROBE1(hotspot_jni, GetVersion__return, CurrentVersion); |
4601 #else /* USDT2 */ | |
4602 HOTSPOT_JNI_GETVERSION_RETURN( | |
4603 CurrentVersion); | |
4604 #endif /* USDT2 */ | |
2886 return CurrentVersion; | 4605 return CurrentVersion; |
2887 JNI_END | 4606 JNI_END |
2888 | 4607 |
2889 extern struct JavaVM_ main_vm; | 4608 extern struct JavaVM_ main_vm; |
2890 | 4609 |
2891 JNI_LEAF(jint, jni_GetJavaVM(JNIEnv *env, JavaVM **vm)) | 4610 JNI_LEAF(jint, jni_GetJavaVM(JNIEnv *env, JavaVM **vm)) |
2892 JNIWrapper("jni_GetJavaVM"); | 4611 JNIWrapper("jni_GetJavaVM"); |
4612 #ifndef USDT2 | |
2893 DTRACE_PROBE2(hotspot_jni, GetJavaVM__entry, env, vm); | 4613 DTRACE_PROBE2(hotspot_jni, GetJavaVM__entry, env, vm); |
4614 #else /* USDT2 */ | |
4615 HOTSPOT_JNI_GETJAVAVM_ENTRY( | |
4616 env, (void **) vm); | |
4617 #endif /* USDT2 */ | |
2894 *vm = (JavaVM *)(&main_vm); | 4618 *vm = (JavaVM *)(&main_vm); |
4619 #ifndef USDT2 | |
2895 DTRACE_PROBE1(hotspot_jni, GetJavaVM__return, JNI_OK); | 4620 DTRACE_PROBE1(hotspot_jni, GetJavaVM__return, JNI_OK); |
4621 #else /* USDT2 */ | |
4622 HOTSPOT_JNI_GETJAVAVM_RETURN( | |
4623 JNI_OK); | |
4624 #endif /* USDT2 */ | |
2896 return JNI_OK; | 4625 return JNI_OK; |
2897 JNI_END | 4626 JNI_END |
2898 | 4627 |
2899 // Structure containing all jni functions | 4628 // Structure containing all jni functions |
2900 struct JNINativeInterface_ jni_NativeInterface = { | 4629 struct JNINativeInterface_ jni_NativeInterface = { |
3270 | 4999 |
3271 | 5000 |
3272 #define JAVASTACKSIZE (400 * 1024) /* Default size of a thread java stack */ | 5001 #define JAVASTACKSIZE (400 * 1024) /* Default size of a thread java stack */ |
3273 enum { VERIFY_NONE, VERIFY_REMOTE, VERIFY_ALL }; | 5002 enum { VERIFY_NONE, VERIFY_REMOTE, VERIFY_ALL }; |
3274 | 5003 |
5004 #ifndef USDT2 | |
3275 HS_DTRACE_PROBE_DECL1(hotspot_jni, GetDefaultJavaVMInitArgs__entry, void*); | 5005 HS_DTRACE_PROBE_DECL1(hotspot_jni, GetDefaultJavaVMInitArgs__entry, void*); |
3276 DT_RETURN_MARK_DECL(GetDefaultJavaVMInitArgs, jint); | 5006 DT_RETURN_MARK_DECL(GetDefaultJavaVMInitArgs, jint); |
5007 #else /* USDT2 */ | |
5008 DT_RETURN_MARK_DECL(GetDefaultJavaVMInitArgs, jint | |
5009 , HOTSPOT_JNI_GETDEFAULTJAVAVMINITARGS_RETURN(_ret_ref)); | |
5010 #endif /* USDT2 */ | |
3277 | 5011 |
3278 _JNI_IMPORT_OR_EXPORT_ jint JNICALL JNI_GetDefaultJavaVMInitArgs(void *args_) { | 5012 _JNI_IMPORT_OR_EXPORT_ jint JNICALL JNI_GetDefaultJavaVMInitArgs(void *args_) { |
5013 #ifndef USDT2 | |
3279 HS_DTRACE_PROBE1(hotspot_jni, GetDefaultJavaVMInitArgs__entry, args_); | 5014 HS_DTRACE_PROBE1(hotspot_jni, GetDefaultJavaVMInitArgs__entry, args_); |
5015 #else /* USDT2 */ | |
5016 HOTSPOT_JNI_GETDEFAULTJAVAVMINITARGS_ENTRY( | |
5017 args_); | |
5018 #endif /* USDT2 */ | |
3280 JDK1_1InitArgs *args = (JDK1_1InitArgs *)args_; | 5019 JDK1_1InitArgs *args = (JDK1_1InitArgs *)args_; |
3281 jint ret = JNI_ERR; | 5020 jint ret = JNI_ERR; |
3282 DT_RETURN_MARK(GetDefaultJavaVMInitArgs, jint, (const jint&)ret); | 5021 DT_RETURN_MARK(GetDefaultJavaVMInitArgs, jint, (const jint&)ret); |
3283 | 5022 |
3284 if (Threads::is_supported_jni_version(args->version)) { | 5023 if (Threads::is_supported_jni_version(args->version)) { |
3295 args->javaStackSize = (jint)(ThreadStackSize * K); | 5034 args->javaStackSize = (jint)(ThreadStackSize * K); |
3296 } | 5035 } |
3297 return ret; | 5036 return ret; |
3298 } | 5037 } |
3299 | 5038 |
5039 #ifndef PRODUCT | |
5040 | |
5041 #include "utilities/quickSort.hpp" | |
5042 | |
5043 void execute_internal_vm_tests() { | |
5044 if (ExecuteInternalVMTests) { | |
5045 assert(QuickSort::test_quick_sort(), "test_quick_sort failed"); | |
5046 assert(arrayOopDesc::test_max_array_length(), "test_max_array_length failed"); | |
5047 tty->print_cr("All internal VM tests passed"); | |
5048 } | |
5049 } | |
5050 | |
5051 #endif | |
5052 | |
5053 #ifndef USDT2 | |
3300 HS_DTRACE_PROBE_DECL3(hotspot_jni, CreateJavaVM__entry, vm, penv, args); | 5054 HS_DTRACE_PROBE_DECL3(hotspot_jni, CreateJavaVM__entry, vm, penv, args); |
3301 DT_RETURN_MARK_DECL(CreateJavaVM, jint); | 5055 DT_RETURN_MARK_DECL(CreateJavaVM, jint); |
5056 #else /* USDT2 */ | |
5057 DT_RETURN_MARK_DECL(CreateJavaVM, jint | |
5058 , HOTSPOT_JNI_CREATEJAVAVM_RETURN(_ret_ref)); | |
5059 #endif /* USDT2 */ | |
3302 | 5060 |
3303 _JNI_IMPORT_OR_EXPORT_ jint JNICALL JNI_CreateJavaVM(JavaVM **vm, void **penv, void *args) { | 5061 _JNI_IMPORT_OR_EXPORT_ jint JNICALL JNI_CreateJavaVM(JavaVM **vm, void **penv, void *args) { |
5062 #ifndef USDT2 | |
3304 HS_DTRACE_PROBE3(hotspot_jni, CreateJavaVM__entry, vm, penv, args); | 5063 HS_DTRACE_PROBE3(hotspot_jni, CreateJavaVM__entry, vm, penv, args); |
5064 #else /* USDT2 */ | |
5065 HOTSPOT_JNI_CREATEJAVAVM_ENTRY( | |
5066 (void **) vm, penv, args); | |
5067 #endif /* USDT2 */ | |
3305 | 5068 |
3306 jint result = JNI_ERR; | 5069 jint result = JNI_ERR; |
3307 DT_RETURN_MARK(CreateJavaVM, jint, (const jint&)result); | 5070 DT_RETURN_MARK(CreateJavaVM, jint, (const jint&)result); |
3308 | 5071 |
3309 // We're about to use Atomic::xchg for synchronization. Some Zero | 5072 // We're about to use Atomic::xchg for synchronization. Some Zero |
3392 // control both compiler and architectural-based reordering. | 5155 // control both compiler and architectural-based reordering. |
3393 OrderAccess::release_store(&vm_created, 0); | 5156 OrderAccess::release_store(&vm_created, 0); |
3394 } | 5157 } |
3395 | 5158 |
3396 NOT_PRODUCT(test_error_handler(ErrorHandlerTest)); | 5159 NOT_PRODUCT(test_error_handler(ErrorHandlerTest)); |
5160 NOT_PRODUCT(execute_internal_vm_tests()); | |
3397 return result; | 5161 return result; |
3398 } | 5162 } |
3399 | 5163 |
5164 #ifndef USDT2 | |
3400 HS_DTRACE_PROBE_DECL3(hotspot_jni, GetCreatedJavaVMs__entry, \ | 5165 HS_DTRACE_PROBE_DECL3(hotspot_jni, GetCreatedJavaVMs__entry, \ |
3401 JavaVM**, jsize, jsize*); | 5166 JavaVM**, jsize, jsize*); |
3402 HS_DTRACE_PROBE_DECL1(hotspot_jni, GetCreatedJavaVMs__return, jint); | 5167 HS_DTRACE_PROBE_DECL1(hotspot_jni, GetCreatedJavaVMs__return, jint); |
5168 #endif /* !USDT2 */ | |
3403 | 5169 |
3404 _JNI_IMPORT_OR_EXPORT_ jint JNICALL JNI_GetCreatedJavaVMs(JavaVM **vm_buf, jsize bufLen, jsize *numVMs) { | 5170 _JNI_IMPORT_OR_EXPORT_ jint JNICALL JNI_GetCreatedJavaVMs(JavaVM **vm_buf, jsize bufLen, jsize *numVMs) { |
3405 // See bug 4367188, the wrapper can sometimes cause VM crashes | 5171 // See bug 4367188, the wrapper can sometimes cause VM crashes |
3406 // JNIWrapper("GetCreatedJavaVMs"); | 5172 // JNIWrapper("GetCreatedJavaVMs"); |
5173 #ifndef USDT2 | |
3407 HS_DTRACE_PROBE3(hotspot_jni, GetCreatedJavaVMs__entry, \ | 5174 HS_DTRACE_PROBE3(hotspot_jni, GetCreatedJavaVMs__entry, \ |
3408 vm_buf, bufLen, numVMs); | 5175 vm_buf, bufLen, numVMs); |
5176 #else /* USDT2 */ | |
5177 HOTSPOT_JNI_GETCREATEDJAVAVMS_ENTRY( | |
5178 (void **) vm_buf, bufLen, (uintptr_t *) numVMs); | |
5179 #endif /* USDT2 */ | |
3409 if (vm_created) { | 5180 if (vm_created) { |
3410 if (numVMs != NULL) *numVMs = 1; | 5181 if (numVMs != NULL) *numVMs = 1; |
3411 if (bufLen > 0) *vm_buf = (JavaVM *)(&main_vm); | 5182 if (bufLen > 0) *vm_buf = (JavaVM *)(&main_vm); |
3412 } else { | 5183 } else { |
3413 if (numVMs != NULL) *numVMs = 0; | 5184 if (numVMs != NULL) *numVMs = 0; |
3414 } | 5185 } |
5186 #ifndef USDT2 | |
3415 HS_DTRACE_PROBE1(hotspot_jni, GetCreatedJavaVMs__return, JNI_OK); | 5187 HS_DTRACE_PROBE1(hotspot_jni, GetCreatedJavaVMs__return, JNI_OK); |
5188 #else /* USDT2 */ | |
5189 HOTSPOT_JNI_GETCREATEDJAVAVMS_RETURN( | |
5190 JNI_OK); | |
5191 #endif /* USDT2 */ | |
3416 return JNI_OK; | 5192 return JNI_OK; |
3417 } | 5193 } |
3418 | 5194 |
3419 extern "C" { | 5195 extern "C" { |
3420 | 5196 |
5197 #ifndef USDT2 | |
3421 DT_RETURN_MARK_DECL(DestroyJavaVM, jint); | 5198 DT_RETURN_MARK_DECL(DestroyJavaVM, jint); |
5199 #else /* USDT2 */ | |
5200 DT_RETURN_MARK_DECL(DestroyJavaVM, jint | |
5201 , HOTSPOT_JNI_DESTROYJAVAVM_RETURN(_ret_ref)); | |
5202 #endif /* USDT2 */ | |
3422 | 5203 |
3423 jint JNICALL jni_DestroyJavaVM(JavaVM *vm) { | 5204 jint JNICALL jni_DestroyJavaVM(JavaVM *vm) { |
5205 #ifndef USDT2 | |
3424 DTRACE_PROBE1(hotspot_jni, DestroyJavaVM__entry, vm); | 5206 DTRACE_PROBE1(hotspot_jni, DestroyJavaVM__entry, vm); |
5207 #else /* USDT2 */ | |
5208 HOTSPOT_JNI_DESTROYJAVAVM_ENTRY( | |
5209 vm); | |
5210 #endif /* USDT2 */ | |
3425 jint res = JNI_ERR; | 5211 jint res = JNI_ERR; |
3426 DT_RETURN_MARK(DestroyJavaVM, jint, (const jint&)res); | 5212 DT_RETURN_MARK(DestroyJavaVM, jint, (const jint&)res); |
3427 | 5213 |
3428 if (!vm_created) { | 5214 if (!vm_created) { |
3429 res = JNI_ERR; | 5215 res = JNI_ERR; |
3537 } | 5323 } |
3538 | 5324 |
3539 // mark the thread as no longer attaching | 5325 // mark the thread as no longer attaching |
3540 // this uses a fence to push the change through so we don't have | 5326 // this uses a fence to push the change through so we don't have |
3541 // to regrab the threads_lock | 5327 // to regrab the threads_lock |
3542 thread->set_attached(); | 5328 thread->set_done_attaching_via_jni(); |
3543 | 5329 |
3544 // Set java thread status. | 5330 // Set java thread status. |
3545 java_lang_Thread::set_thread_status(thread->threadObj(), | 5331 java_lang_Thread::set_thread_status(thread->threadObj(), |
3546 java_lang_Thread::RUNNABLE); | 5332 java_lang_Thread::RUNNABLE); |
3547 | 5333 |
3565 return JNI_OK; | 5351 return JNI_OK; |
3566 } | 5352 } |
3567 | 5353 |
3568 | 5354 |
3569 jint JNICALL jni_AttachCurrentThread(JavaVM *vm, void **penv, void *_args) { | 5355 jint JNICALL jni_AttachCurrentThread(JavaVM *vm, void **penv, void *_args) { |
5356 #ifndef USDT2 | |
3570 DTRACE_PROBE3(hotspot_jni, AttachCurrentThread__entry, vm, penv, _args); | 5357 DTRACE_PROBE3(hotspot_jni, AttachCurrentThread__entry, vm, penv, _args); |
5358 #else /* USDT2 */ | |
5359 HOTSPOT_JNI_ATTACHCURRENTTHREAD_ENTRY( | |
5360 vm, penv, _args); | |
5361 #endif /* USDT2 */ | |
3571 if (!vm_created) { | 5362 if (!vm_created) { |
5363 #ifndef USDT2 | |
3572 DTRACE_PROBE1(hotspot_jni, AttachCurrentThread__return, JNI_ERR); | 5364 DTRACE_PROBE1(hotspot_jni, AttachCurrentThread__return, JNI_ERR); |
5365 #else /* USDT2 */ | |
5366 HOTSPOT_JNI_ATTACHCURRENTTHREAD_RETURN( | |
5367 (uint32_t) JNI_ERR); | |
5368 #endif /* USDT2 */ | |
3573 return JNI_ERR; | 5369 return JNI_ERR; |
3574 } | 5370 } |
3575 | 5371 |
3576 JNIWrapper("AttachCurrentThread"); | 5372 JNIWrapper("AttachCurrentThread"); |
3577 jint ret = attach_current_thread(vm, penv, _args, false); | 5373 jint ret = attach_current_thread(vm, penv, _args, false); |
5374 #ifndef USDT2 | |
3578 DTRACE_PROBE1(hotspot_jni, AttachCurrentThread__return, ret); | 5375 DTRACE_PROBE1(hotspot_jni, AttachCurrentThread__return, ret); |
5376 #else /* USDT2 */ | |
5377 HOTSPOT_JNI_ATTACHCURRENTTHREAD_RETURN( | |
5378 ret); | |
5379 #endif /* USDT2 */ | |
3579 return ret; | 5380 return ret; |
3580 } | 5381 } |
3581 | 5382 |
3582 | 5383 |
3583 jint JNICALL jni_DetachCurrentThread(JavaVM *vm) { | 5384 jint JNICALL jni_DetachCurrentThread(JavaVM *vm) { |
5385 #ifndef USDT2 | |
3584 DTRACE_PROBE1(hotspot_jni, DetachCurrentThread__entry, vm); | 5386 DTRACE_PROBE1(hotspot_jni, DetachCurrentThread__entry, vm); |
5387 #else /* USDT2 */ | |
5388 HOTSPOT_JNI_DETACHCURRENTTHREAD_ENTRY( | |
5389 vm); | |
5390 #endif /* USDT2 */ | |
3585 VM_Exit::block_if_vm_exited(); | 5391 VM_Exit::block_if_vm_exited(); |
3586 | 5392 |
3587 JNIWrapper("DetachCurrentThread"); | 5393 JNIWrapper("DetachCurrentThread"); |
3588 | 5394 |
3589 // If the thread has been deattacted the operations is a no-op | 5395 // If the thread has been deattacted the operations is a no-op |
3590 if (ThreadLocalStorage::thread() == NULL) { | 5396 if (ThreadLocalStorage::thread() == NULL) { |
5397 #ifndef USDT2 | |
3591 DTRACE_PROBE1(hotspot_jni, DetachCurrentThread__return, JNI_OK); | 5398 DTRACE_PROBE1(hotspot_jni, DetachCurrentThread__return, JNI_OK); |
5399 #else /* USDT2 */ | |
5400 HOTSPOT_JNI_DETACHCURRENTTHREAD_RETURN( | |
5401 JNI_OK); | |
5402 #endif /* USDT2 */ | |
3592 return JNI_OK; | 5403 return JNI_OK; |
3593 } | 5404 } |
3594 | 5405 |
3595 JavaThread* thread = JavaThread::current(); | 5406 JavaThread* thread = JavaThread::current(); |
3596 if (thread->has_last_Java_frame()) { | 5407 if (thread->has_last_Java_frame()) { |
5408 #ifndef USDT2 | |
3597 DTRACE_PROBE1(hotspot_jni, DetachCurrentThread__return, JNI_ERR); | 5409 DTRACE_PROBE1(hotspot_jni, DetachCurrentThread__return, JNI_ERR); |
5410 #else /* USDT2 */ | |
5411 HOTSPOT_JNI_DETACHCURRENTTHREAD_RETURN( | |
5412 (uint32_t) JNI_ERR); | |
5413 #endif /* USDT2 */ | |
3598 // Can't detach a thread that's running java, that can't work. | 5414 // Can't detach a thread that's running java, that can't work. |
3599 return JNI_ERR; | 5415 return JNI_ERR; |
3600 } | 5416 } |
3601 | 5417 |
3602 // Safepoint support. Have to do call-back to safepoint code, if in the | 5418 // Safepoint support. Have to do call-back to safepoint code, if in the |
3613 // (platform-dependent) methods where we do alternate stack | 5429 // (platform-dependent) methods where we do alternate stack |
3614 // maintenance work?) | 5430 // maintenance work?) |
3615 thread->exit(false, JavaThread::jni_detach); | 5431 thread->exit(false, JavaThread::jni_detach); |
3616 delete thread; | 5432 delete thread; |
3617 | 5433 |
5434 #ifndef USDT2 | |
3618 DTRACE_PROBE1(hotspot_jni, DetachCurrentThread__return, JNI_OK); | 5435 DTRACE_PROBE1(hotspot_jni, DetachCurrentThread__return, JNI_OK); |
5436 #else /* USDT2 */ | |
5437 HOTSPOT_JNI_DETACHCURRENTTHREAD_RETURN( | |
5438 JNI_OK); | |
5439 #endif /* USDT2 */ | |
3619 return JNI_OK; | 5440 return JNI_OK; |
3620 } | 5441 } |
3621 | 5442 |
5443 #ifndef USDT2 | |
3622 DT_RETURN_MARK_DECL(GetEnv, jint); | 5444 DT_RETURN_MARK_DECL(GetEnv, jint); |
5445 #else /* USDT2 */ | |
5446 DT_RETURN_MARK_DECL(GetEnv, jint | |
5447 , HOTSPOT_JNI_GETENV_RETURN(_ret_ref)); | |
5448 #endif /* USDT2 */ | |
3623 | 5449 |
3624 jint JNICALL jni_GetEnv(JavaVM *vm, void **penv, jint version) { | 5450 jint JNICALL jni_GetEnv(JavaVM *vm, void **penv, jint version) { |
5451 #ifndef USDT2 | |
3625 DTRACE_PROBE3(hotspot_jni, GetEnv__entry, vm, penv, version); | 5452 DTRACE_PROBE3(hotspot_jni, GetEnv__entry, vm, penv, version); |
5453 #else /* USDT2 */ | |
5454 HOTSPOT_JNI_GETENV_ENTRY( | |
5455 vm, penv, version); | |
5456 #endif /* USDT2 */ | |
3626 jint ret = JNI_ERR; | 5457 jint ret = JNI_ERR; |
3627 DT_RETURN_MARK(GetEnv, jint, (const jint&)ret); | 5458 DT_RETURN_MARK(GetEnv, jint, (const jint&)ret); |
3628 | 5459 |
3629 if (!vm_created) { | 5460 if (!vm_created) { |
3630 *penv = NULL; | 5461 *penv = NULL; |
3675 } | 5506 } |
3676 } | 5507 } |
3677 | 5508 |
3678 | 5509 |
3679 jint JNICALL jni_AttachCurrentThreadAsDaemon(JavaVM *vm, void **penv, void *_args) { | 5510 jint JNICALL jni_AttachCurrentThreadAsDaemon(JavaVM *vm, void **penv, void *_args) { |
5511 #ifndef USDT2 | |
3680 DTRACE_PROBE3(hotspot_jni, AttachCurrentThreadAsDaemon__entry, vm, penv, _args); | 5512 DTRACE_PROBE3(hotspot_jni, AttachCurrentThreadAsDaemon__entry, vm, penv, _args); |
5513 #else /* USDT2 */ | |
5514 HOTSPOT_JNI_ATTACHCURRENTTHREADASDAEMON_ENTRY( | |
5515 vm, penv, _args); | |
5516 #endif /* USDT2 */ | |
3681 if (!vm_created) { | 5517 if (!vm_created) { |
5518 #ifndef USDT2 | |
3682 DTRACE_PROBE1(hotspot_jni, AttachCurrentThreadAsDaemon__return, JNI_ERR); | 5519 DTRACE_PROBE1(hotspot_jni, AttachCurrentThreadAsDaemon__return, JNI_ERR); |
5520 #else /* USDT2 */ | |
5521 HOTSPOT_JNI_ATTACHCURRENTTHREADASDAEMON_RETURN( | |
5522 (uint32_t) JNI_ERR); | |
5523 #endif /* USDT2 */ | |
3683 return JNI_ERR; | 5524 return JNI_ERR; |
3684 } | 5525 } |
3685 | 5526 |
3686 JNIWrapper("AttachCurrentThreadAsDaemon"); | 5527 JNIWrapper("AttachCurrentThreadAsDaemon"); |
3687 jint ret = attach_current_thread(vm, penv, _args, true); | 5528 jint ret = attach_current_thread(vm, penv, _args, true); |
5529 #ifndef USDT2 | |
3688 DTRACE_PROBE1(hotspot_jni, AttachCurrentThreadAsDaemon__return, ret); | 5530 DTRACE_PROBE1(hotspot_jni, AttachCurrentThreadAsDaemon__return, ret); |
5531 #else /* USDT2 */ | |
5532 HOTSPOT_JNI_ATTACHCURRENTTHREADASDAEMON_RETURN( | |
5533 ret); | |
5534 #endif /* USDT2 */ | |
3689 return ret; | 5535 return ret; |
3690 } | 5536 } |
3691 | 5537 |
3692 | 5538 |
3693 } // End extern "C" | 5539 } // End extern "C" |