Mercurial > hg > graal-compiler

comparison src/share/vm/prims/jni.cpp @ 14278:a3ba776d6ab6

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1 Reviewed-by: coleenp, sspitsyn, dsamersoff
author sla
date Thu, 16 Jan 2014 20:14:21 +0100
parents dbcb1dd0785b
children d050fbf914d8
comparison
equal deleted inserted replaced
14277:3bee68af0296 14278:a3ba776d6ab6
431 JNI_ENTRY(jclass, jni_FindClass(JNIEnv *env, const char *name)) 431 JNI_ENTRY(jclass, jni_FindClass(JNIEnv *env, const char *name))
432 JNIWrapper("FindClass"); 432 JNIWrapper("FindClass");
433 #ifndef USDT2 433 #ifndef USDT2
434 DTRACE_PROBE2(hotspot_jni, FindClass__entry, env, name); 434 DTRACE_PROBE2(hotspot_jni, FindClass__entry, env, name);
435 #else /* USDT2 */ 435 #else /* USDT2 */
436 HOTSPOT_JNI_FINDCLASS_ENTRY( 436 HOTSPOT_JNI_FINDCLASS_ENTRY(env, (char *)name);
437 env, (char *)name);
438 #endif /* USDT2 */ 437 #endif /* USDT2 */
439 438
440 jclass result = NULL; 439 jclass result = NULL;
441 DT_RETURN_MARK(FindClass, jclass, (const jclass&)result); 440 DT_RETURN_MARK(FindClass, jclass, (const jclass&)result);
442 441
509 JNI_ENTRY(jmethodID, jni_FromReflectedMethod(JNIEnv *env, jobject method)) 508 JNI_ENTRY(jmethodID, jni_FromReflectedMethod(JNIEnv *env, jobject method))
510 JNIWrapper("FromReflectedMethod"); 509 JNIWrapper("FromReflectedMethod");
511 #ifndef USDT2 510 #ifndef USDT2
512 DTRACE_PROBE2(hotspot_jni, FromReflectedMethod__entry, env, method); 511 DTRACE_PROBE2(hotspot_jni, FromReflectedMethod__entry, env, method);
513 #else /* USDT2 */ 512 #else /* USDT2 */
514 HOTSPOT_JNI_FROMREFLECTEDMETHOD_ENTRY( 513 HOTSPOT_JNI_FROMREFLECTEDMETHOD_ENTRY(env, method);
515 env, method);
516 #endif /* USDT2 */ 514 #endif /* USDT2 */
517 jmethodID ret = NULL; 515 jmethodID ret = NULL;
518 DT_RETURN_MARK(FromReflectedMethod, jmethodID, (const jmethodID&)ret); 516 DT_RETURN_MARK(FromReflectedMethod, jmethodID, (const jmethodID&)ret);
519 517
520 // method is a handle to a java.lang.reflect.Method object 518 // method is a handle to a java.lang.reflect.Method object
550 JNI_ENTRY(jfieldID, jni_FromReflectedField(JNIEnv *env, jobject field)) 548 JNI_ENTRY(jfieldID, jni_FromReflectedField(JNIEnv *env, jobject field))
551 JNIWrapper("FromReflectedField"); 549 JNIWrapper("FromReflectedField");
552 #ifndef USDT2 550 #ifndef USDT2
553 DTRACE_PROBE2(hotspot_jni, FromReflectedField__entry, env, field); 551 DTRACE_PROBE2(hotspot_jni, FromReflectedField__entry, env, field);
554 #else /* USDT2 */ 552 #else /* USDT2 */
555 HOTSPOT_JNI_FROMREFLECTEDFIELD_ENTRY( 553 HOTSPOT_JNI_FROMREFLECTEDFIELD_ENTRY(env, field);
556 env, field);
557 #endif /* USDT2 */ 554 #endif /* USDT2 */
558 jfieldID ret = NULL; 555 jfieldID ret = NULL;
559 DT_RETURN_MARK(FromReflectedField, jfieldID, (const jfieldID&)ret); 556 DT_RETURN_MARK(FromReflectedField, jfieldID, (const jfieldID&)ret);
560 557
561 // field is a handle to a java.lang.reflect.Field object 558 // field is a handle to a java.lang.reflect.Field object
599 JNI_ENTRY(jobject, jni_ToReflectedMethod(JNIEnv *env, jclass cls, jmethodID method_id, jboolean isStatic)) 596 JNI_ENTRY(jobject, jni_ToReflectedMethod(JNIEnv *env, jclass cls, jmethodID method_id, jboolean isStatic))
600 JNIWrapper("ToReflectedMethod"); 597 JNIWrapper("ToReflectedMethod");
601 #ifndef USDT2 598 #ifndef USDT2
602 DTRACE_PROBE4(hotspot_jni, ToReflectedMethod__entry, env, cls, method_id, isStatic); 599 DTRACE_PROBE4(hotspot_jni, ToReflectedMethod__entry, env, cls, method_id, isStatic);
603 #else /* USDT2 */ 600 #else /* USDT2 */
604 HOTSPOT_JNI_TOREFLECTEDMETHOD_ENTRY( 601 HOTSPOT_JNI_TOREFLECTEDMETHOD_ENTRY(env, cls, (uintptr_t) method_id, isStatic);
605 env, cls, (uintptr_t) method_id, isStatic);
606 #endif /* USDT2 */ 602 #endif /* USDT2 */
607 jobject ret = NULL; 603 jobject ret = NULL;
608 DT_RETURN_MARK(ToReflectedMethod, jobject, (const jobject&)ret); 604 DT_RETURN_MARK(ToReflectedMethod, jobject, (const jobject&)ret);
609 605
610 methodHandle m (THREAD, Method::resolve_jmethod_id(method_id)); 606 methodHandle m (THREAD, Method::resolve_jmethod_id(method_id));
629 JNI_ENTRY(jclass, jni_GetSuperclass(JNIEnv *env, jclass sub)) 625 JNI_ENTRY(jclass, jni_GetSuperclass(JNIEnv *env, jclass sub))
630 JNIWrapper("GetSuperclass"); 626 JNIWrapper("GetSuperclass");
631 #ifndef USDT2 627 #ifndef USDT2
632 DTRACE_PROBE2(hotspot_jni, GetSuperclass__entry, env, sub); 628 DTRACE_PROBE2(hotspot_jni, GetSuperclass__entry, env, sub);
633 #else /* USDT2 */ 629 #else /* USDT2 */
634 HOTSPOT_JNI_GETSUPERCLASS_ENTRY( 630 HOTSPOT_JNI_GETSUPERCLASS_ENTRY(env, sub);
635 env, sub);
636 #endif /* USDT2 */ 631 #endif /* USDT2 */
637 jclass obj = NULL; 632 jclass obj = NULL;
638 DT_RETURN_MARK(GetSuperclass, jclass, (const jclass&)obj); 633 DT_RETURN_MARK(GetSuperclass, jclass, (const jclass&)obj);
639 634
640 oop mirror = JNIHandles::resolve_non_null(sub); 635 oop mirror = JNIHandles::resolve_non_null(sub);
663 JNI_QUICK_ENTRY(jboolean, jni_IsAssignableFrom(JNIEnv *env, jclass sub, jclass super)) 658 JNI_QUICK_ENTRY(jboolean, jni_IsAssignableFrom(JNIEnv *env, jclass sub, jclass super))
664 JNIWrapper("IsSubclassOf"); 659 JNIWrapper("IsSubclassOf");
665 #ifndef USDT2 660 #ifndef USDT2
666 DTRACE_PROBE3(hotspot_jni, IsAssignableFrom__entry, env, sub, super); 661 DTRACE_PROBE3(hotspot_jni, IsAssignableFrom__entry, env, sub, super);
667 #else /* USDT2 */ 662 #else /* USDT2 */
668 HOTSPOT_JNI_ISASSIGNABLEFROM_ENTRY( 663 HOTSPOT_JNI_ISASSIGNABLEFROM_ENTRY(env, sub, super);
669 env, sub, super);
670 #endif /* USDT2 */ 664 #endif /* USDT2 */
671 oop sub_mirror = JNIHandles::resolve_non_null(sub); 665 oop sub_mirror = JNIHandles::resolve_non_null(sub);
672 oop super_mirror = JNIHandles::resolve_non_null(super); 666 oop super_mirror = JNIHandles::resolve_non_null(super);
673 if (java_lang_Class::is_primitive(sub_mirror) || 667 if (java_lang_Class::is_primitive(sub_mirror) ||
674 java_lang_Class::is_primitive(super_mirror)) { 668 java_lang_Class::is_primitive(super_mirror)) {
675 jboolean ret = (sub_mirror == super_mirror); 669 jboolean ret = (sub_mirror == super_mirror);
676 #ifndef USDT2 670 #ifndef USDT2
677 DTRACE_PROBE1(hotspot_jni, IsAssignableFrom__return, ret); 671 DTRACE_PROBE1(hotspot_jni, IsAssignableFrom__return, ret);
678 #else /* USDT2 */ 672 #else /* USDT2 */
679 HOTSPOT_JNI_ISASSIGNABLEFROM_RETURN( 673 HOTSPOT_JNI_ISASSIGNABLEFROM_RETURN(ret);
680 ret);
681 #endif /* USDT2 */ 674 #endif /* USDT2 */
682 return ret; 675 return ret;
683 } 676 }
684 Klass* sub_klass = java_lang_Class::as_Klass(sub_mirror); 677 Klass* sub_klass = java_lang_Class::as_Klass(sub_mirror);
685 Klass* super_klass = java_lang_Class::as_Klass(super_mirror); 678 Klass* super_klass = java_lang_Class::as_Klass(super_mirror);
687 jboolean ret = sub_klass->is_subtype_of(super_klass) ? 680 jboolean ret = sub_klass->is_subtype_of(super_klass) ?
688 JNI_TRUE : JNI_FALSE; 681 JNI_TRUE : JNI_FALSE;
689 #ifndef USDT2 682 #ifndef USDT2
690 DTRACE_PROBE1(hotspot_jni, IsAssignableFrom__return, ret); 683 DTRACE_PROBE1(hotspot_jni, IsAssignableFrom__return, ret);
691 #else /* USDT2 */ 684 #else /* USDT2 */
692 HOTSPOT_JNI_ISASSIGNABLEFROM_RETURN( 685 HOTSPOT_JNI_ISASSIGNABLEFROM_RETURN(ret);
693 ret);
694 #endif /* USDT2 */ 686 #endif /* USDT2 */
695 return ret; 687 return ret;
696 JNI_END 688 JNI_END
697 689
698 #ifndef USDT2 690 #ifndef USDT2
705 JNI_ENTRY(jint, jni_Throw(JNIEnv *env, jthrowable obj)) 697 JNI_ENTRY(jint, jni_Throw(JNIEnv *env, jthrowable obj))
706 JNIWrapper("Throw"); 698 JNIWrapper("Throw");
707 #ifndef USDT2 699 #ifndef USDT2
708 DTRACE_PROBE2(hotspot_jni, Throw__entry, env, obj); 700 DTRACE_PROBE2(hotspot_jni, Throw__entry, env, obj);
709 #else /* USDT2 */ 701 #else /* USDT2 */
710 HOTSPOT_JNI_THROW_ENTRY( 702 HOTSPOT_JNI_THROW_ENTRY(env, obj);
711 env, obj);
712 #endif /* USDT2 */ 703 #endif /* USDT2 */
713 jint ret = JNI_OK; 704 jint ret = JNI_OK;
714 DT_RETURN_MARK(Throw, jint, (const jint&)ret); 705 DT_RETURN_MARK(Throw, jint, (const jint&)ret);
715 706
716 THROW_OOP_(JNIHandles::resolve(obj), JNI_OK); 707 THROW_OOP_(JNIHandles::resolve(obj), JNI_OK);
727 JNI_ENTRY(jint, jni_ThrowNew(JNIEnv *env, jclass clazz, const char *message)) 718 JNI_ENTRY(jint, jni_ThrowNew(JNIEnv *env, jclass clazz, const char *message))
728 JNIWrapper("ThrowNew"); 719 JNIWrapper("ThrowNew");
729 #ifndef USDT2 720 #ifndef USDT2
730 DTRACE_PROBE3(hotspot_jni, ThrowNew__entry, env, clazz, message); 721 DTRACE_PROBE3(hotspot_jni, ThrowNew__entry, env, clazz, message);
731 #else /* USDT2 */ 722 #else /* USDT2 */
732 HOTSPOT_JNI_THROWNEW_ENTRY( 723 HOTSPOT_JNI_THROWNEW_ENTRY(env, clazz, (char *) message);
733 env, clazz, (char *) message);
734 #endif /* USDT2 */ 724 #endif /* USDT2 */
735 jint ret = JNI_OK; 725 jint ret = JNI_OK;
736 DT_RETURN_MARK(ThrowNew, jint, (const jint&)ret); 726 DT_RETURN_MARK(ThrowNew, jint, (const jint&)ret);
737 727
738 InstanceKlass* k = InstanceKlass::cast(java_lang_Class::as_Klass(JNIHandles::resolve_non_null(clazz))); 728 InstanceKlass* k = InstanceKlass::cast(java_lang_Class::as_Klass(JNIHandles::resolve_non_null(clazz)));
761 JNI_ENTRY_NO_PRESERVE(jthrowable, jni_ExceptionOccurred(JNIEnv *env)) 751 JNI_ENTRY_NO_PRESERVE(jthrowable, jni_ExceptionOccurred(JNIEnv *env))
762 JNIWrapper("ExceptionOccurred"); 752 JNIWrapper("ExceptionOccurred");
763 #ifndef USDT2 753 #ifndef USDT2
764 DTRACE_PROBE1(hotspot_jni, ExceptionOccurred__entry, env); 754 DTRACE_PROBE1(hotspot_jni, ExceptionOccurred__entry, env);
765 #else /* USDT2 */ 755 #else /* USDT2 */
766 HOTSPOT_JNI_EXCEPTIONOCCURRED_ENTRY( 756 HOTSPOT_JNI_EXCEPTIONOCCURRED_ENTRY(env);
767 env);
768 #endif /* USDT2 */ 757 #endif /* USDT2 */
769 jni_check_async_exceptions(thread); 758 jni_check_async_exceptions(thread);
770 oop exception = thread->pending_exception(); 759 oop exception = thread->pending_exception();
771 jthrowable ret = (jthrowable) JNIHandles::make_local(env, exception); 760 jthrowable ret = (jthrowable) JNIHandles::make_local(env, exception);
772 #ifndef USDT2 761 #ifndef USDT2
773 DTRACE_PROBE1(hotspot_jni, ExceptionOccurred__return, ret); 762 DTRACE_PROBE1(hotspot_jni, ExceptionOccurred__return, ret);
774 #else /* USDT2 */ 763 #else /* USDT2 */
775 HOTSPOT_JNI_EXCEPTIONOCCURRED_RETURN( 764 HOTSPOT_JNI_EXCEPTIONOCCURRED_RETURN(ret);
776 ret);
777 #endif /* USDT2 */ 765 #endif /* USDT2 */
778 return ret; 766 return ret;
779 JNI_END 767 JNI_END
780 768
781 769
782 JNI_ENTRY_NO_PRESERVE(void, jni_ExceptionDescribe(JNIEnv *env)) 770 JNI_ENTRY_NO_PRESERVE(void, jni_ExceptionDescribe(JNIEnv *env))
783 JNIWrapper("ExceptionDescribe"); 771 JNIWrapper("ExceptionDescribe");
784 #ifndef USDT2 772 #ifndef USDT2
785 DTRACE_PROBE1(hotspot_jni, ExceptionDescribe__entry, env); 773 DTRACE_PROBE1(hotspot_jni, ExceptionDescribe__entry, env);
786 #else /* USDT2 */ 774 #else /* USDT2 */
787 HOTSPOT_JNI_EXCEPTIONDESCRIBE_ENTRY( 775 HOTSPOT_JNI_EXCEPTIONDESCRIBE_ENTRY(env);
788 env);
789 #endif /* USDT2 */ 776 #endif /* USDT2 */
790 if (thread->has_pending_exception()) { 777 if (thread->has_pending_exception()) {
791 Handle ex(thread, thread->pending_exception()); 778 Handle ex(thread, thread->pending_exception());
792 thread->clear_pending_exception(); 779 thread->clear_pending_exception();
793 if (ex->is_a(SystemDictionary::ThreadDeath_klass())) { 780 if (ex->is_a(SystemDictionary::ThreadDeath_klass())) {
823 } 810 }
824 } 811 }
825 #ifndef USDT2 812 #ifndef USDT2
826 DTRACE_PROBE(hotspot_jni, ExceptionDescribe__return); 813 DTRACE_PROBE(hotspot_jni, ExceptionDescribe__return);
827 #else /* USDT2 */ 814 #else /* USDT2 */
828 HOTSPOT_JNI_EXCEPTIONDESCRIBE_RETURN( 815 HOTSPOT_JNI_EXCEPTIONDESCRIBE_RETURN();
829 );
830 #endif /* USDT2 */ 816 #endif /* USDT2 */
831 JNI_END 817 JNI_END
832 818
833 819
834 JNI_QUICK_ENTRY(void, jni_ExceptionClear(JNIEnv *env)) 820 JNI_QUICK_ENTRY(void, jni_ExceptionClear(JNIEnv *env))
835 JNIWrapper("ExceptionClear"); 821 JNIWrapper("ExceptionClear");
836 #ifndef USDT2 822 #ifndef USDT2
837 DTRACE_PROBE1(hotspot_jni, ExceptionClear__entry, env); 823 DTRACE_PROBE1(hotspot_jni, ExceptionClear__entry, env);
838 #else /* USDT2 */ 824 #else /* USDT2 */
839 HOTSPOT_JNI_EXCEPTIONCLEAR_ENTRY( 825 HOTSPOT_JNI_EXCEPTIONCLEAR_ENTRY(env);
840 env);
841 #endif /* USDT2 */ 826 #endif /* USDT2 */
842 827
843 // The jni code might be using this API to clear java thrown exception. 828 // The jni code might be using this API to clear java thrown exception.
844 // So just mark jvmti thread exception state as exception caught. 829 // So just mark jvmti thread exception state as exception caught.
845 JvmtiThreadState *state = JavaThread::current()->jvmti_thread_state(); 830 JvmtiThreadState *state = JavaThread::current()->jvmti_thread_state();
848 } 833 }
849 thread->clear_pending_exception(); 834 thread->clear_pending_exception();
850 #ifndef USDT2 835 #ifndef USDT2
851 DTRACE_PROBE(hotspot_jni, ExceptionClear__return); 836 DTRACE_PROBE(hotspot_jni, ExceptionClear__return);
852 #else /* USDT2 */ 837 #else /* USDT2 */
853 HOTSPOT_JNI_EXCEPTIONCLEAR_RETURN( 838 HOTSPOT_JNI_EXCEPTIONCLEAR_RETURN();
854 );
855 #endif /* USDT2 */ 839 #endif /* USDT2 */
856 JNI_END 840 JNI_END
857 841
858 842
859 JNI_ENTRY(void, jni_FatalError(JNIEnv *env, const char *msg)) 843 JNI_ENTRY(void, jni_FatalError(JNIEnv *env, const char *msg))
860 JNIWrapper("FatalError"); 844 JNIWrapper("FatalError");
861 #ifndef USDT2 845 #ifndef USDT2
862 DTRACE_PROBE2(hotspot_jni, FatalError__entry, env, msg); 846 DTRACE_PROBE2(hotspot_jni, FatalError__entry, env, msg);
863 #else /* USDT2 */ 847 #else /* USDT2 */
864 HOTSPOT_JNI_FATALERROR_ENTRY( 848 HOTSPOT_JNI_FATALERROR_ENTRY(env, (char *) msg);
865 env, (char *) msg);
866 #endif /* USDT2 */ 849 #endif /* USDT2 */
867 tty->print_cr("FATAL ERROR in native method: %s", msg); 850 tty->print_cr("FATAL ERROR in native method: %s", msg);
868 thread->print_stack(); 851 thread->print_stack();
869 os::abort(); // Dump core and abort 852 os::abort(); // Dump core and abort
870 JNI_END 853 JNI_END
873 JNI_ENTRY(jint, jni_PushLocalFrame(JNIEnv *env, jint capacity)) 856 JNI_ENTRY(jint, jni_PushLocalFrame(JNIEnv *env, jint capacity))
874 JNIWrapper("PushLocalFrame"); 857 JNIWrapper("PushLocalFrame");
875 #ifndef USDT2 858 #ifndef USDT2
876 DTRACE_PROBE2(hotspot_jni, PushLocalFrame__entry, env, capacity); 859 DTRACE_PROBE2(hotspot_jni, PushLocalFrame__entry, env, capacity);
877 #else /* USDT2 */ 860 #else /* USDT2 */
878 HOTSPOT_JNI_PUSHLOCALFRAME_ENTRY( 861 HOTSPOT_JNI_PUSHLOCALFRAME_ENTRY(env, capacity);
879 env, capacity);
880 #endif /* USDT2 */ 862 #endif /* USDT2 */
881 //%note jni_11 863 //%note jni_11
882 if (capacity < 0 || capacity > MAX_REASONABLE_LOCAL_CAPACITY) { 864 if (capacity < 0 || capacity > MAX_REASONABLE_LOCAL_CAPACITY) {
883 #ifndef USDT2 865 #ifndef USDT2
884 DTRACE_PROBE1(hotspot_jni, PushLocalFrame__return, JNI_ERR); 866 DTRACE_PROBE1(hotspot_jni, PushLocalFrame__return, JNI_ERR);
885 #else /* USDT2 */ 867 #else /* USDT2 */
886 HOTSPOT_JNI_PUSHLOCALFRAME_RETURN( 868 HOTSPOT_JNI_PUSHLOCALFRAME_RETURN((uint32_t)JNI_ERR);
887 (uint32_t)JNI_ERR);
888 #endif /* USDT2 */ 869 #endif /* USDT2 */
889 return JNI_ERR; 870 return JNI_ERR;
890 } 871 }
891 JNIHandleBlock* old_handles = thread->active_handles(); 872 JNIHandleBlock* old_handles = thread->active_handles();
892 JNIHandleBlock* new_handles = JNIHandleBlock::allocate_block(thread); 873 JNIHandleBlock* new_handles = JNIHandleBlock::allocate_block(thread);
895 thread->set_active_handles(new_handles); 876 thread->set_active_handles(new_handles);
896 jint ret = JNI_OK; 877 jint ret = JNI_OK;
897 #ifndef USDT2 878 #ifndef USDT2
898 DTRACE_PROBE1(hotspot_jni, PushLocalFrame__return, ret); 879 DTRACE_PROBE1(hotspot_jni, PushLocalFrame__return, ret);
899 #else /* USDT2 */ 880 #else /* USDT2 */
900 HOTSPOT_JNI_PUSHLOCALFRAME_RETURN( 881 HOTSPOT_JNI_PUSHLOCALFRAME_RETURN(ret);
901 ret);
902 #endif /* USDT2 */ 882 #endif /* USDT2 */
903 return ret; 883 return ret;
904 JNI_END 884 JNI_END
905 885
906 886
907 JNI_ENTRY(jobject, jni_PopLocalFrame(JNIEnv *env, jobject result)) 887 JNI_ENTRY(jobject, jni_PopLocalFrame(JNIEnv *env, jobject result))
908 JNIWrapper("PopLocalFrame"); 888 JNIWrapper("PopLocalFrame");
909 #ifndef USDT2 889 #ifndef USDT2
910 DTRACE_PROBE2(hotspot_jni, PopLocalFrame__entry, env, result); 890 DTRACE_PROBE2(hotspot_jni, PopLocalFrame__entry, env, result);
911 #else /* USDT2 */ 891 #else /* USDT2 */
912 HOTSPOT_JNI_POPLOCALFRAME_ENTRY( 892 HOTSPOT_JNI_POPLOCALFRAME_ENTRY(env, result);
913 env, result);
914 #endif /* USDT2 */ 893 #endif /* USDT2 */
915 //%note jni_11 894 //%note jni_11
916 Handle result_handle(thread, JNIHandles::resolve(result)); 895 Handle result_handle(thread, JNIHandles::resolve(result));
917 JNIHandleBlock* old_handles = thread->active_handles(); 896 JNIHandleBlock* old_handles = thread->active_handles();
918 JNIHandleBlock* new_handles = old_handles->pop_frame_link(); 897 JNIHandleBlock* new_handles = old_handles->pop_frame_link();
927 result = JNIHandles::make_local(thread, result_handle()); 906 result = JNIHandles::make_local(thread, result_handle());
928 } 907 }
929 #ifndef USDT2 908 #ifndef USDT2
930 DTRACE_PROBE1(hotspot_jni, PopLocalFrame__return, result); 909 DTRACE_PROBE1(hotspot_jni, PopLocalFrame__return, result);
931 #else /* USDT2 */ 910 #else /* USDT2 */
932 HOTSPOT_JNI_POPLOCALFRAME_RETURN( 911 HOTSPOT_JNI_POPLOCALFRAME_RETURN(result);
933 result);
934 #endif /* USDT2 */ 912 #endif /* USDT2 */
935 return result; 913 return result;
936 JNI_END 914 JNI_END
937 915
938 916
939 JNI_ENTRY(jobject, jni_NewGlobalRef(JNIEnv *env, jobject ref)) 917 JNI_ENTRY(jobject, jni_NewGlobalRef(JNIEnv *env, jobject ref))
940 JNIWrapper("NewGlobalRef"); 918 JNIWrapper("NewGlobalRef");
941 #ifndef USDT2 919 #ifndef USDT2
942 DTRACE_PROBE2(hotspot_jni, NewGlobalRef__entry, env, ref); 920 DTRACE_PROBE2(hotspot_jni, NewGlobalRef__entry, env, ref);
943 #else /* USDT2 */ 921 #else /* USDT2 */
944 HOTSPOT_JNI_NEWGLOBALREF_ENTRY( 922 HOTSPOT_JNI_NEWGLOBALREF_ENTRY(env, ref);
945 env, ref);
946 #endif /* USDT2 */ 923 #endif /* USDT2 */
947 Handle ref_handle(thread, JNIHandles::resolve(ref)); 924 Handle ref_handle(thread, JNIHandles::resolve(ref));
948 jobject ret = JNIHandles::make_global(ref_handle); 925 jobject ret = JNIHandles::make_global(ref_handle);
949 #ifndef USDT2 926 #ifndef USDT2
950 DTRACE_PROBE1(hotspot_jni, NewGlobalRef__return, ret); 927 DTRACE_PROBE1(hotspot_jni, NewGlobalRef__return, ret);
951 #else /* USDT2 */ 928 #else /* USDT2 */
952 HOTSPOT_JNI_NEWGLOBALREF_RETURN( 929 HOTSPOT_JNI_NEWGLOBALREF_RETURN(ret);
953 ret);
954 #endif /* USDT2 */ 930 #endif /* USDT2 */
955 return ret; 931 return ret;
956 JNI_END 932 JNI_END
957 933
958 // Must be JNI_ENTRY (with HandleMark) 934 // Must be JNI_ENTRY (with HandleMark)
959 JNI_ENTRY_NO_PRESERVE(void, jni_DeleteGlobalRef(JNIEnv *env, jobject ref)) 935 JNI_ENTRY_NO_PRESERVE(void, jni_DeleteGlobalRef(JNIEnv *env, jobject ref))
960 JNIWrapper("DeleteGlobalRef"); 936 JNIWrapper("DeleteGlobalRef");
961 #ifndef USDT2 937 #ifndef USDT2
962 DTRACE_PROBE2(hotspot_jni, DeleteGlobalRef__entry, env, ref); 938 DTRACE_PROBE2(hotspot_jni, DeleteGlobalRef__entry, env, ref);
963 #else /* USDT2 */ 939 #else /* USDT2 */
964 HOTSPOT_JNI_DELETEGLOBALREF_ENTRY( 940 HOTSPOT_JNI_DELETEGLOBALREF_ENTRY(env, ref);
965 env, ref);
966 #endif /* USDT2 */ 941 #endif /* USDT2 */
967 JNIHandles::destroy_global(ref); 942 JNIHandles::destroy_global(ref);
968 #ifndef USDT2 943 #ifndef USDT2
969 DTRACE_PROBE(hotspot_jni, DeleteGlobalRef__return); 944 DTRACE_PROBE(hotspot_jni, DeleteGlobalRef__return);
970 #else /* USDT2 */ 945 #else /* USDT2 */
971 HOTSPOT_JNI_DELETEGLOBALREF_RETURN( 946 HOTSPOT_JNI_DELETEGLOBALREF_RETURN();
972 );
973 #endif /* USDT2 */ 947 #endif /* USDT2 */
974 JNI_END 948 JNI_END
975 949
976 JNI_QUICK_ENTRY(void, jni_DeleteLocalRef(JNIEnv *env, jobject obj)) 950 JNI_QUICK_ENTRY(void, jni_DeleteLocalRef(JNIEnv *env, jobject obj))
977 JNIWrapper("DeleteLocalRef"); 951 JNIWrapper("DeleteLocalRef");
978 #ifndef USDT2 952 #ifndef USDT2
979 DTRACE_PROBE2(hotspot_jni, DeleteLocalRef__entry, env, obj); 953 DTRACE_PROBE2(hotspot_jni, DeleteLocalRef__entry, env, obj);
980 #else /* USDT2 */ 954 #else /* USDT2 */
981 HOTSPOT_JNI_DELETELOCALREF_ENTRY( 955 HOTSPOT_JNI_DELETELOCALREF_ENTRY(env, obj);
982 env, obj);
983 #endif /* USDT2 */ 956 #endif /* USDT2 */
984 JNIHandles::destroy_local(obj); 957 JNIHandles::destroy_local(obj);
985 #ifndef USDT2 958 #ifndef USDT2
986 DTRACE_PROBE(hotspot_jni, DeleteLocalRef__return); 959 DTRACE_PROBE(hotspot_jni, DeleteLocalRef__return);
987 #else /* USDT2 */ 960 #else /* USDT2 */
988 HOTSPOT_JNI_DELETELOCALREF_RETURN( 961 HOTSPOT_JNI_DELETELOCALREF_RETURN();
989 );
990 #endif /* USDT2 */ 962 #endif /* USDT2 */
991 JNI_END 963 JNI_END
992 964
993 JNI_QUICK_ENTRY(jboolean, jni_IsSameObject(JNIEnv *env, jobject r1, jobject r2)) 965 JNI_QUICK_ENTRY(jboolean, jni_IsSameObject(JNIEnv *env, jobject r1, jobject r2))
994 JNIWrapper("IsSameObject"); 966 JNIWrapper("IsSameObject");
995 #ifndef USDT2 967 #ifndef USDT2
996 DTRACE_PROBE3(hotspot_jni, IsSameObject__entry, env, r1, r2); 968 DTRACE_PROBE3(hotspot_jni, IsSameObject__entry, env, r1, r2);
997 #else /* USDT2 */ 969 #else /* USDT2 */
998 HOTSPOT_JNI_ISSAMEOBJECT_ENTRY( 970 HOTSPOT_JNI_ISSAMEOBJECT_ENTRY(env, r1, r2);
999 env, r1, r2);
1000 #endif /* USDT2 */ 971 #endif /* USDT2 */
1001 oop a = JNIHandles::resolve(r1); 972 oop a = JNIHandles::resolve(r1);
1002 oop b = JNIHandles::resolve(r2); 973 oop b = JNIHandles::resolve(r2);
1003 jboolean ret = (a == b) ? JNI_TRUE : JNI_FALSE; 974 jboolean ret = (a == b) ? JNI_TRUE : JNI_FALSE;
1004 #ifndef USDT2 975 #ifndef USDT2
1005 DTRACE_PROBE1(hotspot_jni, IsSameObject__return, ret); 976 DTRACE_PROBE1(hotspot_jni, IsSameObject__return, ret);
1006 #else /* USDT2 */ 977 #else /* USDT2 */
1007 HOTSPOT_JNI_ISSAMEOBJECT_RETURN( 978 HOTSPOT_JNI_ISSAMEOBJECT_RETURN(ret);
1008 ret);
1009 #endif /* USDT2 */ 979 #endif /* USDT2 */
1010 return ret; 980 return ret;
1011 JNI_END 981 JNI_END
1012 982
1013 983
1014 JNI_ENTRY(jobject, jni_NewLocalRef(JNIEnv *env, jobject ref)) 984 JNI_ENTRY(jobject, jni_NewLocalRef(JNIEnv *env, jobject ref))
1015 JNIWrapper("NewLocalRef"); 985 JNIWrapper("NewLocalRef");
1016 #ifndef USDT2 986 #ifndef USDT2
1017 DTRACE_PROBE2(hotspot_jni, NewLocalRef__entry, env, ref); 987 DTRACE_PROBE2(hotspot_jni, NewLocalRef__entry, env, ref);
1018 #else /* USDT2 */ 988 #else /* USDT2 */
1019 HOTSPOT_JNI_NEWLOCALREF_ENTRY( 989 HOTSPOT_JNI_NEWLOCALREF_ENTRY(env, ref);
1020 env, ref);
1021 #endif /* USDT2 */ 990 #endif /* USDT2 */
1022 jobject ret = JNIHandles::make_local(env, JNIHandles::resolve(ref)); 991 jobject ret = JNIHandles::make_local(env, JNIHandles::resolve(ref));
1023 #ifndef USDT2 992 #ifndef USDT2
1024 DTRACE_PROBE1(hotspot_jni, NewLocalRef__return, ret); 993 DTRACE_PROBE1(hotspot_jni, NewLocalRef__return, ret);
1025 #else /* USDT2 */ 994 #else /* USDT2 */
1026 HOTSPOT_JNI_NEWLOCALREF_RETURN( 995 HOTSPOT_JNI_NEWLOCALREF_RETURN(ret);
1027 ret);
1028 #endif /* USDT2 */ 996 #endif /* USDT2 */
1029 return ret; 997 return ret;
1030 JNI_END 998 JNI_END
1031 999
1032 JNI_LEAF(jint, jni_EnsureLocalCapacity(JNIEnv *env, jint capacity)) 1000 JNI_LEAF(jint, jni_EnsureLocalCapacity(JNIEnv *env, jint capacity))
1033 JNIWrapper("EnsureLocalCapacity"); 1001 JNIWrapper("EnsureLocalCapacity");
1034 #ifndef USDT2 1002 #ifndef USDT2
1035 DTRACE_PROBE2(hotspot_jni, EnsureLocalCapacity__entry, env, capacity); 1003 DTRACE_PROBE2(hotspot_jni, EnsureLocalCapacity__entry, env, capacity);
1036 #else /* USDT2 */ 1004 #else /* USDT2 */
1037 HOTSPOT_JNI_ENSURELOCALCAPACITY_ENTRY( 1005 HOTSPOT_JNI_ENSURELOCALCAPACITY_ENTRY(env, capacity);
1038 env, capacity);
1039 #endif /* USDT2 */ 1006 #endif /* USDT2 */
1040 jint ret; 1007 jint ret;
1041 if (capacity >= 0 && capacity <= MAX_REASONABLE_LOCAL_CAPACITY) { 1008 if (capacity >= 0 && capacity <= MAX_REASONABLE_LOCAL_CAPACITY) {
1042 ret = JNI_OK; 1009 ret = JNI_OK;
1043 } else { 1010 } else {
1044 ret = JNI_ERR; 1011 ret = JNI_ERR;
1045 } 1012 }
1046 #ifndef USDT2 1013 #ifndef USDT2
1047 DTRACE_PROBE1(hotspot_jni, EnsureLocalCapacity__return, ret); 1014 DTRACE_PROBE1(hotspot_jni, EnsureLocalCapacity__return, ret);
1048 #else /* USDT2 */ 1015 #else /* USDT2 */
1049 HOTSPOT_JNI_ENSURELOCALCAPACITY_RETURN( 1016 HOTSPOT_JNI_ENSURELOCALCAPACITY_RETURN(ret);
1050 ret);
1051 #endif /* USDT2 */ 1017 #endif /* USDT2 */
1052 return ret; 1018 return ret;
1053 JNI_END 1019 JNI_END
1054 1020
1055 // Return the Handle Type 1021 // Return the Handle Type
1056 JNI_LEAF(jobjectRefType, jni_GetObjectRefType(JNIEnv *env, jobject obj)) 1022 JNI_LEAF(jobjectRefType, jni_GetObjectRefType(JNIEnv *env, jobject obj))
1057 JNIWrapper("GetObjectRefType"); 1023 JNIWrapper("GetObjectRefType");
1058 #ifndef USDT2 1024 #ifndef USDT2
1059 DTRACE_PROBE2(hotspot_jni, GetObjectRefType__entry, env, obj); 1025 DTRACE_PROBE2(hotspot_jni, GetObjectRefType__entry, env, obj);
1060 #else /* USDT2 */ 1026 #else /* USDT2 */
1061 HOTSPOT_JNI_GETOBJECTREFTYPE_ENTRY( 1027 HOTSPOT_JNI_GETOBJECTREFTYPE_ENTRY(env, obj);
1062 env, obj);
1063 #endif /* USDT2 */ 1028 #endif /* USDT2 */
1064 jobjectRefType ret; 1029 jobjectRefType ret;
1065 if (JNIHandles::is_local_handle(thread, obj) || 1030 if (JNIHandles::is_local_handle(thread, obj) ||
1066 JNIHandles::is_frame_handle(thread, obj)) 1031 JNIHandles::is_frame_handle(thread, obj))
1067 ret = JNILocalRefType; 1032 ret = JNILocalRefType;
1072 else 1037 else
1073 ret = JNIInvalidRefType; 1038 ret = JNIInvalidRefType;
1074 #ifndef USDT2 1039 #ifndef USDT2
1075 DTRACE_PROBE1(hotspot_jni, GetObjectRefType__return, ret); 1040 DTRACE_PROBE1(hotspot_jni, GetObjectRefType__return, ret);
1076 #else /* USDT2 */ 1041 #else /* USDT2 */
1077 HOTSPOT_JNI_GETOBJECTREFTYPE_RETURN( 1042 HOTSPOT_JNI_GETOBJECTREFTYPE_RETURN((void *) ret);
1078 (void *) ret);
1079 #endif /* USDT2 */ 1043 #endif /* USDT2 */
1080 return ret; 1044 return ret;
1081 JNI_END 1045 JNI_END
1082 1046
1083 1047
1408 JNIWrapper("AllocObject"); 1372 JNIWrapper("AllocObject");
1409 1373
1410 #ifndef USDT2 1374 #ifndef USDT2
1411 DTRACE_PROBE2(hotspot_jni, AllocObject__entry, env, clazz); 1375 DTRACE_PROBE2(hotspot_jni, AllocObject__entry, env, clazz);
1412 #else /* USDT2 */ 1376 #else /* USDT2 */
1413 HOTSPOT_JNI_ALLOCOBJECT_ENTRY( 1377 HOTSPOT_JNI_ALLOCOBJECT_ENTRY(env, clazz);
1414 env, clazz);
1415 #endif /* USDT2 */ 1378 #endif /* USDT2 */
1416 jobject ret = NULL; 1379 jobject ret = NULL;
1417 DT_RETURN_MARK(AllocObject, jobject, (const jobject&)ret); 1380 DT_RETURN_MARK(AllocObject, jobject, (const jobject&)ret);
1418 1381
1419 instanceOop i = alloc_object(clazz, CHECK_NULL); 1382 instanceOop i = alloc_object(clazz, CHECK_NULL);
1431 JNI_ENTRY(jobject, jni_NewObjectA(JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args)) 1394 JNI_ENTRY(jobject, jni_NewObjectA(JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args))
1432 JNIWrapper("NewObjectA"); 1395 JNIWrapper("NewObjectA");
1433 #ifndef USDT2 1396 #ifndef USDT2
1434 DTRACE_PROBE3(hotspot_jni, NewObjectA__entry, env, clazz, methodID); 1397 DTRACE_PROBE3(hotspot_jni, NewObjectA__entry, env, clazz, methodID);
1435 #else /* USDT2 */ 1398 #else /* USDT2 */
1436 HOTSPOT_JNI_NEWOBJECTA_ENTRY( 1399 HOTSPOT_JNI_NEWOBJECTA_ENTRY(env, clazz, (uintptr_t) methodID);
1437 env, clazz, (uintptr_t) methodID);
1438 #endif /* USDT2 */ 1400 #endif /* USDT2 */
1439 jobject obj = NULL; 1401 jobject obj = NULL;
1440 DT_RETURN_MARK(NewObjectA, jobject, (const jobject)obj); 1402 DT_RETURN_MARK(NewObjectA, jobject, (const jobject)obj);
1441 1403
1442 instanceOop i = alloc_object(clazz, CHECK_NULL); 1404 instanceOop i = alloc_object(clazz, CHECK_NULL);
1457 JNI_ENTRY(jobject, jni_NewObjectV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)) 1419 JNI_ENTRY(jobject, jni_NewObjectV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args))
1458 JNIWrapper("NewObjectV"); 1420 JNIWrapper("NewObjectV");
1459 #ifndef USDT2 1421 #ifndef USDT2
1460 DTRACE_PROBE3(hotspot_jni, NewObjectV__entry, env, clazz, methodID); 1422 DTRACE_PROBE3(hotspot_jni, NewObjectV__entry, env, clazz, methodID);
1461 #else /* USDT2 */ 1423 #else /* USDT2 */
1462 HOTSPOT_JNI_NEWOBJECTV_ENTRY( 1424 HOTSPOT_JNI_NEWOBJECTV_ENTRY(env, clazz, (uintptr_t) methodID);
1463 env, clazz, (uintptr_t) methodID);
1464 #endif /* USDT2 */ 1425 #endif /* USDT2 */
1465 jobject obj = NULL; 1426 jobject obj = NULL;
1466 DT_RETURN_MARK(NewObjectV, jobject, (const jobject&)obj); 1427 DT_RETURN_MARK(NewObjectV, jobject, (const jobject&)obj);
1467 1428
1468 instanceOop i = alloc_object(clazz, CHECK_NULL); 1429 instanceOop i = alloc_object(clazz, CHECK_NULL);
1483 JNI_ENTRY(jobject, jni_NewObject(JNIEnv *env, jclass clazz, jmethodID methodID, ...)) 1444 JNI_ENTRY(jobject, jni_NewObject(JNIEnv *env, jclass clazz, jmethodID methodID, ...))
1484 JNIWrapper("NewObject"); 1445 JNIWrapper("NewObject");
1485 #ifndef USDT2 1446 #ifndef USDT2
1486 DTRACE_PROBE3(hotspot_jni, NewObject__entry, env, clazz, methodID); 1447 DTRACE_PROBE3(hotspot_jni, NewObject__entry, env, clazz, methodID);
1487 #else /* USDT2 */ 1448 #else /* USDT2 */
1488 HOTSPOT_JNI_NEWOBJECT_ENTRY( 1449 HOTSPOT_JNI_NEWOBJECT_ENTRY(env, clazz, (uintptr_t) methodID);
1489 env, clazz, (uintptr_t) methodID);
1490 #endif /* USDT2 */ 1450 #endif /* USDT2 */
1491 jobject obj = NULL; 1451 jobject obj = NULL;
1492 DT_RETURN_MARK(NewObject, jobject, (const jobject&)obj); 1452 DT_RETURN_MARK(NewObject, jobject, (const jobject&)obj);
1493 1453
1494 instanceOop i = alloc_object(clazz, CHECK_NULL); 1454 instanceOop i = alloc_object(clazz, CHECK_NULL);
1506 JNI_ENTRY(jclass, jni_GetObjectClass(JNIEnv *env, jobject obj)) 1466 JNI_ENTRY(jclass, jni_GetObjectClass(JNIEnv *env, jobject obj))
1507 JNIWrapper("GetObjectClass"); 1467 JNIWrapper("GetObjectClass");
1508 #ifndef USDT2 1468 #ifndef USDT2
1509 DTRACE_PROBE2(hotspot_jni, GetObjectClass__entry, env, obj); 1469 DTRACE_PROBE2(hotspot_jni, GetObjectClass__entry, env, obj);
1510 #else /* USDT2 */ 1470 #else /* USDT2 */
1511 HOTSPOT_JNI_GETOBJECTCLASS_ENTRY( 1471 HOTSPOT_JNI_GETOBJECTCLASS_ENTRY(env, obj);
1512 env, obj);
1513 #endif /* USDT2 */ 1472 #endif /* USDT2 */
1514 Klass* k = JNIHandles::resolve_non_null(obj)->klass(); 1473 Klass* k = JNIHandles::resolve_non_null(obj)->klass();
1515 jclass ret = 1474 jclass ret =
1516 (jclass) JNIHandles::make_local(env, k->java_mirror()); 1475 (jclass) JNIHandles::make_local(env, k->java_mirror());
1517 #ifndef USDT2 1476 #ifndef USDT2
1518 DTRACE_PROBE1(hotspot_jni, GetObjectClass__return, ret); 1477 DTRACE_PROBE1(hotspot_jni, GetObjectClass__return, ret);
1519 #else /* USDT2 */ 1478 #else /* USDT2 */
1520 HOTSPOT_JNI_GETOBJECTCLASS_RETURN( 1479 HOTSPOT_JNI_GETOBJECTCLASS_RETURN(ret);
1521 ret);
1522 #endif /* USDT2 */ 1480 #endif /* USDT2 */
1523 return ret; 1481 return ret;
1524 JNI_END 1482 JNI_END
1525 1483
1526 JNI_QUICK_ENTRY(jboolean, jni_IsInstanceOf(JNIEnv *env, jobject obj, jclass clazz)) 1484 JNI_QUICK_ENTRY(jboolean, jni_IsInstanceOf(JNIEnv *env, jobject obj, jclass clazz))
1527 JNIWrapper("IsInstanceOf"); 1485 JNIWrapper("IsInstanceOf");
1528 #ifndef USDT2 1486 #ifndef USDT2
1529 DTRACE_PROBE3(hotspot_jni, IsInstanceOf__entry, env, obj, clazz); 1487 DTRACE_PROBE3(hotspot_jni, IsInstanceOf__entry, env, obj, clazz);
1530 #else /* USDT2 */ 1488 #else /* USDT2 */
1531 HOTSPOT_JNI_ISINSTANCEOF_ENTRY( 1489 HOTSPOT_JNI_ISINSTANCEOF_ENTRY(env, obj, clazz);
1532 env, obj, clazz);
1533 #endif /* USDT2 */ 1490 #endif /* USDT2 */
1534 jboolean ret = JNI_TRUE; 1491 jboolean ret = JNI_TRUE;
1535 if (obj != NULL) { 1492 if (obj != NULL) {
1536 ret = JNI_FALSE; 1493 ret = JNI_FALSE;
1537 Klass* k = java_lang_Class::as_Klass( 1494 Klass* k = java_lang_Class::as_Klass(
1541 } 1498 }
1542 } 1499 }
1543 #ifndef USDT2 1500 #ifndef USDT2
1544 DTRACE_PROBE1(hotspot_jni, IsInstanceOf__return, ret); 1501 DTRACE_PROBE1(hotspot_jni, IsInstanceOf__return, ret);
1545 #else /* USDT2 */ 1502 #else /* USDT2 */
1546 HOTSPOT_JNI_ISINSTANCEOF_RETURN( 1503 HOTSPOT_JNI_ISINSTANCEOF_RETURN(ret);
1547 ret);
1548 #endif /* USDT2 */ 1504 #endif /* USDT2 */
1549 return ret; 1505 return ret;
1550 JNI_END 1506 JNI_END
1551 1507
1552 1508
1606 const char *name, const char *sig)) 1562 const char *name, const char *sig))
1607 JNIWrapper("GetMethodID"); 1563 JNIWrapper("GetMethodID");
1608 #ifndef USDT2 1564 #ifndef USDT2
1609 DTRACE_PROBE4(hotspot_jni, GetMethodID__entry, env, clazz, name, sig); 1565 DTRACE_PROBE4(hotspot_jni, GetMethodID__entry, env, clazz, name, sig);
1610 #else /* USDT2 */ 1566 #else /* USDT2 */
1611 HOTSPOT_JNI_GETMETHODID_ENTRY( 1567 HOTSPOT_JNI_GETMETHODID_ENTRY(env, clazz, (char *) name, (char *) sig);
1612 env, clazz, (char *) name, (char *) sig);
1613 #endif /* USDT2 */ 1568 #endif /* USDT2 */
1614 jmethodID ret = get_method_id(env, clazz, name, sig, false, thread); 1569 jmethodID ret = get_method_id(env, clazz, name, sig, false, thread);
1615 #ifndef USDT2 1570 #ifndef USDT2
1616 DTRACE_PROBE1(hotspot_jni, GetMethodID__return, ret); 1571 DTRACE_PROBE1(hotspot_jni, GetMethodID__return, ret);
1617 #else /* USDT2 */ 1572 #else /* USDT2 */
1618 HOTSPOT_JNI_GETMETHODID_RETURN( 1573 HOTSPOT_JNI_GETMETHODID_RETURN((uintptr_t) ret);
1619 (uintptr_t) ret);
1620 #endif /* USDT2 */ 1574 #endif /* USDT2 */
1621 return ret; 1575 return ret;
1622 JNI_END 1576 JNI_END
1623 1577
1624 1578
1626 const char *name, const char *sig)) 1580 const char *name, const char *sig))
1627 JNIWrapper("GetStaticMethodID"); 1581 JNIWrapper("GetStaticMethodID");
1628 #ifndef USDT2 1582 #ifndef USDT2
1629 DTRACE_PROBE4(hotspot_jni, GetStaticMethodID__entry, env, clazz, name, sig); 1583 DTRACE_PROBE4(hotspot_jni, GetStaticMethodID__entry, env, clazz, name, sig);
1630 #else /* USDT2 */ 1584 #else /* USDT2 */
1631 HOTSPOT_JNI_GETSTATICMETHODID_ENTRY( 1585 HOTSPOT_JNI_GETSTATICMETHODID_ENTRY(env, (char *) clazz, (char *) name, (char *)sig);
1632 env, (char *) clazz, (char *) name, (char *)sig);
1633 #endif /* USDT2 */ 1586 #endif /* USDT2 */
1634 jmethodID ret = get_method_id(env, clazz, name, sig, true, thread); 1587 jmethodID ret = get_method_id(env, clazz, name, sig, true, thread);
1635 #ifndef USDT2 1588 #ifndef USDT2
1636 DTRACE_PROBE1(hotspot_jni, GetStaticMethodID__return, ret); 1589 DTRACE_PROBE1(hotspot_jni, GetStaticMethodID__return, ret);
1637 #else /* USDT2 */ 1590 #else /* USDT2 */
1638 HOTSPOT_JNI_GETSTATICMETHODID_RETURN( 1591 HOTSPOT_JNI_GETSTATICMETHODID_RETURN((uintptr_t) ret);
1639 (uintptr_t) ret);
1640 #endif /* USDT2 */ 1592 #endif /* USDT2 */
1641 return ret; 1593 return ret;
1642 JNI_END 1594 JNI_END
1643 1595
1644 1596
1894 JNI_ENTRY(void, jni_CallVoidMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)) 1846 JNI_ENTRY(void, jni_CallVoidMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...))
1895 JNIWrapper("CallVoidMethod"); 1847 JNIWrapper("CallVoidMethod");
1896 #ifndef USDT2 1848 #ifndef USDT2
1897 DTRACE_PROBE3(hotspot_jni, CallVoidMethod__entry, env, obj, methodID); 1849 DTRACE_PROBE3(hotspot_jni, CallVoidMethod__entry, env, obj, methodID);
1898 #else /* USDT2 */ 1850 #else /* USDT2 */
1899 HOTSPOT_JNI_CALLVOIDMETHOD_ENTRY( 1851 HOTSPOT_JNI_CALLVOIDMETHOD_ENTRY(env, obj, (uintptr_t) methodID);
1900 env, obj, (uintptr_t) methodID);
1901 #endif /* USDT2 */ 1852 #endif /* USDT2 */
1902 DT_VOID_RETURN_MARK(CallVoidMethod); 1853 DT_VOID_RETURN_MARK(CallVoidMethod);
1903 1854
1904 va_list args; 1855 va_list args;
1905 va_start(args, methodID); 1856 va_start(args, methodID);
1913 JNI_ENTRY(void, jni_CallVoidMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)) 1864 JNI_ENTRY(void, jni_CallVoidMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args))
1914 JNIWrapper("CallVoidMethodV"); 1865 JNIWrapper("CallVoidMethodV");
1915 #ifndef USDT2 1866 #ifndef USDT2
1916 DTRACE_PROBE3(hotspot_jni, CallVoidMethodV__entry, env, obj, methodID); 1867 DTRACE_PROBE3(hotspot_jni, CallVoidMethodV__entry, env, obj, methodID);
1917 #else /* USDT2 */ 1868 #else /* USDT2 */
1918 HOTSPOT_JNI_CALLVOIDMETHODV_ENTRY( 1869 HOTSPOT_JNI_CALLVOIDMETHODV_ENTRY(env, obj, (uintptr_t) methodID);
1919 env, obj, (uintptr_t) methodID);
1920 #endif /* USDT2 */ 1870 #endif /* USDT2 */
1921 DT_VOID_RETURN_MARK(CallVoidMethodV); 1871 DT_VOID_RETURN_MARK(CallVoidMethodV);
1922 1872
1923 JavaValue jvalue(T_VOID); 1873 JavaValue jvalue(T_VOID);
1924 JNI_ArgumentPusherVaArg ap(methodID, args); 1874 JNI_ArgumentPusherVaArg ap(methodID, args);
1929 JNI_ENTRY(void, jni_CallVoidMethodA(JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args)) 1879 JNI_ENTRY(void, jni_CallVoidMethodA(JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args))
1930 JNIWrapper("CallVoidMethodA"); 1880 JNIWrapper("CallVoidMethodA");
1931 #ifndef USDT2 1881 #ifndef USDT2
1932 DTRACE_PROBE3(hotspot_jni, CallVoidMethodA__entry, env, obj, methodID); 1882 DTRACE_PROBE3(hotspot_jni, CallVoidMethodA__entry, env, obj, methodID);
1933 #else /* USDT2 */ 1883 #else /* USDT2 */
1934 HOTSPOT_JNI_CALLVOIDMETHODA_ENTRY( 1884 HOTSPOT_JNI_CALLVOIDMETHODA_ENTRY(env, obj, (uintptr_t) methodID);
1935 env, obj, (uintptr_t) methodID);
1936 #endif /* USDT2 */ 1885 #endif /* USDT2 */
1937 DT_VOID_RETURN_MARK(CallVoidMethodA); 1886 DT_VOID_RETURN_MARK(CallVoidMethodA);
1938 1887
1939 JavaValue jvalue(T_VOID); 1888 JavaValue jvalue(T_VOID);
1940 JNI_ArgumentPusherArray ap(methodID, args); 1889 JNI_ArgumentPusherArray ap(methodID, args);
2192 2141
2193 #ifndef USDT2 2142 #ifndef USDT2
2194 DTRACE_PROBE4(hotspot_jni, CallNonvirtualVoidMethod__entry, 2143 DTRACE_PROBE4(hotspot_jni, CallNonvirtualVoidMethod__entry,
2195 env, obj, cls, methodID); 2144 env, obj, cls, methodID);
2196 #else /* USDT2 */ 2145 #else /* USDT2 */
2197 HOTSPOT_JNI_CALLNONVIRTUALVOIDMETHOD_ENTRY( 2146 HOTSPOT_JNI_CALLNONVIRTUALVOIDMETHOD_ENTRY(env, obj, cls, (uintptr_t) methodID);
2198 env, obj, cls, (uintptr_t) methodID);
2199 #endif /* USDT2 */ 2147 #endif /* USDT2 */
2200 DT_VOID_RETURN_MARK(CallNonvirtualVoidMethod); 2148 DT_VOID_RETURN_MARK(CallNonvirtualVoidMethod);
2201 2149
2202 va_list args; 2150 va_list args;
2203 va_start(args, methodID); 2151 va_start(args, methodID);
2494 JNI_ENTRY(void, jni_CallStaticVoidMethod(JNIEnv *env, jclass cls, jmethodID methodID, ...)) 2442 JNI_ENTRY(void, jni_CallStaticVoidMethod(JNIEnv *env, jclass cls, jmethodID methodID, ...))
2495 JNIWrapper("CallStaticVoidMethod"); 2443 JNIWrapper("CallStaticVoidMethod");
2496 #ifndef USDT2 2444 #ifndef USDT2
2497 DTRACE_PROBE3(hotspot_jni, CallStaticVoidMethod__entry, env, cls, methodID); 2445 DTRACE_PROBE3(hotspot_jni, CallStaticVoidMethod__entry, env, cls, methodID);
2498 #else /* USDT2 */ 2446 #else /* USDT2 */
2499 HOTSPOT_JNI_CALLSTATICVOIDMETHOD_ENTRY( 2447 HOTSPOT_JNI_CALLSTATICVOIDMETHOD_ENTRY(env, cls, (uintptr_t) methodID);
2500 env, cls, (uintptr_t) methodID);
2501 #endif /* USDT2 */ 2448 #endif /* USDT2 */
2502 DT_VOID_RETURN_MARK(CallStaticVoidMethod); 2449 DT_VOID_RETURN_MARK(CallStaticVoidMethod);
2503 2450
2504 va_list args; 2451 va_list args;
2505 va_start(args, methodID); 2452 va_start(args, methodID);
2513 JNI_ENTRY(void, jni_CallStaticVoidMethodV(JNIEnv *env, jclass cls, jmethodID methodID, va_list args)) 2460 JNI_ENTRY(void, jni_CallStaticVoidMethodV(JNIEnv *env, jclass cls, jmethodID methodID, va_list args))
2514 JNIWrapper("CallStaticVoidMethodV"); 2461 JNIWrapper("CallStaticVoidMethodV");
2515 #ifndef USDT2 2462 #ifndef USDT2
2516 DTRACE_PROBE3(hotspot_jni, CallStaticVoidMethodV__entry, env, cls, methodID); 2463 DTRACE_PROBE3(hotspot_jni, CallStaticVoidMethodV__entry, env, cls, methodID);
2517 #else /* USDT2 */ 2464 #else /* USDT2 */
2518 HOTSPOT_JNI_CALLSTATICVOIDMETHODV_ENTRY( 2465 HOTSPOT_JNI_CALLSTATICVOIDMETHODV_ENTRY(env, cls, (uintptr_t) methodID);
2519 env, cls, (uintptr_t) methodID);
2520 #endif /* USDT2 */ 2466 #endif /* USDT2 */
2521 DT_VOID_RETURN_MARK(CallStaticVoidMethodV); 2467 DT_VOID_RETURN_MARK(CallStaticVoidMethodV);
2522 2468
2523 JavaValue jvalue(T_VOID); 2469 JavaValue jvalue(T_VOID);
2524 JNI_ArgumentPusherVaArg ap(methodID, args); 2470 JNI_ArgumentPusherVaArg ap(methodID, args);
2529 JNI_ENTRY(void, jni_CallStaticVoidMethodA(JNIEnv *env, jclass cls, jmethodID methodID, const jvalue *args)) 2475 JNI_ENTRY(void, jni_CallStaticVoidMethodA(JNIEnv *env, jclass cls, jmethodID methodID, const jvalue *args))
2530 JNIWrapper("CallStaticVoidMethodA"); 2476 JNIWrapper("CallStaticVoidMethodA");
2531 #ifndef USDT2 2477 #ifndef USDT2
2532 DTRACE_PROBE3(hotspot_jni, CallStaticVoidMethodA__entry, env, cls, methodID); 2478 DTRACE_PROBE3(hotspot_jni, CallStaticVoidMethodA__entry, env, cls, methodID);
2533 #else /* USDT2 */ 2479 #else /* USDT2 */
2534 HOTSPOT_JNI_CALLSTATICVOIDMETHODA_ENTRY( 2480 HOTSPOT_JNI_CALLSTATICVOIDMETHODA_ENTRY(env, cls, (uintptr_t) methodID);
2535 env, cls, (uintptr_t) methodID);
2536 #endif /* USDT2 */ 2481 #endif /* USDT2 */
2537 DT_VOID_RETURN_MARK(CallStaticVoidMethodA); 2482 DT_VOID_RETURN_MARK(CallStaticVoidMethodA);
2538 2483
2539 JavaValue jvalue(T_VOID); 2484 JavaValue jvalue(T_VOID);
2540 JNI_ArgumentPusherArray ap(methodID, args); 2485 JNI_ArgumentPusherArray ap(methodID, args);
2558 const char *name, const char *sig)) 2503 const char *name, const char *sig))
2559 JNIWrapper("GetFieldID"); 2504 JNIWrapper("GetFieldID");
2560 #ifndef USDT2 2505 #ifndef USDT2
2561 DTRACE_PROBE4(hotspot_jni, GetFieldID__entry, env, clazz, name, sig); 2506 DTRACE_PROBE4(hotspot_jni, GetFieldID__entry, env, clazz, name, sig);
2562 #else /* USDT2 */ 2507 #else /* USDT2 */
2563 HOTSPOT_JNI_GETFIELDID_ENTRY( 2508 HOTSPOT_JNI_GETFIELDID_ENTRY(env, clazz, (char *) name, (char *) sig);
2564 env, clazz, (char *) name, (char *) sig);
2565 #endif /* USDT2 */ 2509 #endif /* USDT2 */
2566 jfieldID ret = 0; 2510 jfieldID ret = 0;
2567 DT_RETURN_MARK(GetFieldID, jfieldID, (const jfieldID&)ret); 2511 DT_RETURN_MARK(GetFieldID, jfieldID, (const jfieldID&)ret);
2568 2512
2569 // The class should have been loaded (we have an instance of the class 2513 // The class should have been loaded (we have an instance of the class
2595 JNI_ENTRY(jobject, jni_GetObjectField(JNIEnv *env, jobject obj, jfieldID fieldID)) 2539 JNI_ENTRY(jobject, jni_GetObjectField(JNIEnv *env, jobject obj, jfieldID fieldID))
2596 JNIWrapper("GetObjectField"); 2540 JNIWrapper("GetObjectField");
2597 #ifndef USDT2 2541 #ifndef USDT2
2598 DTRACE_PROBE3(hotspot_jni, GetObjectField__entry, env, obj, fieldID); 2542 DTRACE_PROBE3(hotspot_jni, GetObjectField__entry, env, obj, fieldID);
2599 #else /* USDT2 */ 2543 #else /* USDT2 */
2600 HOTSPOT_JNI_GETOBJECTFIELD_ENTRY( 2544 HOTSPOT_JNI_GETOBJECTFIELD_ENTRY(env, obj, (uintptr_t) fieldID);
2601 env, obj, (uintptr_t) fieldID);
2602 #endif /* USDT2 */ 2545 #endif /* USDT2 */
2603 oop o = JNIHandles::resolve_non_null(obj); 2546 oop o = JNIHandles::resolve_non_null(obj);
2604 Klass* k = o->klass(); 2547 Klass* k = o->klass();
2605 int offset = jfieldIDWorkaround::from_instance_jfieldID(k, fieldID); 2548 int offset = jfieldIDWorkaround::from_instance_jfieldID(k, fieldID);
2606 // Keep JVMTI addition small and only check enabled flag here. 2549 // Keep JVMTI addition small and only check enabled flag here.
2630 } 2573 }
2631 #endif // INCLUDE_ALL_GCS 2574 #endif // INCLUDE_ALL_GCS
2632 #ifndef USDT2 2575 #ifndef USDT2
2633 DTRACE_PROBE1(hotspot_jni, GetObjectField__return, ret); 2576 DTRACE_PROBE1(hotspot_jni, GetObjectField__return, ret);
2634 #else /* USDT2 */ 2577 #else /* USDT2 */
2635 HOTSPOT_JNI_GETOBJECTFIELD_RETURN( 2578 HOTSPOT_JNI_GETOBJECTFIELD_RETURN(ret);
2636 ret);
2637 #endif /* USDT2 */ 2579 #endif /* USDT2 */
2638 return ret; 2580 return ret;
2639 JNI_END 2581 JNI_END
2640 2582
2641 2583
2756 JNI_QUICK_ENTRY(void, jni_SetObjectField(JNIEnv *env, jobject obj, jfieldID fieldID, jobject value)) 2698 JNI_QUICK_ENTRY(void, jni_SetObjectField(JNIEnv *env, jobject obj, jfieldID fieldID, jobject value))
2757 JNIWrapper("SetObjectField"); 2699 JNIWrapper("SetObjectField");
2758 #ifndef USDT2 2700 #ifndef USDT2
2759 DTRACE_PROBE4(hotspot_jni, SetObjectField__entry, env, obj, fieldID, value); 2701 DTRACE_PROBE4(hotspot_jni, SetObjectField__entry, env, obj, fieldID, value);
2760 #else /* USDT2 */ 2702 #else /* USDT2 */
2761 HOTSPOT_JNI_SETOBJECTFIELD_ENTRY( 2703 HOTSPOT_JNI_SETOBJECTFIELD_ENTRY(env, obj, (uintptr_t) fieldID, value);
2762 env, obj, (uintptr_t) fieldID, value);
2763 #endif /* USDT2 */ 2704 #endif /* USDT2 */
2764 oop o = JNIHandles::resolve_non_null(obj); 2705 oop o = JNIHandles::resolve_non_null(obj);
2765 Klass* k = o->klass(); 2706 Klass* k = o->klass();
2766 int offset = jfieldIDWorkaround::from_instance_jfieldID(k, fieldID); 2707 int offset = jfieldIDWorkaround::from_instance_jfieldID(k, fieldID);
2767 // Keep JVMTI addition small and only check enabled flag here. 2708 // Keep JVMTI addition small and only check enabled flag here.
2774 } 2715 }
2775 o->obj_field_put(offset, JNIHandles::resolve(value)); 2716 o->obj_field_put(offset, JNIHandles::resolve(value));
2776 #ifndef USDT2 2717 #ifndef USDT2
2777 DTRACE_PROBE(hotspot_jni, SetObjectField__return); 2718 DTRACE_PROBE(hotspot_jni, SetObjectField__return);
2778 #else /* USDT2 */ 2719 #else /* USDT2 */
2779 HOTSPOT_JNI_SETOBJECTFIELD_RETURN( 2720 HOTSPOT_JNI_SETOBJECTFIELD_RETURN();
2780 );
2781 #endif /* USDT2 */ 2721 #endif /* USDT2 */
2782 JNI_END 2722 JNI_END
2783 2723
2784 #ifndef USDT2 2724 #ifndef USDT2
2785 #define DEFINE_SETFIELD(Argument,Fieldname,Result,SigType,unionType) \ 2725 #define DEFINE_SETFIELD(Argument,Fieldname,Result,SigType,unionType) \
2878 JNIWrapper("ToReflectedField"); 2818 JNIWrapper("ToReflectedField");
2879 #ifndef USDT2 2819 #ifndef USDT2
2880 DTRACE_PROBE4(hotspot_jni, ToReflectedField__entry, 2820 DTRACE_PROBE4(hotspot_jni, ToReflectedField__entry,
2881 env, cls, fieldID, isStatic); 2821 env, cls, fieldID, isStatic);
2882 #else /* USDT2 */ 2822 #else /* USDT2 */
2883 HOTSPOT_JNI_TOREFLECTEDFIELD_ENTRY( 2823 HOTSPOT_JNI_TOREFLECTEDFIELD_ENTRY(env, cls, (uintptr_t) fieldID, isStatic);
2884 env, cls, (uintptr_t) fieldID, isStatic);
2885 #endif /* USDT2 */ 2824 #endif /* USDT2 */
2886 jobject ret = NULL; 2825 jobject ret = NULL;
2887 DT_RETURN_MARK(ToReflectedField, jobject, (const jobject&)ret); 2826 DT_RETURN_MARK(ToReflectedField, jobject, (const jobject&)ret);
2888 2827
2889 fieldDescriptor fd; 2828 fieldDescriptor fd;
2923 const char *name, const char *sig)) 2862 const char *name, const char *sig))
2924 JNIWrapper("GetStaticFieldID"); 2863 JNIWrapper("GetStaticFieldID");
2925 #ifndef USDT2 2864 #ifndef USDT2
2926 DTRACE_PROBE4(hotspot_jni, GetStaticFieldID__entry, env, clazz, name, sig); 2865 DTRACE_PROBE4(hotspot_jni, GetStaticFieldID__entry, env, clazz, name, sig);
2927 #else /* USDT2 */ 2866 #else /* USDT2 */
2928 HOTSPOT_JNI_GETSTATICFIELDID_ENTRY( 2867 HOTSPOT_JNI_GETSTATICFIELDID_ENTRY(env, clazz, (char *) name, (char *) sig);
2929 env, clazz, (char *) name, (char *) sig);
2930 #endif /* USDT2 */ 2868 #endif /* USDT2 */
2931 jfieldID ret = NULL; 2869 jfieldID ret = NULL;
2932 DT_RETURN_MARK(GetStaticFieldID, jfieldID, (const jfieldID&)ret); 2870 DT_RETURN_MARK(GetStaticFieldID, jfieldID, (const jfieldID&)ret);
2933 2871
2934 // The class should have been loaded (we have an instance of the class 2872 // The class should have been loaded (we have an instance of the class
2964 JNI_ENTRY(jobject, jni_GetStaticObjectField(JNIEnv *env, jclass clazz, jfieldID fieldID)) 2902 JNI_ENTRY(jobject, jni_GetStaticObjectField(JNIEnv *env, jclass clazz, jfieldID fieldID))
2965 JNIWrapper("GetStaticObjectField"); 2903 JNIWrapper("GetStaticObjectField");
2966 #ifndef USDT2 2904 #ifndef USDT2
2967 DTRACE_PROBE3(hotspot_jni, GetStaticObjectField__entry, env, clazz, fieldID); 2905 DTRACE_PROBE3(hotspot_jni, GetStaticObjectField__entry, env, clazz, fieldID);
2968 #else /* USDT2 */ 2906 #else /* USDT2 */
2969 HOTSPOT_JNI_GETSTATICOBJECTFIELD_ENTRY( 2907 HOTSPOT_JNI_GETSTATICOBJECTFIELD_ENTRY(env, clazz, (uintptr_t) fieldID);
2970 env, clazz, (uintptr_t) fieldID);
2971 #endif /* USDT2 */ 2908 #endif /* USDT2 */
2972 #if INCLUDE_JNI_CHECK 2909 #if INCLUDE_JNI_CHECK
2973 DEBUG_ONLY(Klass* param_k = jniCheck::validate_class(thread, clazz);) 2910 DEBUG_ONLY(Klass* param_k = jniCheck::validate_class(thread, clazz);)
2974 #endif // INCLUDE_JNI_CHECK 2911 #endif // INCLUDE_JNI_CHECK
2975 JNIid* id = jfieldIDWorkaround::from_static_jfieldID(fieldID); 2912 JNIid* id = jfieldIDWorkaround::from_static_jfieldID(fieldID);
2981 } 2918 }
2982 jobject ret = JNIHandles::make_local(id->holder()->java_mirror()->obj_field(id->offset())); 2919 jobject ret = JNIHandles::make_local(id->holder()->java_mirror()->obj_field(id->offset()));
2983 #ifndef USDT2 2920 #ifndef USDT2
2984 DTRACE_PROBE1(hotspot_jni, GetStaticObjectField__return, ret); 2921 DTRACE_PROBE1(hotspot_jni, GetStaticObjectField__return, ret);
2985 #else /* USDT2 */ 2922 #else /* USDT2 */
2986 HOTSPOT_JNI_GETSTATICOBJECTFIELD_RETURN( 2923 HOTSPOT_JNI_GETSTATICOBJECTFIELD_RETURN(ret);
2987 ret);
2988 #endif /* USDT2 */ 2924 #endif /* USDT2 */
2989 return ret; 2925 return ret;
2990 JNI_END 2926 JNI_END
2991 2927
2992 #ifndef USDT2 2928 #ifndef USDT2
3067 JNI_ENTRY(void, jni_SetStaticObjectField(JNIEnv *env, jclass clazz, jfieldID fieldID, jobject value)) 3003 JNI_ENTRY(void, jni_SetStaticObjectField(JNIEnv *env, jclass clazz, jfieldID fieldID, jobject value))
3068 JNIWrapper("SetStaticObjectField"); 3004 JNIWrapper("SetStaticObjectField");
3069 #ifndef USDT2 3005 #ifndef USDT2
3070 DTRACE_PROBE4(hotspot_jni, SetStaticObjectField__entry, env, clazz, fieldID, value); 3006 DTRACE_PROBE4(hotspot_jni, SetStaticObjectField__entry, env, clazz, fieldID, value);
3071 #else /* USDT2 */ 3007 #else /* USDT2 */
3072 HOTSPOT_JNI_SETSTATICOBJECTFIELD_ENTRY( 3008 HOTSPOT_JNI_SETSTATICOBJECTFIELD_ENTRY(env, clazz, (uintptr_t) fieldID, value);
3073 env, clazz, (uintptr_t) fieldID, value);
3074 #endif /* USDT2 */ 3009 #endif /* USDT2 */
3075 JNIid* id = jfieldIDWorkaround::from_static_jfieldID(fieldID); 3010 JNIid* id = jfieldIDWorkaround::from_static_jfieldID(fieldID);
3076 assert(id->is_static_field_id(), "invalid static field id"); 3011 assert(id->is_static_field_id(), "invalid static field id");
3077 // Keep JVMTI addition small and only check enabled flag here. 3012 // Keep JVMTI addition small and only check enabled flag here.
3078 // jni_SetField_probe() assumes that is okay to create handles. 3013 // jni_SetField_probe() assumes that is okay to create handles.
3083 } 3018 }
3084 id->holder()->java_mirror()->obj_field_put(id->offset(), JNIHandles::resolve(value)); 3019 id->holder()->java_mirror()->obj_field_put(id->offset(), JNIHandles::resolve(value));
3085 #ifndef USDT2 3020 #ifndef USDT2
3086 DTRACE_PROBE(hotspot_jni, SetStaticObjectField__return); 3021 DTRACE_PROBE(hotspot_jni, SetStaticObjectField__return);
3087 #else /* USDT2 */ 3022 #else /* USDT2 */
3088 HOTSPOT_JNI_SETSTATICOBJECTFIELD_RETURN( 3023 HOTSPOT_JNI_SETSTATICOBJECTFIELD_RETURN();
3089 );
3090 #endif /* USDT2 */ 3024 #endif /* USDT2 */
3091 JNI_END 3025 JNI_END
3092 3026
3093 3027
3094 #ifndef USDT2 3028 #ifndef USDT2
3187 JNI_ENTRY(jstring, jni_NewString(JNIEnv *env, const jchar *unicodeChars, jsize len)) 3121 JNI_ENTRY(jstring, jni_NewString(JNIEnv *env, const jchar *unicodeChars, jsize len))
3188 JNIWrapper("NewString"); 3122 JNIWrapper("NewString");
3189 #ifndef USDT2 3123 #ifndef USDT2
3190 DTRACE_PROBE3(hotspot_jni, NewString__entry, env, unicodeChars, len); 3124 DTRACE_PROBE3(hotspot_jni, NewString__entry, env, unicodeChars, len);
3191 #else /* USDT2 */ 3125 #else /* USDT2 */
3192 HOTSPOT_JNI_NEWSTRING_ENTRY( 3126 HOTSPOT_JNI_NEWSTRING_ENTRY(env, (uint16_t *) unicodeChars, len);
3193 env, (uint16_t *) unicodeChars, len);
3194 #endif /* USDT2 */ 3127 #endif /* USDT2 */
3195 jstring ret = NULL; 3128 jstring ret = NULL;
3196 DT_RETURN_MARK(NewString, jstring, (const jstring&)ret); 3129 DT_RETURN_MARK(NewString, jstring, (const jstring&)ret);
3197 oop string=java_lang_String::create_oop_from_unicode((jchar*) unicodeChars, len, CHECK_NULL); 3130 oop string=java_lang_String::create_oop_from_unicode((jchar*) unicodeChars, len, CHECK_NULL);
3198 ret = (jstring) JNIHandles::make_local(env, string); 3131 ret = (jstring) JNIHandles::make_local(env, string);
3203 JNI_QUICK_ENTRY(jsize, jni_GetStringLength(JNIEnv *env, jstring string)) 3136 JNI_QUICK_ENTRY(jsize, jni_GetStringLength(JNIEnv *env, jstring string))
3204 JNIWrapper("GetStringLength"); 3137 JNIWrapper("GetStringLength");
3205 #ifndef USDT2 3138 #ifndef USDT2
3206 DTRACE_PROBE2(hotspot_jni, GetStringLength__entry, env, string); 3139 DTRACE_PROBE2(hotspot_jni, GetStringLength__entry, env, string);
3207 #else /* USDT2 */ 3140 #else /* USDT2 */
3208 HOTSPOT_JNI_GETSTRINGLENGTH_ENTRY( 3141 HOTSPOT_JNI_GETSTRINGLENGTH_ENTRY(env, string);
3209 env, string);
3210 #endif /* USDT2 */ 3142 #endif /* USDT2 */
3211 jsize ret = 0; 3143 jsize ret = 0;
3212 oop s = JNIHandles::resolve_non_null(string); 3144 oop s = JNIHandles::resolve_non_null(string);
3213 if (java_lang_String::value(s) != NULL) { 3145 if (java_lang_String::value(s) != NULL) {
3214 ret = java_lang_String::length(s); 3146 ret = java_lang_String::length(s);
3215 } 3147 }
3216 #ifndef USDT2 3148 #ifndef USDT2
3217 DTRACE_PROBE1(hotspot_jni, GetStringLength__return, ret); 3149 DTRACE_PROBE1(hotspot_jni, GetStringLength__return, ret);
3218 #else /* USDT2 */ 3150 #else /* USDT2 */
3219 HOTSPOT_JNI_GETSTRINGLENGTH_RETURN( 3151 HOTSPOT_JNI_GETSTRINGLENGTH_RETURN(ret);
3220 ret);
3221 #endif /* USDT2 */ 3152 #endif /* USDT2 */
3222 return ret; 3153 return ret;
3223 JNI_END 3154 JNI_END
3224 3155
3225 3156
3227 JNIEnv *env, jstring string, jboolean *isCopy)) 3158 JNIEnv *env, jstring string, jboolean *isCopy))
3228 JNIWrapper("GetStringChars"); 3159 JNIWrapper("GetStringChars");
3229 #ifndef USDT2 3160 #ifndef USDT2
3230 DTRACE_PROBE3(hotspot_jni, GetStringChars__entry, env, string, isCopy); 3161 DTRACE_PROBE3(hotspot_jni, GetStringChars__entry, env, string, isCopy);
3231 #else /* USDT2 */ 3162 #else /* USDT2 */
3232 HOTSPOT_JNI_GETSTRINGCHARS_ENTRY( 3163 HOTSPOT_JNI_GETSTRINGCHARS_ENTRY(env, string, (uintptr_t *) isCopy);
3233 env, string, (uintptr_t *) isCopy);
3234 #endif /* USDT2 */ 3164 #endif /* USDT2 */
3235 jchar* buf = NULL; 3165 jchar* buf = NULL;
3236 oop s = JNIHandles::resolve_non_null(string); 3166 oop s = JNIHandles::resolve_non_null(string);
3237 typeArrayOop s_value = java_lang_String::value(s); 3167 typeArrayOop s_value = java_lang_String::value(s);
3238 if (s_value != NULL) { 3168 if (s_value != NULL) {
3252 } 3182 }
3253 } 3183 }
3254 #ifndef USDT2 3184 #ifndef USDT2
3255 DTRACE_PROBE1(hotspot_jni, GetStringChars__return, buf); 3185 DTRACE_PROBE1(hotspot_jni, GetStringChars__return, buf);
3256 #else /* USDT2 */ 3186 #else /* USDT2 */
3257 HOTSPOT_JNI_GETSTRINGCHARS_RETURN( 3187 HOTSPOT_JNI_GETSTRINGCHARS_RETURN(buf);
3258 buf);
3259 #endif /* USDT2 */ 3188 #endif /* USDT2 */
3260 return buf; 3189 return buf;
3261 JNI_END 3190 JNI_END
3262 3191
3263 3192
3264 JNI_QUICK_ENTRY(void, jni_ReleaseStringChars(JNIEnv *env, jstring str, const jchar *chars)) 3193 JNI_QUICK_ENTRY(void, jni_ReleaseStringChars(JNIEnv *env, jstring str, const jchar *chars))
3265 JNIWrapper("ReleaseStringChars"); 3194 JNIWrapper("ReleaseStringChars");
3266 #ifndef USDT2 3195 #ifndef USDT2
3267 DTRACE_PROBE3(hotspot_jni, ReleaseStringChars__entry, env, str, chars); 3196 DTRACE_PROBE3(hotspot_jni, ReleaseStringChars__entry, env, str, chars);
3268 #else /* USDT2 */ 3197 #else /* USDT2 */
3269 HOTSPOT_JNI_RELEASESTRINGCHARS_ENTRY( 3198 HOTSPOT_JNI_RELEASESTRINGCHARS_ENTRY(env, str, (uint16_t *) chars);
3270 env, str, (uint16_t *) chars);
3271 #endif /* USDT2 */ 3199 #endif /* USDT2 */
3272 //%note jni_6 3200 //%note jni_6
3273 if (chars != NULL) { 3201 if (chars != NULL) {
3274 // Since String objects are supposed to be immutable, don't copy any 3202 // Since String objects are supposed to be immutable, don't copy any
3275 // new data back. A bad user will have to go after the char array. 3203 // new data back. A bad user will have to go after the char array.
3276 FreeHeap((void*) chars); 3204 FreeHeap((void*) chars);
3277 } 3205 }
3278 #ifndef USDT2 3206 #ifndef USDT2
3279 DTRACE_PROBE(hotspot_jni, ReleaseStringChars__return); 3207 DTRACE_PROBE(hotspot_jni, ReleaseStringChars__return);
3280 #else /* USDT2 */ 3208 #else /* USDT2 */
3281 HOTSPOT_JNI_RELEASESTRINGCHARS_RETURN( 3209 HOTSPOT_JNI_RELEASESTRINGCHARS_RETURN();
3282 );
3283 #endif /* USDT2 */ 3210 #endif /* USDT2 */
3284 JNI_END 3211 JNI_END
3285 3212
3286 3213
3287 // UTF Interface 3214 // UTF Interface
3296 JNI_ENTRY(jstring, jni_NewStringUTF(JNIEnv *env, const char *bytes)) 3223 JNI_ENTRY(jstring, jni_NewStringUTF(JNIEnv *env, const char *bytes))
3297 JNIWrapper("NewStringUTF"); 3224 JNIWrapper("NewStringUTF");
3298 #ifndef USDT2 3225 #ifndef USDT2
3299 DTRACE_PROBE2(hotspot_jni, NewStringUTF__entry, env, bytes); 3226 DTRACE_PROBE2(hotspot_jni, NewStringUTF__entry, env, bytes);
3300 #else /* USDT2 */ 3227 #else /* USDT2 */
3301 HOTSPOT_JNI_NEWSTRINGUTF_ENTRY( 3228 HOTSPOT_JNI_NEWSTRINGUTF_ENTRY(env, (char *) bytes);
3302 env, (char *) bytes);
3303 #endif /* USDT2 */ 3229 #endif /* USDT2 */
3304 jstring ret; 3230 jstring ret;
3305 DT_RETURN_MARK(NewStringUTF, jstring, (const jstring&)ret); 3231 DT_RETURN_MARK(NewStringUTF, jstring, (const jstring&)ret);
3306 3232
3307 oop result = java_lang_String::create_oop_from_str((char*) bytes, CHECK_NULL); 3233 oop result = java_lang_String::create_oop_from_str((char*) bytes, CHECK_NULL);
3313 JNI_ENTRY(jsize, jni_GetStringUTFLength(JNIEnv *env, jstring string)) 3239 JNI_ENTRY(jsize, jni_GetStringUTFLength(JNIEnv *env, jstring string))
3314 JNIWrapper("GetStringUTFLength"); 3240 JNIWrapper("GetStringUTFLength");
3315 #ifndef USDT2 3241 #ifndef USDT2
3316 DTRACE_PROBE2(hotspot_jni, GetStringUTFLength__entry, env, string); 3242 DTRACE_PROBE2(hotspot_jni, GetStringUTFLength__entry, env, string);
3317 #else /* USDT2 */ 3243 #else /* USDT2 */
3318 HOTSPOT_JNI_GETSTRINGUTFLENGTH_ENTRY( 3244 HOTSPOT_JNI_GETSTRINGUTFLENGTH_ENTRY(env, string);
3319 env, string);
3320 #endif /* USDT2 */ 3245 #endif /* USDT2 */
3321 jsize ret = 0; 3246 jsize ret = 0;
3322 oop java_string = JNIHandles::resolve_non_null(string); 3247 oop java_string = JNIHandles::resolve_non_null(string);
3323 if (java_lang_String::value(java_string) != NULL) { 3248 if (java_lang_String::value(java_string) != NULL) {
3324 ret = java_lang_String::utf8_length(java_string); 3249 ret = java_lang_String::utf8_length(java_string);
3325 } 3250 }
3326 #ifndef USDT2 3251 #ifndef USDT2
3327 DTRACE_PROBE1(hotspot_jni, GetStringUTFLength__return, ret); 3252 DTRACE_PROBE1(hotspot_jni, GetStringUTFLength__return, ret);
3328 #else /* USDT2 */ 3253 #else /* USDT2 */
3329 HOTSPOT_JNI_GETSTRINGUTFLENGTH_RETURN( 3254 HOTSPOT_JNI_GETSTRINGUTFLENGTH_RETURN(ret);
3330 ret);
3331 #endif /* USDT2 */ 3255 #endif /* USDT2 */
3332 return ret; 3256 return ret;
3333 JNI_END 3257 JNI_END
3334 3258
3335 3259
3336 JNI_ENTRY(const char*, jni_GetStringUTFChars(JNIEnv *env, jstring string, jboolean *isCopy)) 3260 JNI_ENTRY(const char*, jni_GetStringUTFChars(JNIEnv *env, jstring string, jboolean *isCopy))
3337 JNIWrapper("GetStringUTFChars"); 3261 JNIWrapper("GetStringUTFChars");
3338 #ifndef USDT2 3262 #ifndef USDT2
3339 DTRACE_PROBE3(hotspot_jni, GetStringUTFChars__entry, env, string, isCopy); 3263 DTRACE_PROBE3(hotspot_jni, GetStringUTFChars__entry, env, string, isCopy);
3340 #else /* USDT2 */ 3264 #else /* USDT2 */
3341 HOTSPOT_JNI_GETSTRINGUTFCHARS_ENTRY( 3265 HOTSPOT_JNI_GETSTRINGUTFCHARS_ENTRY(env, string, (uintptr_t *) isCopy);
3342 env, string, (uintptr_t *) isCopy);
3343 #endif /* USDT2 */ 3266 #endif /* USDT2 */
3344 char* result = NULL; 3267 char* result = NULL;
3345 oop java_string = JNIHandles::resolve_non_null(string); 3268 oop java_string = JNIHandles::resolve_non_null(string);
3346 if (java_lang_String::value(java_string) != NULL) { 3269 if (java_lang_String::value(java_string) != NULL) {
3347 size_t length = java_lang_String::utf8_length(java_string); 3270 size_t length = java_lang_String::utf8_length(java_string);
3355 } 3278 }
3356 } 3279 }
3357 #ifndef USDT2 3280 #ifndef USDT2
3358 DTRACE_PROBE1(hotspot_jni, GetStringUTFChars__return, result); 3281 DTRACE_PROBE1(hotspot_jni, GetStringUTFChars__return, result);
3359 #else /* USDT2 */ 3282 #else /* USDT2 */
3360 HOTSPOT_JNI_GETSTRINGUTFCHARS_RETURN( 3283 HOTSPOT_JNI_GETSTRINGUTFCHARS_RETURN(result);
3361 result);
3362 #endif /* USDT2 */ 3284 #endif /* USDT2 */
3363 return result; 3285 return result;
3364 JNI_END 3286 JNI_END
3365 3287
3366 3288
3367 JNI_LEAF(void, jni_ReleaseStringUTFChars(JNIEnv *env, jstring str, const char *chars)) 3289 JNI_LEAF(void, jni_ReleaseStringUTFChars(JNIEnv *env, jstring str, const char *chars))
3368 JNIWrapper("ReleaseStringUTFChars"); 3290 JNIWrapper("ReleaseStringUTFChars");
3369 #ifndef USDT2 3291 #ifndef USDT2
3370 DTRACE_PROBE3(hotspot_jni, ReleaseStringUTFChars__entry, env, str, chars); 3292 DTRACE_PROBE3(hotspot_jni, ReleaseStringUTFChars__entry, env, str, chars);
3371 #else /* USDT2 */ 3293 #else /* USDT2 */
3372 HOTSPOT_JNI_RELEASESTRINGUTFCHARS_ENTRY( 3294 HOTSPOT_JNI_RELEASESTRINGUTFCHARS_ENTRY(env, str, (char *) chars);
3373 env, str, (char *) chars);
3374 #endif /* USDT2 */ 3295 #endif /* USDT2 */
3375 if (chars != NULL) { 3296 if (chars != NULL) {
3376 FreeHeap((char*) chars); 3297 FreeHeap((char*) chars);
3377 } 3298 }
3378 #ifndef USDT2 3299 #ifndef USDT2
3379 DTRACE_PROBE(hotspot_jni, ReleaseStringUTFChars__return); 3300 DTRACE_PROBE(hotspot_jni, ReleaseStringUTFChars__return);
3380 #else /* USDT2 */ 3301 #else /* USDT2 */
3381 HOTSPOT_JNI_RELEASESTRINGUTFCHARS_RETURN( 3302 HOTSPOT_JNI_RELEASESTRINGUTFCHARS_RETURN();
3382 );
3383 #endif /* USDT2 */ 3303 #endif /* USDT2 */
3384 JNI_END 3304 JNI_END
3385 3305
3386 3306
3387 JNI_QUICK_ENTRY(jsize, jni_GetArrayLength(JNIEnv *env, jarray array)) 3307 JNI_QUICK_ENTRY(jsize, jni_GetArrayLength(JNIEnv *env, jarray array))
3388 JNIWrapper("GetArrayLength"); 3308 JNIWrapper("GetArrayLength");
3389 #ifndef USDT2 3309 #ifndef USDT2
3390 DTRACE_PROBE2(hotspot_jni, GetArrayLength__entry, env, array); 3310 DTRACE_PROBE2(hotspot_jni, GetArrayLength__entry, env, array);
3391 #else /* USDT2 */ 3311 #else /* USDT2 */
3392 HOTSPOT_JNI_GETARRAYLENGTH_ENTRY( 3312 HOTSPOT_JNI_GETARRAYLENGTH_ENTRY(env, array);
3393 env, array);
3394 #endif /* USDT2 */ 3313 #endif /* USDT2 */
3395 arrayOop a = arrayOop(JNIHandles::resolve_non_null(array)); 3314 arrayOop a = arrayOop(JNIHandles::resolve_non_null(array));
3396 assert(a->is_array(), "must be array"); 3315 assert(a->is_array(), "must be array");
3397 jsize ret = a->length(); 3316 jsize ret = a->length();
3398 #ifndef USDT2 3317 #ifndef USDT2
3399 DTRACE_PROBE1(hotspot_jni, GetArrayLength__return, ret); 3318 DTRACE_PROBE1(hotspot_jni, GetArrayLength__return, ret);
3400 #else /* USDT2 */ 3319 #else /* USDT2 */
3401 HOTSPOT_JNI_GETARRAYLENGTH_RETURN( 3320 HOTSPOT_JNI_GETARRAYLENGTH_RETURN(ret);
3402 ret);
3403 #endif /* USDT2 */ 3321 #endif /* USDT2 */
3404 return ret; 3322 return ret;
3405 JNI_END 3323 JNI_END
3406 3324
3407 3325
3419 JNI_ENTRY(jobjectArray, jni_NewObjectArray(JNIEnv *env, jsize length, jclass elementClass, jobject initialElement)) 3337 JNI_ENTRY(jobjectArray, jni_NewObjectArray(JNIEnv *env, jsize length, jclass elementClass, jobject initialElement))
3420 JNIWrapper("NewObjectArray"); 3338 JNIWrapper("NewObjectArray");
3421 #ifndef USDT2 3339 #ifndef USDT2
3422 DTRACE_PROBE4(hotspot_jni, NewObjectArray__entry, env, length, elementClass, initialElement); 3340 DTRACE_PROBE4(hotspot_jni, NewObjectArray__entry, env, length, elementClass, initialElement);
3423 #else /* USDT2 */ 3341 #else /* USDT2 */
3424 HOTSPOT_JNI_NEWOBJECTARRAY_ENTRY( 3342 HOTSPOT_JNI_NEWOBJECTARRAY_ENTRY(env, length, elementClass, initialElement);
3425 env, length, elementClass, initialElement);
3426 #endif /* USDT2 */ 3343 #endif /* USDT2 */
3427 jobjectArray ret = NULL; 3344 jobjectArray ret = NULL;
3428 DT_RETURN_MARK(NewObjectArray, jobjectArray, (const jobjectArray&)ret); 3345 DT_RETURN_MARK(NewObjectArray, jobjectArray, (const jobjectArray&)ret);
3429 KlassHandle ek(THREAD, java_lang_Class::as_Klass(JNIHandles::resolve_non_null(elementClass))); 3346 KlassHandle ek(THREAD, java_lang_Class::as_Klass(JNIHandles::resolve_non_null(elementClass)));
3430 Klass* ako = ek()->array_klass(CHECK_NULL); 3347 Klass* ako = ek()->array_klass(CHECK_NULL);
3451 JNI_ENTRY(jobject, jni_GetObjectArrayElement(JNIEnv *env, jobjectArray array, jsize index)) 3368 JNI_ENTRY(jobject, jni_GetObjectArrayElement(JNIEnv *env, jobjectArray array, jsize index))
3452 JNIWrapper("GetObjectArrayElement"); 3369 JNIWrapper("GetObjectArrayElement");
3453 #ifndef USDT2 3370 #ifndef USDT2
3454 DTRACE_PROBE3(hotspot_jni, GetObjectArrayElement__entry, env, array, index); 3371 DTRACE_PROBE3(hotspot_jni, GetObjectArrayElement__entry, env, array, index);
3455 #else /* USDT2 */ 3372 #else /* USDT2 */
3456 HOTSPOT_JNI_GETOBJECTARRAYELEMENT_ENTRY( 3373 HOTSPOT_JNI_GETOBJECTARRAYELEMENT_ENTRY(env, array, index);
3457 env, array, index);
3458 #endif /* USDT2 */ 3374 #endif /* USDT2 */
3459 jobject ret = NULL; 3375 jobject ret = NULL;
3460 DT_RETURN_MARK(GetObjectArrayElement, jobject, (const jobject&)ret); 3376 DT_RETURN_MARK(GetObjectArrayElement, jobject, (const jobject&)ret);
3461 objArrayOop a = objArrayOop(JNIHandles::resolve_non_null(array)); 3377 objArrayOop a = objArrayOop(JNIHandles::resolve_non_null(array));
3462 if (a->is_within_bounds(index)) { 3378 if (a->is_within_bounds(index)) {
3479 JNI_ENTRY(void, jni_SetObjectArrayElement(JNIEnv *env, jobjectArray array, jsize index, jobject value)) 3395 JNI_ENTRY(void, jni_SetObjectArrayElement(JNIEnv *env, jobjectArray array, jsize index, jobject value))
3480 JNIWrapper("SetObjectArrayElement"); 3396 JNIWrapper("SetObjectArrayElement");
3481 #ifndef USDT2 3397 #ifndef USDT2
3482 DTRACE_PROBE4(hotspot_jni, SetObjectArrayElement__entry, env, array, index, value); 3398 DTRACE_PROBE4(hotspot_jni, SetObjectArrayElement__entry, env, array, index, value);
3483 #else /* USDT2 */ 3399 #else /* USDT2 */
3484 HOTSPOT_JNI_SETOBJECTARRAYELEMENT_ENTRY( 3400 HOTSPOT_JNI_SETOBJECTARRAYELEMENT_ENTRY(env, array, index, value);
3485 env, array, index, value);
3486 #endif /* USDT2 */ 3401 #endif /* USDT2 */
3487 DT_VOID_RETURN_MARK(SetObjectArrayElement); 3402 DT_VOID_RETURN_MARK(SetObjectArrayElement);
3488 3403
3489 objArrayOop a = objArrayOop(JNIHandles::resolve_non_null(array)); 3404 objArrayOop a = objArrayOop(JNIHandles::resolve_non_null(array));
3490 oop v = JNIHandles::resolve(value); 3405 oop v = JNIHandles::resolve(value);
4032 jint nMethods)) 3947 jint nMethods))
4033 JNIWrapper("RegisterNatives"); 3948 JNIWrapper("RegisterNatives");
4034 #ifndef USDT2 3949 #ifndef USDT2
4035 DTRACE_PROBE4(hotspot_jni, RegisterNatives__entry, env, clazz, methods, nMethods); 3950 DTRACE_PROBE4(hotspot_jni, RegisterNatives__entry, env, clazz, methods, nMethods);
4036 #else /* USDT2 */ 3951 #else /* USDT2 */
4037 HOTSPOT_JNI_REGISTERNATIVES_ENTRY( 3952 HOTSPOT_JNI_REGISTERNATIVES_ENTRY(env, clazz, (void *) methods, nMethods);
4038 env, clazz, (void *) methods, nMethods);
4039 #endif /* USDT2 */ 3953 #endif /* USDT2 */
4040 jint ret = 0; 3954 jint ret = 0;
4041 DT_RETURN_MARK(RegisterNatives, jint, (const jint&)ret); 3955 DT_RETURN_MARK(RegisterNatives, jint, (const jint&)ret);
4042 3956
4043 KlassHandle h_k(thread, java_lang_Class::as_Klass(JNIHandles::resolve_non_null(clazz))); 3957 KlassHandle h_k(thread, java_lang_Class::as_Klass(JNIHandles::resolve_non_null(clazz)));
4075 JNI_ENTRY(jint, jni_UnregisterNatives(JNIEnv *env, jclass clazz)) 3989 JNI_ENTRY(jint, jni_UnregisterNatives(JNIEnv *env, jclass clazz))
4076 JNIWrapper("UnregisterNatives"); 3990 JNIWrapper("UnregisterNatives");
4077 #ifndef USDT2 3991 #ifndef USDT2
4078 DTRACE_PROBE2(hotspot_jni, UnregisterNatives__entry, env, clazz); 3992 DTRACE_PROBE2(hotspot_jni, UnregisterNatives__entry, env, clazz);
4079 #else /* USDT2 */ 3993 #else /* USDT2 */
4080 HOTSPOT_JNI_UNREGISTERNATIVES_ENTRY( 3994 HOTSPOT_JNI_UNREGISTERNATIVES_ENTRY(env, clazz);
4081 env, clazz);
4082 #endif /* USDT2 */ 3995 #endif /* USDT2 */
4083 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(clazz)); 3996 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(clazz));
4084 //%note jni_2 3997 //%note jni_2
4085 if (k->oop_is_instance()) { 3998 if (k->oop_is_instance()) {
4086 for (int index = 0; index < InstanceKlass::cast(k)->methods()->length(); index++) { 3999 for (int index = 0; index < InstanceKlass::cast(k)->methods()->length(); index++) {
4092 } 4005 }
4093 } 4006 }
4094 #ifndef USDT2 4007 #ifndef USDT2
4095 DTRACE_PROBE1(hotspot_jni, UnregisterNatives__return, 0); 4008 DTRACE_PROBE1(hotspot_jni, UnregisterNatives__return, 0);
4096 #else /* USDT2 */ 4009 #else /* USDT2 */
4097 HOTSPOT_JNI_UNREGISTERNATIVES_RETURN( 4010 HOTSPOT_JNI_UNREGISTERNATIVES_RETURN(0);
4098 0);
4099 #endif /* USDT2 */ 4011 #endif /* USDT2 */
4100 return 0; 4012 return 0;
4101 JNI_END 4013 JNI_END
4102 4014
4103 // 4015 //
4113 4025
4114 JNI_ENTRY(jint, jni_MonitorEnter(JNIEnv *env, jobject jobj)) 4026 JNI_ENTRY(jint, jni_MonitorEnter(JNIEnv *env, jobject jobj))
4115 #ifndef USDT2 4027 #ifndef USDT2
4116 DTRACE_PROBE2(hotspot_jni, MonitorEnter__entry, env, jobj); 4028 DTRACE_PROBE2(hotspot_jni, MonitorEnter__entry, env, jobj);
4117 #else /* USDT2 */ 4029 #else /* USDT2 */
4118 HOTSPOT_JNI_MONITORENTER_ENTRY( 4030 HOTSPOT_JNI_MONITORENTER_ENTRY(env, jobj);
4119 env, jobj);
4120 #endif /* USDT2 */ 4031 #endif /* USDT2 */
4121 jint ret = JNI_ERR; 4032 jint ret = JNI_ERR;
4122 DT_RETURN_MARK(MonitorEnter, jint, (const jint&)ret); 4033 DT_RETURN_MARK(MonitorEnter, jint, (const jint&)ret);
4123 4034
4124 // If the object is null, we can't do anything with it 4035 // If the object is null, we can't do anything with it
4141 4052
4142 JNI_ENTRY(jint, jni_MonitorExit(JNIEnv *env, jobject jobj)) 4053 JNI_ENTRY(jint, jni_MonitorExit(JNIEnv *env, jobject jobj))
4143 #ifndef USDT2 4054 #ifndef USDT2
4144 DTRACE_PROBE2(hotspot_jni, MonitorExit__entry, env, jobj); 4055 DTRACE_PROBE2(hotspot_jni, MonitorExit__entry, env, jobj);
4145 #else /* USDT2 */ 4056 #else /* USDT2 */
4146 HOTSPOT_JNI_MONITOREXIT_ENTRY( 4057 HOTSPOT_JNI_MONITOREXIT_ENTRY(env, jobj);
4147 env, jobj);
4148 #endif /* USDT2 */ 4058 #endif /* USDT2 */
4149 jint ret = JNI_ERR; 4059 jint ret = JNI_ERR;
4150 DT_RETURN_MARK(MonitorExit, jint, (const jint&)ret); 4060 DT_RETURN_MARK(MonitorExit, jint, (const jint&)ret);
4151 4061
4152 // Don't do anything with a null object 4062 // Don't do anything with a null object
4175 JNI_ENTRY(void, jni_GetStringRegion(JNIEnv *env, jstring string, jsize start, jsize len, jchar *buf)) 4085 JNI_ENTRY(void, jni_GetStringRegion(JNIEnv *env, jstring string, jsize start, jsize len, jchar *buf))
4176 JNIWrapper("GetStringRegion"); 4086 JNIWrapper("GetStringRegion");
4177 #ifndef USDT2 4087 #ifndef USDT2
4178 DTRACE_PROBE5(hotspot_jni, GetStringRegion__entry, env, string, start, len, buf); 4088 DTRACE_PROBE5(hotspot_jni, GetStringRegion__entry, env, string, start, len, buf);
4179 #else /* USDT2 */ 4089 #else /* USDT2 */
4180 HOTSPOT_JNI_GETSTRINGREGION_ENTRY( 4090 HOTSPOT_JNI_GETSTRINGREGION_ENTRY(env, string, start, len, buf);
4181 env, string, start, len, buf);
4182 #endif /* USDT2 */ 4091 #endif /* USDT2 */
4183 DT_VOID_RETURN_MARK(GetStringRegion); 4092 DT_VOID_RETURN_MARK(GetStringRegion);
4184 oop s = JNIHandles::resolve_non_null(string); 4093 oop s = JNIHandles::resolve_non_null(string);
4185 int s_len = java_lang_String::length(s); 4094 int s_len = java_lang_String::length(s);
4186 if (start < 0 || len < 0 || start + len > s_len) { 4095 if (start < 0 || len < 0 || start + len > s_len) {
4204 JNI_ENTRY(void, jni_GetStringUTFRegion(JNIEnv *env, jstring string, jsize start, jsize len, char *buf)) 4113 JNI_ENTRY(void, jni_GetStringUTFRegion(JNIEnv *env, jstring string, jsize start, jsize len, char *buf))
4205 JNIWrapper("GetStringUTFRegion"); 4114 JNIWrapper("GetStringUTFRegion");
4206 #ifndef USDT2 4115 #ifndef USDT2
4207 DTRACE_PROBE5(hotspot_jni, GetStringUTFRegion__entry, env, string, start, len, buf); 4116 DTRACE_PROBE5(hotspot_jni, GetStringUTFRegion__entry, env, string, start, len, buf);
4208 #else /* USDT2 */ 4117 #else /* USDT2 */
4209 HOTSPOT_JNI_GETSTRINGUTFREGION_ENTRY( 4118 HOTSPOT_JNI_GETSTRINGUTFREGION_ENTRY(env, string, start, len, buf);
4210 env, string, start, len, buf);
4211 #endif /* USDT2 */ 4119 #endif /* USDT2 */
4212 DT_VOID_RETURN_MARK(GetStringUTFRegion); 4120 DT_VOID_RETURN_MARK(GetStringUTFRegion);
4213 oop s = JNIHandles::resolve_non_null(string); 4121 oop s = JNIHandles::resolve_non_null(string);
4214 int s_len = java_lang_String::length(s); 4122 int s_len = java_lang_String::length(s);
4215 if (start < 0 || len < 0 || start + len > s_len) { 4123 if (start < 0 || len < 0 || start + len > s_len) {
4235 JNI_ENTRY(void*, jni_GetPrimitiveArrayCritical(JNIEnv *env, jarray array, jboolean *isCopy)) 4143 JNI_ENTRY(void*, jni_GetPrimitiveArrayCritical(JNIEnv *env, jarray array, jboolean *isCopy))
4236 JNIWrapper("GetPrimitiveArrayCritical"); 4144 JNIWrapper("GetPrimitiveArrayCritical");
4237 #ifndef USDT2 4145 #ifndef USDT2
4238 DTRACE_PROBE3(hotspot_jni, GetPrimitiveArrayCritical__entry, env, array, isCopy); 4146 DTRACE_PROBE3(hotspot_jni, GetPrimitiveArrayCritical__entry, env, array, isCopy);
4239 #else /* USDT2 */ 4147 #else /* USDT2 */
4240 HOTSPOT_JNI_GETPRIMITIVEARRAYCRITICAL_ENTRY( 4148 HOTSPOT_JNI_GETPRIMITIVEARRAYCRITICAL_ENTRY(env, array, (uintptr_t *) isCopy);
4241 env, array, (uintptr_t *) isCopy);
4242 #endif /* USDT2 */ 4149 #endif /* USDT2 */
4243 GC_locker::lock_critical(thread); 4150 GC_locker::lock_critical(thread);
4244 if (isCopy != NULL) { 4151 if (isCopy != NULL) {
4245 *isCopy = JNI_FALSE; 4152 *isCopy = JNI_FALSE;
4246 } 4153 }
4254 } 4161 }
4255 void* ret = arrayOop(a)->base(type); 4162 void* ret = arrayOop(a)->base(type);
4256 #ifndef USDT2 4163 #ifndef USDT2
4257 DTRACE_PROBE1(hotspot_jni, GetPrimitiveArrayCritical__return, ret); 4164 DTRACE_PROBE1(hotspot_jni, GetPrimitiveArrayCritical__return, ret);
4258 #else /* USDT2 */ 4165 #else /* USDT2 */
4259 HOTSPOT_JNI_GETPRIMITIVEARRAYCRITICAL_RETURN( 4166 HOTSPOT_JNI_GETPRIMITIVEARRAYCRITICAL_RETURN(ret);
4260 ret);
4261 #endif /* USDT2 */ 4167 #endif /* USDT2 */
4262 return ret; 4168 return ret;
4263 JNI_END 4169 JNI_END
4264 4170
4265 4171
4266 JNI_ENTRY(void, jni_ReleasePrimitiveArrayCritical(JNIEnv *env, jarray array, void *carray, jint mode)) 4172 JNI_ENTRY(void, jni_ReleasePrimitiveArrayCritical(JNIEnv *env, jarray array, void *carray, jint mode))
4267 JNIWrapper("ReleasePrimitiveArrayCritical"); 4173 JNIWrapper("ReleasePrimitiveArrayCritical");
4268 #ifndef USDT2 4174 #ifndef USDT2
4269 DTRACE_PROBE4(hotspot_jni, ReleasePrimitiveArrayCritical__entry, env, array, carray, mode); 4175 DTRACE_PROBE4(hotspot_jni, ReleasePrimitiveArrayCritical__entry, env, array, carray, mode);
4270 #else /* USDT2 */ 4176 #else /* USDT2 */
4271 HOTSPOT_JNI_RELEASEPRIMITIVEARRAYCRITICAL_ENTRY( 4177 HOTSPOT_JNI_RELEASEPRIMITIVEARRAYCRITICAL_ENTRY(env, array, carray, mode);
4272 env, array, carray, mode);
4273 #endif /* USDT2 */ 4178 #endif /* USDT2 */
4274 // The array, carray and mode arguments are ignored 4179 // The array, carray and mode arguments are ignored
4275 GC_locker::unlock_critical(thread); 4180 GC_locker::unlock_critical(thread);
4276 #ifndef USDT2 4181 #ifndef USDT2
4277 DTRACE_PROBE(hotspot_jni, ReleasePrimitiveArrayCritical__return); 4182 DTRACE_PROBE(hotspot_jni, ReleasePrimitiveArrayCritical__return);
4278 #else /* USDT2 */ 4183 #else /* USDT2 */
4279 HOTSPOT_JNI_RELEASEPRIMITIVEARRAYCRITICAL_RETURN( 4184 HOTSPOT_JNI_RELEASEPRIMITIVEARRAYCRITICAL_RETURN();
4280 );
4281 #endif /* USDT2 */ 4185 #endif /* USDT2 */
4282 JNI_END 4186 JNI_END
4283 4187
4284 4188
4285 JNI_ENTRY(const jchar*, jni_GetStringCritical(JNIEnv *env, jstring string, jboolean *isCopy)) 4189 JNI_ENTRY(const jchar*, jni_GetStringCritical(JNIEnv *env, jstring string, jboolean *isCopy))
4286 JNIWrapper("GetStringCritical"); 4190 JNIWrapper("GetStringCritical");
4287 #ifndef USDT2 4191 #ifndef USDT2
4288 DTRACE_PROBE3(hotspot_jni, GetStringCritical__entry, env, string, isCopy); 4192 DTRACE_PROBE3(hotspot_jni, GetStringCritical__entry, env, string, isCopy);
4289 #else /* USDT2 */ 4193 #else /* USDT2 */
4290 HOTSPOT_JNI_GETSTRINGCRITICAL_ENTRY( 4194 HOTSPOT_JNI_GETSTRINGCRITICAL_ENTRY(env, string, (uintptr_t *) isCopy);
4291 env, string, (uintptr_t *) isCopy);
4292 #endif /* USDT2 */ 4195 #endif /* USDT2 */
4293 GC_locker::lock_critical(thread); 4196 GC_locker::lock_critical(thread);
4294 if (isCopy != NULL) { 4197 if (isCopy != NULL) {
4295 *isCopy = JNI_FALSE; 4198 *isCopy = JNI_FALSE;
4296 } 4199 }
4305 ret = (jchar*) s_value->base(T_CHAR); 4208 ret = (jchar*) s_value->base(T_CHAR);
4306 } 4209 }
4307 #ifndef USDT2 4210 #ifndef USDT2
4308 DTRACE_PROBE1(hotspot_jni, GetStringCritical__return, ret); 4211 DTRACE_PROBE1(hotspot_jni, GetStringCritical__return, ret);
4309 #else /* USDT2 */ 4212 #else /* USDT2 */
4310 HOTSPOT_JNI_GETSTRINGCRITICAL_RETURN( 4213 HOTSPOT_JNI_GETSTRINGCRITICAL_RETURN((uint16_t *) ret);
4311 (uint16_t *) ret);
4312 #endif /* USDT2 */ 4214 #endif /* USDT2 */
4313 return ret; 4215 return ret;
4314 JNI_END 4216 JNI_END
4315 4217
4316 4218
4317 JNI_ENTRY(void, jni_ReleaseStringCritical(JNIEnv *env, jstring str, const jchar *chars)) 4219 JNI_ENTRY(void, jni_ReleaseStringCritical(JNIEnv *env, jstring str, const jchar *chars))
4318 JNIWrapper("ReleaseStringCritical"); 4220 JNIWrapper("ReleaseStringCritical");
4319 #ifndef USDT2 4221 #ifndef USDT2
4320 DTRACE_PROBE3(hotspot_jni, ReleaseStringCritical__entry, env, str, chars); 4222 DTRACE_PROBE3(hotspot_jni, ReleaseStringCritical__entry, env, str, chars);
4321 #else /* USDT2 */ 4223 #else /* USDT2 */
4322 HOTSPOT_JNI_RELEASESTRINGCRITICAL_ENTRY( 4224 HOTSPOT_JNI_RELEASESTRINGCRITICAL_ENTRY(env, str, (uint16_t *) chars);
4323 env, str, (uint16_t *) chars);
4324 #endif /* USDT2 */ 4225 #endif /* USDT2 */
4325 // The str and chars arguments are ignored 4226 // The str and chars arguments are ignored
4326 GC_locker::unlock_critical(thread); 4227 GC_locker::unlock_critical(thread);
4327 #ifndef USDT2 4228 #ifndef USDT2
4328 DTRACE_PROBE(hotspot_jni, ReleaseStringCritical__return); 4229 DTRACE_PROBE(hotspot_jni, ReleaseStringCritical__return);
4329 #else /* USDT2 */ 4230 #else /* USDT2 */
4330 HOTSPOT_JNI_RELEASESTRINGCRITICAL_RETURN( 4231 HOTSPOT_JNI_RELEASESTRINGCRITICAL_RETURN();
4331 );
4332 #endif /* USDT2 */ 4232 #endif /* USDT2 */
4333 JNI_END 4233 JNI_END
4334 4234
4335 4235
4336 JNI_ENTRY(jweak, jni_NewWeakGlobalRef(JNIEnv *env, jobject ref)) 4236 JNI_ENTRY(jweak, jni_NewWeakGlobalRef(JNIEnv *env, jobject ref))
4337 JNIWrapper("jni_NewWeakGlobalRef"); 4237 JNIWrapper("jni_NewWeakGlobalRef");
4338 #ifndef USDT2 4238 #ifndef USDT2
4339 DTRACE_PROBE2(hotspot_jni, NewWeakGlobalRef__entry, env, ref); 4239 DTRACE_PROBE2(hotspot_jni, NewWeakGlobalRef__entry, env, ref);
4340 #else /* USDT2 */ 4240 #else /* USDT2 */
4341 HOTSPOT_JNI_NEWWEAKGLOBALREF_ENTRY( 4241 HOTSPOT_JNI_NEWWEAKGLOBALREF_ENTRY(env, ref);
4342 env, ref);
4343 #endif /* USDT2 */ 4242 #endif /* USDT2 */
4344 Handle ref_handle(thread, JNIHandles::resolve(ref)); 4243 Handle ref_handle(thread, JNIHandles::resolve(ref));
4345 jweak ret = JNIHandles::make_weak_global(ref_handle); 4244 jweak ret = JNIHandles::make_weak_global(ref_handle);
4346 #ifndef USDT2 4245 #ifndef USDT2
4347 DTRACE_PROBE1(hotspot_jni, NewWeakGlobalRef__return, ret); 4246 DTRACE_PROBE1(hotspot_jni, NewWeakGlobalRef__return, ret);
4348 #else /* USDT2 */ 4247 #else /* USDT2 */
4349 HOTSPOT_JNI_NEWWEAKGLOBALREF_RETURN( 4248 HOTSPOT_JNI_NEWWEAKGLOBALREF_RETURN(ret);
4350 ret);
4351 #endif /* USDT2 */ 4249 #endif /* USDT2 */
4352 return ret; 4250 return ret;
4353 JNI_END 4251 JNI_END
4354 4252
4355 // Must be JNI_ENTRY (with HandleMark) 4253 // Must be JNI_ENTRY (with HandleMark)
4356 JNI_ENTRY(void, jni_DeleteWeakGlobalRef(JNIEnv *env, jweak ref)) 4254 JNI_ENTRY(void, jni_DeleteWeakGlobalRef(JNIEnv *env, jweak ref))
4357 JNIWrapper("jni_DeleteWeakGlobalRef"); 4255 JNIWrapper("jni_DeleteWeakGlobalRef");
4358 #ifndef USDT2 4256 #ifndef USDT2
4359 DTRACE_PROBE2(hotspot_jni, DeleteWeakGlobalRef__entry, env, ref); 4257 DTRACE_PROBE2(hotspot_jni, DeleteWeakGlobalRef__entry, env, ref);
4360 #else /* USDT2 */ 4258 #else /* USDT2 */
4361 HOTSPOT_JNI_DELETEWEAKGLOBALREF_ENTRY( 4259 HOTSPOT_JNI_DELETEWEAKGLOBALREF_ENTRY(env, ref);
4362 env, ref);
4363 #endif /* USDT2 */ 4260 #endif /* USDT2 */
4364 JNIHandles::destroy_weak_global(ref); 4261 JNIHandles::destroy_weak_global(ref);
4365 #ifndef USDT2 4262 #ifndef USDT2
4366 DTRACE_PROBE(hotspot_jni, DeleteWeakGlobalRef__return); 4263 DTRACE_PROBE(hotspot_jni, DeleteWeakGlobalRef__return);
4367 #else /* USDT2 */ 4264 #else /* USDT2 */
4368 HOTSPOT_JNI_DELETEWEAKGLOBALREF_RETURN( 4265 HOTSPOT_JNI_DELETEWEAKGLOBALREF_RETURN();
4369 );
4370 #endif /* USDT2 */ 4266 #endif /* USDT2 */
4371 JNI_END 4267 JNI_END
4372 4268
4373 4269
4374 JNI_QUICK_ENTRY(jboolean, jni_ExceptionCheck(JNIEnv *env)) 4270 JNI_QUICK_ENTRY(jboolean, jni_ExceptionCheck(JNIEnv *env))
4375 JNIWrapper("jni_ExceptionCheck"); 4271 JNIWrapper("jni_ExceptionCheck");
4376 #ifndef USDT2 4272 #ifndef USDT2
4377 DTRACE_PROBE1(hotspot_jni, ExceptionCheck__entry, env); 4273 DTRACE_PROBE1(hotspot_jni, ExceptionCheck__entry, env);
4378 #else /* USDT2 */ 4274 #else /* USDT2 */
4379 HOTSPOT_JNI_EXCEPTIONCHECK_ENTRY( 4275 HOTSPOT_JNI_EXCEPTIONCHECK_ENTRY(env);
4380 env);
4381 #endif /* USDT2 */ 4276 #endif /* USDT2 */
4382 jni_check_async_exceptions(thread); 4277 jni_check_async_exceptions(thread);
4383 jboolean ret = (thread->has_pending_exception()) ? JNI_TRUE : JNI_FALSE; 4278 jboolean ret = (thread->has_pending_exception()) ? JNI_TRUE : JNI_FALSE;
4384 #ifndef USDT2 4279 #ifndef USDT2
4385 DTRACE_PROBE1(hotspot_jni, ExceptionCheck__return, ret); 4280 DTRACE_PROBE1(hotspot_jni, ExceptionCheck__return, ret);
4386 #else /* USDT2 */ 4281 #else /* USDT2 */
4387 HOTSPOT_JNI_EXCEPTIONCHECK_RETURN( 4282 HOTSPOT_JNI_EXCEPTIONCHECK_RETURN(ret);
4388 ret);
4389 #endif /* USDT2 */ 4283 #endif /* USDT2 */
4390 return ret; 4284 return ret;
4391 JNI_END 4285 JNI_END
4392 4286
4393 4287
4479 4373
4480 JNIWrapper("jni_NewDirectByteBuffer"); 4374 JNIWrapper("jni_NewDirectByteBuffer");
4481 #ifndef USDT2 4375 #ifndef USDT2
4482 DTRACE_PROBE3(hotspot_jni, NewDirectByteBuffer__entry, env, address, capacity); 4376 DTRACE_PROBE3(hotspot_jni, NewDirectByteBuffer__entry, env, address, capacity);
4483 #else /* USDT2 */ 4377 #else /* USDT2 */
4484 HOTSPOT_JNI_NEWDIRECTBYTEBUFFER_ENTRY( 4378 HOTSPOT_JNI_NEWDIRECTBYTEBUFFER_ENTRY(env, address, capacity);
4485 env, address, capacity);
4486 #endif /* USDT2 */ 4379 #endif /* USDT2 */
4487 4380
4488 if (!directBufferSupportInitializeEnded) { 4381 if (!directBufferSupportInitializeEnded) {
4489 if (!initializeDirectBufferSupport(env, thread)) { 4382 if (!initializeDirectBufferSupport(env, thread)) {
4490 #ifndef USDT2 4383 #ifndef USDT2
4491 DTRACE_PROBE1(hotspot_jni, NewDirectByteBuffer__return, NULL); 4384 DTRACE_PROBE1(hotspot_jni, NewDirectByteBuffer__return, NULL);
4492 #else /* USDT2 */ 4385 #else /* USDT2 */
4493 HOTSPOT_JNI_NEWDIRECTBYTEBUFFER_RETURN( 4386 HOTSPOT_JNI_NEWDIRECTBYTEBUFFER_RETURN(NULL);
4494 NULL);
4495 #endif /* USDT2 */ 4387 #endif /* USDT2 */
4496 return NULL; 4388 return NULL;
4497 } 4389 }
4498 } 4390 }
4499 4391
4504 jint cap = (jint) capacity; 4396 jint cap = (jint) capacity;
4505 jobject ret = env->NewObject(directByteBufferClass, directByteBufferConstructor, addr, cap); 4397 jobject ret = env->NewObject(directByteBufferClass, directByteBufferConstructor, addr, cap);
4506 #ifndef USDT2 4398 #ifndef USDT2
4507 DTRACE_PROBE1(hotspot_jni, NewDirectByteBuffer__return, ret); 4399 DTRACE_PROBE1(hotspot_jni, NewDirectByteBuffer__return, ret);
4508 #else /* USDT2 */ 4400 #else /* USDT2 */
4509 HOTSPOT_JNI_NEWDIRECTBYTEBUFFER_RETURN( 4401 HOTSPOT_JNI_NEWDIRECTBYTEBUFFER_RETURN(ret);
4510 ret);
4511 #endif /* USDT2 */ 4402 #endif /* USDT2 */
4512 return ret; 4403 return ret;
4513 } 4404 }
4514 4405
4515 #ifndef USDT2 4406 #ifndef USDT2
4526 4417
4527 JNIWrapper("jni_GetDirectBufferAddress"); 4418 JNIWrapper("jni_GetDirectBufferAddress");
4528 #ifndef USDT2 4419 #ifndef USDT2
4529 DTRACE_PROBE2(hotspot_jni, GetDirectBufferAddress__entry, env, buf); 4420 DTRACE_PROBE2(hotspot_jni, GetDirectBufferAddress__entry, env, buf);
4530 #else /* USDT2 */ 4421 #else /* USDT2 */
4531 HOTSPOT_JNI_GETDIRECTBUFFERADDRESS_ENTRY( 4422 HOTSPOT_JNI_GETDIRECTBUFFERADDRESS_ENTRY(env, buf);
4532 env, buf);
4533 #endif /* USDT2 */ 4423 #endif /* USDT2 */
4534 void* ret = NULL; 4424 void* ret = NULL;
4535 DT_RETURN_MARK(GetDirectBufferAddress, void*, (const void*&)ret); 4425 DT_RETURN_MARK(GetDirectBufferAddress, void*, (const void*&)ret);
4536 4426
4537 if (!directBufferSupportInitializeEnded) { 4427 if (!directBufferSupportInitializeEnded) {
4562 4452
4563 JNIWrapper("jni_GetDirectBufferCapacity"); 4453 JNIWrapper("jni_GetDirectBufferCapacity");
4564 #ifndef USDT2 4454 #ifndef USDT2
4565 DTRACE_PROBE2(hotspot_jni, GetDirectBufferCapacity__entry, env, buf); 4455 DTRACE_PROBE2(hotspot_jni, GetDirectBufferCapacity__entry, env, buf);
4566 #else /* USDT2 */ 4456 #else /* USDT2 */
4567 HOTSPOT_JNI_GETDIRECTBUFFERCAPACITY_ENTRY( 4457 HOTSPOT_JNI_GETDIRECTBUFFERCAPACITY_ENTRY(env, buf);
4568 env, buf);
4569 #endif /* USDT2 */ 4458 #endif /* USDT2 */
4570 jlong ret = -1; 4459 jlong ret = -1;
4571 DT_RETURN_MARK(GetDirectBufferCapacity, jlong, (const jlong&)ret); 4460 DT_RETURN_MARK(GetDirectBufferCapacity, jlong, (const jlong&)ret);
4572 4461
4573 if (!directBufferSupportInitializeEnded) { 4462 if (!directBufferSupportInitializeEnded) {
4594 JNI_LEAF(jint, jni_GetVersion(JNIEnv *env)) 4483 JNI_LEAF(jint, jni_GetVersion(JNIEnv *env))
4595 JNIWrapper("GetVersion"); 4484 JNIWrapper("GetVersion");
4596 #ifndef USDT2 4485 #ifndef USDT2
4597 DTRACE_PROBE1(hotspot_jni, GetVersion__entry, env); 4486 DTRACE_PROBE1(hotspot_jni, GetVersion__entry, env);
4598 #else /* USDT2 */ 4487 #else /* USDT2 */
4599 HOTSPOT_JNI_GETVERSION_ENTRY( 4488 HOTSPOT_JNI_GETVERSION_ENTRY(env);
4600 env);
4601 #endif /* USDT2 */ 4489 #endif /* USDT2 */
4602 #ifndef USDT2 4490 #ifndef USDT2
4603 DTRACE_PROBE1(hotspot_jni, GetVersion__return, CurrentVersion); 4491 DTRACE_PROBE1(hotspot_jni, GetVersion__return, CurrentVersion);
4604 #else /* USDT2 */ 4492 #else /* USDT2 */
4605 HOTSPOT_JNI_GETVERSION_RETURN( 4493 HOTSPOT_JNI_GETVERSION_RETURN(CurrentVersion);
4606 CurrentVersion);
4607 #endif /* USDT2 */ 4494 #endif /* USDT2 */
4608 return CurrentVersion; 4495 return CurrentVersion;
4609 JNI_END 4496 JNI_END
4610 4497
4611 extern struct JavaVM_ main_vm; 4498 extern struct JavaVM_ main_vm;
4613 JNI_LEAF(jint, jni_GetJavaVM(JNIEnv *env, JavaVM **vm)) 4500 JNI_LEAF(jint, jni_GetJavaVM(JNIEnv *env, JavaVM **vm))
4614 JNIWrapper("jni_GetJavaVM"); 4501 JNIWrapper("jni_GetJavaVM");
4615 #ifndef USDT2 4502 #ifndef USDT2
4616 DTRACE_PROBE2(hotspot_jni, GetJavaVM__entry, env, vm); 4503 DTRACE_PROBE2(hotspot_jni, GetJavaVM__entry, env, vm);
4617 #else /* USDT2 */ 4504 #else /* USDT2 */
4618 HOTSPOT_JNI_GETJAVAVM_ENTRY( 4505 HOTSPOT_JNI_GETJAVAVM_ENTRY(env, (void **) vm);
4619 env, (void **) vm);
4620 #endif /* USDT2 */ 4506 #endif /* USDT2 */
4621 *vm = (JavaVM *)(&main_vm); 4507 *vm = (JavaVM *)(&main_vm);
4622 #ifndef USDT2 4508 #ifndef USDT2
4623 DTRACE_PROBE1(hotspot_jni, GetJavaVM__return, JNI_OK); 4509 DTRACE_PROBE1(hotspot_jni, GetJavaVM__return, JNI_OK);
4624 #else /* USDT2 */ 4510 #else /* USDT2 */
4625 HOTSPOT_JNI_GETJAVAVM_RETURN( 4511 HOTSPOT_JNI_GETJAVAVM_RETURN(JNI_OK);
4626 JNI_OK);
4627 #endif /* USDT2 */ 4512 #endif /* USDT2 */
4628 return JNI_OK; 4513 return JNI_OK;
4629 JNI_END 4514 JNI_END
4630 4515
4631 // Structure containing all jni functions 4516 // Structure containing all jni functions
5012 4897
5013 _JNI_IMPORT_OR_EXPORT_ jint JNICALL JNI_GetDefaultJavaVMInitArgs(void *args_) { 4898 _JNI_IMPORT_OR_EXPORT_ jint JNICALL JNI_GetDefaultJavaVMInitArgs(void *args_) {
5014 #ifndef USDT2 4899 #ifndef USDT2
5015 HS_DTRACE_PROBE1(hotspot_jni, GetDefaultJavaVMInitArgs__entry, args_); 4900 HS_DTRACE_PROBE1(hotspot_jni, GetDefaultJavaVMInitArgs__entry, args_);
5016 #else /* USDT2 */ 4901 #else /* USDT2 */
5017 HOTSPOT_JNI_GETDEFAULTJAVAVMINITARGS_ENTRY( 4902 HOTSPOT_JNI_GETDEFAULTJAVAVMINITARGS_ENTRY(args_);
5018 args_);
5019 #endif /* USDT2 */ 4903 #endif /* USDT2 */
5020 JDK1_1InitArgs *args = (JDK1_1InitArgs *)args_; 4904 JDK1_1InitArgs *args = (JDK1_1InitArgs *)args_;
5021 jint ret = JNI_ERR; 4905 jint ret = JNI_ERR;
5022 DT_RETURN_MARK(GetDefaultJavaVMInitArgs, jint, (const jint&)ret); 4906 DT_RETURN_MARK(GetDefaultJavaVMInitArgs, jint, (const jint&)ret);
5023 4907
5106 4990
5107 _JNI_IMPORT_OR_EXPORT_ jint JNICALL JNI_CreateJavaVM(JavaVM **vm, void **penv, void *args) { 4991 _JNI_IMPORT_OR_EXPORT_ jint JNICALL JNI_CreateJavaVM(JavaVM **vm, void **penv, void *args) {
5108 #ifndef USDT2 4992 #ifndef USDT2
5109 HS_DTRACE_PROBE3(hotspot_jni, CreateJavaVM__entry, vm, penv, args); 4993 HS_DTRACE_PROBE3(hotspot_jni, CreateJavaVM__entry, vm, penv, args);
5110 #else /* USDT2 */ 4994 #else /* USDT2 */
5111 HOTSPOT_JNI_CREATEJAVAVM_ENTRY( 4995 HOTSPOT_JNI_CREATEJAVAVM_ENTRY((void **) vm, penv, args);
5112 (void **) vm, penv, args);
5113 #endif /* USDT2 */ 4996 #endif /* USDT2 */
5114 4997
5115 jint result = JNI_ERR; 4998 jint result = JNI_ERR;
5116 DT_RETURN_MARK(CreateJavaVM, jint, (const jint&)result); 4999 DT_RETURN_MARK(CreateJavaVM, jint, (const jint&)result);
5117 5000
5229 // JNIWrapper("GetCreatedJavaVMs"); 5112 // JNIWrapper("GetCreatedJavaVMs");
5230 #ifndef USDT2 5113 #ifndef USDT2
5231 HS_DTRACE_PROBE3(hotspot_jni, GetCreatedJavaVMs__entry, \ 5114 HS_DTRACE_PROBE3(hotspot_jni, GetCreatedJavaVMs__entry, \
5232 vm_buf, bufLen, numVMs); 5115 vm_buf, bufLen, numVMs);
5233 #else /* USDT2 */ 5116 #else /* USDT2 */
5234 HOTSPOT_JNI_GETCREATEDJAVAVMS_ENTRY( 5117 HOTSPOT_JNI_GETCREATEDJAVAVMS_ENTRY((void **) vm_buf, bufLen, (uintptr_t *) numVMs);
5235 (void **) vm_buf, bufLen, (uintptr_t *) numVMs);
5236 #endif /* USDT2 */ 5118 #endif /* USDT2 */
5237 if (vm_created) { 5119 if (vm_created) {
5238 if (numVMs != NULL) *numVMs = 1; 5120 if (numVMs != NULL) *numVMs = 1;
5239 if (bufLen > 0) *vm_buf = (JavaVM *)(&main_vm); 5121 if (bufLen > 0) *vm_buf = (JavaVM *)(&main_vm);
5240 } else { 5122 } else {
5241 if (numVMs != NULL) *numVMs = 0; 5123 if (numVMs != NULL) *numVMs = 0;
5242 } 5124 }
5243 #ifndef USDT2 5125 #ifndef USDT2
5244 HS_DTRACE_PROBE1(hotspot_jni, GetCreatedJavaVMs__return, JNI_OK); 5126 HS_DTRACE_PROBE1(hotspot_jni, GetCreatedJavaVMs__return, JNI_OK);
5245 #else /* USDT2 */ 5127 #else /* USDT2 */
5246 HOTSPOT_JNI_GETCREATEDJAVAVMS_RETURN( 5128 HOTSPOT_JNI_GETCREATEDJAVAVMS_RETURN(JNI_OK);
5247 JNI_OK);
5248 #endif /* USDT2 */ 5129 #endif /* USDT2 */
5249 return JNI_OK; 5130 return JNI_OK;
5250 } 5131 }
5251 5132
5252 extern "C" { 5133 extern "C" {
5260 5141
5261 jint JNICALL jni_DestroyJavaVM(JavaVM *vm) { 5142 jint JNICALL jni_DestroyJavaVM(JavaVM *vm) {
5262 #ifndef USDT2 5143 #ifndef USDT2
5263 DTRACE_PROBE1(hotspot_jni, DestroyJavaVM__entry, vm); 5144 DTRACE_PROBE1(hotspot_jni, DestroyJavaVM__entry, vm);
5264 #else /* USDT2 */ 5145 #else /* USDT2 */
5265 HOTSPOT_JNI_DESTROYJAVAVM_ENTRY( 5146 HOTSPOT_JNI_DESTROYJAVAVM_ENTRY(vm);
5266 vm);
5267 #endif /* USDT2 */ 5147 #endif /* USDT2 */
5268 jint res = JNI_ERR; 5148 jint res = JNI_ERR;
5269 DT_RETURN_MARK(DestroyJavaVM, jint, (const jint&)res); 5149 DT_RETURN_MARK(DestroyJavaVM, jint, (const jint&)res);
5270 5150
5271 if (!vm_created) { 5151 if (!vm_created) {
5417 5297
5418 jint JNICALL jni_AttachCurrentThread(JavaVM *vm, void **penv, void *_args) { 5298 jint JNICALL jni_AttachCurrentThread(JavaVM *vm, void **penv, void *_args) {
5419 #ifndef USDT2 5299 #ifndef USDT2
5420 DTRACE_PROBE3(hotspot_jni, AttachCurrentThread__entry, vm, penv, _args); 5300 DTRACE_PROBE3(hotspot_jni, AttachCurrentThread__entry, vm, penv, _args);
5421 #else /* USDT2 */ 5301 #else /* USDT2 */
5422 HOTSPOT_JNI_ATTACHCURRENTTHREAD_ENTRY( 5302 HOTSPOT_JNI_ATTACHCURRENTTHREAD_ENTRY(vm, penv, _args);
5423 vm, penv, _args);
5424 #endif /* USDT2 */ 5303 #endif /* USDT2 */
5425 if (!vm_created) { 5304 if (!vm_created) {
5426 #ifndef USDT2 5305 #ifndef USDT2
5427 DTRACE_PROBE1(hotspot_jni, AttachCurrentThread__return, JNI_ERR); 5306 DTRACE_PROBE1(hotspot_jni, AttachCurrentThread__return, JNI_ERR);
5428 #else /* USDT2 */ 5307 #else /* USDT2 */
5429 HOTSPOT_JNI_ATTACHCURRENTTHREAD_RETURN( 5308 HOTSPOT_JNI_ATTACHCURRENTTHREAD_RETURN((uint32_t) JNI_ERR);
5430 (uint32_t) JNI_ERR);
5431 #endif /* USDT2 */ 5309 #endif /* USDT2 */
5432 return JNI_ERR; 5310 return JNI_ERR;
5433 } 5311 }
5434 5312
5435 JNIWrapper("AttachCurrentThread"); 5313 JNIWrapper("AttachCurrentThread");
5436 jint ret = attach_current_thread(vm, penv, _args, false); 5314 jint ret = attach_current_thread(vm, penv, _args, false);
5437 #ifndef USDT2 5315 #ifndef USDT2
5438 DTRACE_PROBE1(hotspot_jni, AttachCurrentThread__return, ret); 5316 DTRACE_PROBE1(hotspot_jni, AttachCurrentThread__return, ret);
5439 #else /* USDT2 */ 5317 #else /* USDT2 */
5440 HOTSPOT_JNI_ATTACHCURRENTTHREAD_RETURN( 5318 HOTSPOT_JNI_ATTACHCURRENTTHREAD_RETURN(ret);
5441 ret);
5442 #endif /* USDT2 */ 5319 #endif /* USDT2 */
5443 return ret; 5320 return ret;
5444 } 5321 }
5445 5322
5446 5323
5447 jint JNICALL jni_DetachCurrentThread(JavaVM *vm) { 5324 jint JNICALL jni_DetachCurrentThread(JavaVM *vm) {
5448 #ifndef USDT2 5325 #ifndef USDT2
5449 DTRACE_PROBE1(hotspot_jni, DetachCurrentThread__entry, vm); 5326 DTRACE_PROBE1(hotspot_jni, DetachCurrentThread__entry, vm);
5450 #else /* USDT2 */ 5327 #else /* USDT2 */
5451 HOTSPOT_JNI_DETACHCURRENTTHREAD_ENTRY( 5328 HOTSPOT_JNI_DETACHCURRENTTHREAD_ENTRY(vm);
5452 vm);
5453 #endif /* USDT2 */ 5329 #endif /* USDT2 */
5454 VM_Exit::block_if_vm_exited(); 5330 VM_Exit::block_if_vm_exited();
5455 5331
5456 JNIWrapper("DetachCurrentThread"); 5332 JNIWrapper("DetachCurrentThread");
5457 5333
5458 // If the thread has been deattacted the operations is a no-op 5334 // If the thread has been deattacted the operations is a no-op
5459 if (ThreadLocalStorage::thread() == NULL) { 5335 if (ThreadLocalStorage::thread() == NULL) {
5460 #ifndef USDT2 5336 #ifndef USDT2
5461 DTRACE_PROBE1(hotspot_jni, DetachCurrentThread__return, JNI_OK); 5337 DTRACE_PROBE1(hotspot_jni, DetachCurrentThread__return, JNI_OK);
5462 #else /* USDT2 */ 5338 #else /* USDT2 */
5463 HOTSPOT_JNI_DETACHCURRENTTHREAD_RETURN( 5339 HOTSPOT_JNI_DETACHCURRENTTHREAD_RETURN(JNI_OK);
5464 JNI_OK);
5465 #endif /* USDT2 */ 5340 #endif /* USDT2 */
5466 return JNI_OK; 5341 return JNI_OK;
5467 } 5342 }
5468 5343
5469 JavaThread* thread = JavaThread::current(); 5344 JavaThread* thread = JavaThread::current();
5470 if (thread->has_last_Java_frame()) { 5345 if (thread->has_last_Java_frame()) {
5471 #ifndef USDT2 5346 #ifndef USDT2
5472 DTRACE_PROBE1(hotspot_jni, DetachCurrentThread__return, JNI_ERR); 5347 DTRACE_PROBE1(hotspot_jni, DetachCurrentThread__return, JNI_ERR);
5473 #else /* USDT2 */ 5348 #else /* USDT2 */
5474 HOTSPOT_JNI_DETACHCURRENTTHREAD_RETURN( 5349 HOTSPOT_JNI_DETACHCURRENTTHREAD_RETURN((uint32_t) JNI_ERR);
5475 (uint32_t) JNI_ERR);
5476 #endif /* USDT2 */ 5350 #endif /* USDT2 */
5477 // Can't detach a thread that's running java, that can't work. 5351 // Can't detach a thread that's running java, that can't work.
5478 return JNI_ERR; 5352 return JNI_ERR;
5479 } 5353 }
5480 5354
5495 delete thread; 5369 delete thread;
5496 5370
5497 #ifndef USDT2 5371 #ifndef USDT2
5498 DTRACE_PROBE1(hotspot_jni, DetachCurrentThread__return, JNI_OK); 5372 DTRACE_PROBE1(hotspot_jni, DetachCurrentThread__return, JNI_OK);
5499 #else /* USDT2 */ 5373 #else /* USDT2 */
5500 HOTSPOT_JNI_DETACHCURRENTTHREAD_RETURN( 5374 HOTSPOT_JNI_DETACHCURRENTTHREAD_RETURN(JNI_OK);
5501 JNI_OK);
5502 #endif /* USDT2 */ 5375 #endif /* USDT2 */
5503 return JNI_OK; 5376 return JNI_OK;
5504 } 5377 }
5505 5378
5506 #ifndef USDT2 5379 #ifndef USDT2
5512 5385
5513 jint JNICALL jni_GetEnv(JavaVM *vm, void **penv, jint version) { 5386 jint JNICALL jni_GetEnv(JavaVM *vm, void **penv, jint version) {
5514 #ifndef USDT2 5387 #ifndef USDT2
5515 DTRACE_PROBE3(hotspot_jni, GetEnv__entry, vm, penv, version); 5388 DTRACE_PROBE3(hotspot_jni, GetEnv__entry, vm, penv, version);
5516 #else /* USDT2 */ 5389 #else /* USDT2 */
5517 HOTSPOT_JNI_GETENV_ENTRY( 5390 HOTSPOT_JNI_GETENV_ENTRY(vm, penv, version);
5518 vm, penv, version);
5519 #endif /* USDT2 */ 5391 #endif /* USDT2 */
5520 jint ret = JNI_ERR; 5392 jint ret = JNI_ERR;
5521 DT_RETURN_MARK(GetEnv, jint, (const jint&)ret); 5393 DT_RETURN_MARK(GetEnv, jint, (const jint&)ret);
5522 5394
5523 if (!vm_created) { 5395 if (!vm_created) {
5571 5443
5572 jint JNICALL jni_AttachCurrentThreadAsDaemon(JavaVM *vm, void **penv, void *_args) { 5444 jint JNICALL jni_AttachCurrentThreadAsDaemon(JavaVM *vm, void **penv, void *_args) {
5573 #ifndef USDT2 5445 #ifndef USDT2
5574 DTRACE_PROBE3(hotspot_jni, AttachCurrentThreadAsDaemon__entry, vm, penv, _args); 5446 DTRACE_PROBE3(hotspot_jni, AttachCurrentThreadAsDaemon__entry, vm, penv, _args);
5575 #else /* USDT2 */ 5447 #else /* USDT2 */
5576 HOTSPOT_JNI_ATTACHCURRENTTHREADASDAEMON_ENTRY( 5448 HOTSPOT_JNI_ATTACHCURRENTTHREADASDAEMON_ENTRY(vm, penv, _args);
5577 vm, penv, _args);
5578 #endif /* USDT2 */ 5449 #endif /* USDT2 */
5579 if (!vm_created) { 5450 if (!vm_created) {
5580 #ifndef USDT2 5451 #ifndef USDT2
5581 DTRACE_PROBE1(hotspot_jni, AttachCurrentThreadAsDaemon__return, JNI_ERR); 5452 DTRACE_PROBE1(hotspot_jni, AttachCurrentThreadAsDaemon__return, JNI_ERR);
5582 #else /* USDT2 */ 5453 #else /* USDT2 */
5583 HOTSPOT_JNI_ATTACHCURRENTTHREADASDAEMON_RETURN( 5454 HOTSPOT_JNI_ATTACHCURRENTTHREADASDAEMON_RETURN((uint32_t) JNI_ERR);
5584 (uint32_t) JNI_ERR);
5585 #endif /* USDT2 */ 5455 #endif /* USDT2 */
5586 return JNI_ERR; 5456 return JNI_ERR;
5587 } 5457 }
5588 5458
5589 JNIWrapper("AttachCurrentThreadAsDaemon"); 5459 JNIWrapper("AttachCurrentThreadAsDaemon");
5590 jint ret = attach_current_thread(vm, penv, _args, true); 5460 jint ret = attach_current_thread(vm, penv, _args, true);
5591 #ifndef USDT2 5461 #ifndef USDT2
5592 DTRACE_PROBE1(hotspot_jni, AttachCurrentThreadAsDaemon__return, ret); 5462 DTRACE_PROBE1(hotspot_jni, AttachCurrentThreadAsDaemon__return, ret);
5593 #else /* USDT2 */ 5463 #else /* USDT2 */
5594 HOTSPOT_JNI_ATTACHCURRENTTHREADASDAEMON_RETURN( 5464 HOTSPOT_JNI_ATTACHCURRENTTHREADASDAEMON_RETURN(ret);
5595 ret);
5596 #endif /* USDT2 */ 5465 #endif /* USDT2 */
5597 return ret; 5466 return ret;
5598 } 5467 }
5599 5468
5600 5469