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