565 return obj; |
656 return obj; |
566 JNI_END |
657 JNI_END |
567 |
658 |
568 JNI_QUICK_ENTRY(jboolean, jni_IsAssignableFrom(JNIEnv *env, jclass sub, jclass super)) |
659 JNI_QUICK_ENTRY(jboolean, jni_IsAssignableFrom(JNIEnv *env, jclass sub, jclass super)) |
569 JNIWrapper("IsSubclassOf"); |
660 JNIWrapper("IsSubclassOf"); |
|
661 #ifndef USDT2 |
570 DTRACE_PROBE3(hotspot_jni, IsAssignableFrom__entry, env, sub, super); |
662 DTRACE_PROBE3(hotspot_jni, IsAssignableFrom__entry, env, sub, super); |
|
663 #else /* USDT2 */ |
|
664 HOTSPOT_JNI_ISASSIGNABLEFROM_ENTRY( |
|
665 env, sub, super); |
|
666 #endif /* USDT2 */ |
571 oop sub_mirror = JNIHandles::resolve_non_null(sub); |
667 oop sub_mirror = JNIHandles::resolve_non_null(sub); |
572 oop super_mirror = JNIHandles::resolve_non_null(super); |
668 oop super_mirror = JNIHandles::resolve_non_null(super); |
573 if (java_lang_Class::is_primitive(sub_mirror) || |
669 if (java_lang_Class::is_primitive(sub_mirror) || |
574 java_lang_Class::is_primitive(super_mirror)) { |
670 java_lang_Class::is_primitive(super_mirror)) { |
575 jboolean ret = (sub_mirror == super_mirror); |
671 jboolean ret = (sub_mirror == super_mirror); |
|
672 #ifndef USDT2 |
576 DTRACE_PROBE1(hotspot_jni, IsAssignableFrom__return, ret); |
673 DTRACE_PROBE1(hotspot_jni, IsAssignableFrom__return, ret); |
|
674 #else /* USDT2 */ |
|
675 HOTSPOT_JNI_ISASSIGNABLEFROM_RETURN( |
|
676 ret); |
|
677 #endif /* USDT2 */ |
577 return ret; |
678 return ret; |
578 } |
679 } |
579 klassOop sub_klass = java_lang_Class::as_klassOop(sub_mirror); |
680 klassOop sub_klass = java_lang_Class::as_klassOop(sub_mirror); |
580 klassOop super_klass = java_lang_Class::as_klassOop(super_mirror); |
681 klassOop super_klass = java_lang_Class::as_klassOop(super_mirror); |
581 assert(sub_klass != NULL && super_klass != NULL, "invalid arguments to jni_IsAssignableFrom"); |
682 assert(sub_klass != NULL && super_klass != NULL, "invalid arguments to jni_IsAssignableFrom"); |
582 jboolean ret = Klass::cast(sub_klass)->is_subtype_of(super_klass) ? |
683 jboolean ret = Klass::cast(sub_klass)->is_subtype_of(super_klass) ? |
583 JNI_TRUE : JNI_FALSE; |
684 JNI_TRUE : JNI_FALSE; |
|
685 #ifndef USDT2 |
584 DTRACE_PROBE1(hotspot_jni, IsAssignableFrom__return, ret); |
686 DTRACE_PROBE1(hotspot_jni, IsAssignableFrom__return, ret); |
|
687 #else /* USDT2 */ |
|
688 HOTSPOT_JNI_ISASSIGNABLEFROM_RETURN( |
|
689 ret); |
|
690 #endif /* USDT2 */ |
585 return ret; |
691 return ret; |
586 JNI_END |
692 JNI_END |
587 |
693 |
|
694 #ifndef USDT2 |
588 DT_RETURN_MARK_DECL(Throw, jint); |
695 DT_RETURN_MARK_DECL(Throw, jint); |
|
696 #else /* USDT2 */ |
|
697 DT_RETURN_MARK_DECL(Throw, jint |
|
698 , HOTSPOT_JNI_THROW_RETURN(_ret_ref)); |
|
699 #endif /* USDT2 */ |
589 |
700 |
590 JNI_ENTRY(jint, jni_Throw(JNIEnv *env, jthrowable obj)) |
701 JNI_ENTRY(jint, jni_Throw(JNIEnv *env, jthrowable obj)) |
591 JNIWrapper("Throw"); |
702 JNIWrapper("Throw"); |
|
703 #ifndef USDT2 |
592 DTRACE_PROBE2(hotspot_jni, Throw__entry, env, obj); |
704 DTRACE_PROBE2(hotspot_jni, Throw__entry, env, obj); |
|
705 #else /* USDT2 */ |
|
706 HOTSPOT_JNI_THROW_ENTRY( |
|
707 env, obj); |
|
708 #endif /* USDT2 */ |
593 jint ret = JNI_OK; |
709 jint ret = JNI_OK; |
594 DT_RETURN_MARK(Throw, jint, (const jint&)ret); |
710 DT_RETURN_MARK(Throw, jint, (const jint&)ret); |
595 |
711 |
596 THROW_OOP_(JNIHandles::resolve(obj), JNI_OK); |
712 THROW_OOP_(JNIHandles::resolve(obj), JNI_OK); |
597 ShouldNotReachHere(); |
713 ShouldNotReachHere(); |
598 JNI_END |
714 JNI_END |
599 |
715 |
|
716 #ifndef USDT2 |
600 DT_RETURN_MARK_DECL(ThrowNew, jint); |
717 DT_RETURN_MARK_DECL(ThrowNew, jint); |
|
718 #else /* USDT2 */ |
|
719 DT_RETURN_MARK_DECL(ThrowNew, jint |
|
720 , HOTSPOT_JNI_THROWNEW_RETURN(_ret_ref)); |
|
721 #endif /* USDT2 */ |
601 |
722 |
602 JNI_ENTRY(jint, jni_ThrowNew(JNIEnv *env, jclass clazz, const char *message)) |
723 JNI_ENTRY(jint, jni_ThrowNew(JNIEnv *env, jclass clazz, const char *message)) |
603 JNIWrapper("ThrowNew"); |
724 JNIWrapper("ThrowNew"); |
|
725 #ifndef USDT2 |
604 DTRACE_PROBE3(hotspot_jni, ThrowNew__entry, env, clazz, message); |
726 DTRACE_PROBE3(hotspot_jni, ThrowNew__entry, env, clazz, message); |
|
727 #else /* USDT2 */ |
|
728 HOTSPOT_JNI_THROWNEW_ENTRY( |
|
729 env, clazz, (char *) message); |
|
730 #endif /* USDT2 */ |
605 jint ret = JNI_OK; |
731 jint ret = JNI_OK; |
606 DT_RETURN_MARK(ThrowNew, jint, (const jint&)ret); |
732 DT_RETURN_MARK(ThrowNew, jint, (const jint&)ret); |
607 |
733 |
608 instanceKlass* k = instanceKlass::cast(java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(clazz))); |
734 instanceKlass* k = instanceKlass::cast(java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(clazz))); |
609 Symbol* name = k->name(); |
735 Symbol* name = k->name(); |
675 ". Uncaught exception of type %s.", |
816 ". Uncaught exception of type %s.", |
676 Klass::cast(ex->klass())->external_name()); |
817 Klass::cast(ex->klass())->external_name()); |
677 } |
818 } |
678 } |
819 } |
679 } |
820 } |
|
821 #ifndef USDT2 |
680 DTRACE_PROBE(hotspot_jni, ExceptionDescribe__return); |
822 DTRACE_PROBE(hotspot_jni, ExceptionDescribe__return); |
|
823 #else /* USDT2 */ |
|
824 HOTSPOT_JNI_EXCEPTIONDESCRIBE_RETURN( |
|
825 ); |
|
826 #endif /* USDT2 */ |
681 JNI_END |
827 JNI_END |
682 |
828 |
683 |
829 |
684 JNI_QUICK_ENTRY(void, jni_ExceptionClear(JNIEnv *env)) |
830 JNI_QUICK_ENTRY(void, jni_ExceptionClear(JNIEnv *env)) |
685 JNIWrapper("ExceptionClear"); |
831 JNIWrapper("ExceptionClear"); |
|
832 #ifndef USDT2 |
686 DTRACE_PROBE1(hotspot_jni, ExceptionClear__entry, env); |
833 DTRACE_PROBE1(hotspot_jni, ExceptionClear__entry, env); |
|
834 #else /* USDT2 */ |
|
835 HOTSPOT_JNI_EXCEPTIONCLEAR_ENTRY( |
|
836 env); |
|
837 #endif /* USDT2 */ |
687 |
838 |
688 // The jni code might be using this API to clear java thrown exception. |
839 // The jni code might be using this API to clear java thrown exception. |
689 // So just mark jvmti thread exception state as exception caught. |
840 // So just mark jvmti thread exception state as exception caught. |
690 JvmtiThreadState *state = JavaThread::current()->jvmti_thread_state(); |
841 JvmtiThreadState *state = JavaThread::current()->jvmti_thread_state(); |
691 if (state != NULL && state->is_exception_detected()) { |
842 if (state != NULL && state->is_exception_detected()) { |
692 state->set_exception_caught(); |
843 state->set_exception_caught(); |
693 } |
844 } |
694 thread->clear_pending_exception(); |
845 thread->clear_pending_exception(); |
|
846 #ifndef USDT2 |
695 DTRACE_PROBE(hotspot_jni, ExceptionClear__return); |
847 DTRACE_PROBE(hotspot_jni, ExceptionClear__return); |
|
848 #else /* USDT2 */ |
|
849 HOTSPOT_JNI_EXCEPTIONCLEAR_RETURN( |
|
850 ); |
|
851 #endif /* USDT2 */ |
696 JNI_END |
852 JNI_END |
697 |
853 |
698 |
854 |
699 JNI_ENTRY(void, jni_FatalError(JNIEnv *env, const char *msg)) |
855 JNI_ENTRY(void, jni_FatalError(JNIEnv *env, const char *msg)) |
700 JNIWrapper("FatalError"); |
856 JNIWrapper("FatalError"); |
|
857 #ifndef USDT2 |
701 DTRACE_PROBE2(hotspot_jni, FatalError__entry, env, msg); |
858 DTRACE_PROBE2(hotspot_jni, FatalError__entry, env, msg); |
|
859 #else /* USDT2 */ |
|
860 HOTSPOT_JNI_FATALERROR_ENTRY( |
|
861 env, (char *) msg); |
|
862 #endif /* USDT2 */ |
702 tty->print_cr("FATAL ERROR in native method: %s", msg); |
863 tty->print_cr("FATAL ERROR in native method: %s", msg); |
703 thread->print_stack(); |
864 thread->print_stack(); |
704 os::abort(); // Dump core and abort |
865 os::abort(); // Dump core and abort |
705 JNI_END |
866 JNI_END |
706 |
867 |
707 |
868 |
708 JNI_ENTRY(jint, jni_PushLocalFrame(JNIEnv *env, jint capacity)) |
869 JNI_ENTRY(jint, jni_PushLocalFrame(JNIEnv *env, jint capacity)) |
709 JNIWrapper("PushLocalFrame"); |
870 JNIWrapper("PushLocalFrame"); |
|
871 #ifndef USDT2 |
710 DTRACE_PROBE2(hotspot_jni, PushLocalFrame__entry, env, capacity); |
872 DTRACE_PROBE2(hotspot_jni, PushLocalFrame__entry, env, capacity); |
|
873 #else /* USDT2 */ |
|
874 HOTSPOT_JNI_PUSHLOCALFRAME_ENTRY( |
|
875 env, capacity); |
|
876 #endif /* USDT2 */ |
711 //%note jni_11 |
877 //%note jni_11 |
712 if (capacity < 0 && capacity > MAX_REASONABLE_LOCAL_CAPACITY) { |
878 if (capacity < 0 && capacity > MAX_REASONABLE_LOCAL_CAPACITY) { |
|
879 #ifndef USDT2 |
713 DTRACE_PROBE1(hotspot_jni, PushLocalFrame__return, JNI_ERR); |
880 DTRACE_PROBE1(hotspot_jni, PushLocalFrame__return, JNI_ERR); |
|
881 #else /* USDT2 */ |
|
882 HOTSPOT_JNI_PUSHLOCALFRAME_RETURN( |
|
883 (uint32_t)JNI_ERR); |
|
884 #endif /* USDT2 */ |
714 return JNI_ERR; |
885 return JNI_ERR; |
715 } |
886 } |
716 JNIHandleBlock* old_handles = thread->active_handles(); |
887 JNIHandleBlock* old_handles = thread->active_handles(); |
717 JNIHandleBlock* new_handles = JNIHandleBlock::allocate_block(thread); |
888 JNIHandleBlock* new_handles = JNIHandleBlock::allocate_block(thread); |
718 assert(new_handles != NULL, "should not be NULL"); |
889 assert(new_handles != NULL, "should not be NULL"); |
719 new_handles->set_pop_frame_link(old_handles); |
890 new_handles->set_pop_frame_link(old_handles); |
720 thread->set_active_handles(new_handles); |
891 thread->set_active_handles(new_handles); |
721 jint ret = JNI_OK; |
892 jint ret = JNI_OK; |
|
893 #ifndef USDT2 |
722 DTRACE_PROBE1(hotspot_jni, PushLocalFrame__return, ret); |
894 DTRACE_PROBE1(hotspot_jni, PushLocalFrame__return, ret); |
|
895 #else /* USDT2 */ |
|
896 HOTSPOT_JNI_PUSHLOCALFRAME_RETURN( |
|
897 ret); |
|
898 #endif /* USDT2 */ |
723 return ret; |
899 return ret; |
724 JNI_END |
900 JNI_END |
725 |
901 |
726 |
902 |
727 JNI_ENTRY(jobject, jni_PopLocalFrame(JNIEnv *env, jobject result)) |
903 JNI_ENTRY(jobject, jni_PopLocalFrame(JNIEnv *env, jobject result)) |
728 JNIWrapper("PopLocalFrame"); |
904 JNIWrapper("PopLocalFrame"); |
|
905 #ifndef USDT2 |
729 DTRACE_PROBE2(hotspot_jni, PopLocalFrame__entry, env, result); |
906 DTRACE_PROBE2(hotspot_jni, PopLocalFrame__entry, env, result); |
|
907 #else /* USDT2 */ |
|
908 HOTSPOT_JNI_POPLOCALFRAME_ENTRY( |
|
909 env, result); |
|
910 #endif /* USDT2 */ |
730 //%note jni_11 |
911 //%note jni_11 |
731 Handle result_handle(thread, JNIHandles::resolve(result)); |
912 Handle result_handle(thread, JNIHandles::resolve(result)); |
732 JNIHandleBlock* old_handles = thread->active_handles(); |
913 JNIHandleBlock* old_handles = thread->active_handles(); |
733 JNIHandleBlock* new_handles = old_handles->pop_frame_link(); |
914 JNIHandleBlock* new_handles = old_handles->pop_frame_link(); |
734 if (new_handles != NULL) { |
915 if (new_handles != NULL) { |
739 thread->set_active_handles(new_handles); |
920 thread->set_active_handles(new_handles); |
740 old_handles->set_pop_frame_link(NULL); // clear link we won't release new_handles below |
921 old_handles->set_pop_frame_link(NULL); // clear link we won't release new_handles below |
741 JNIHandleBlock::release_block(old_handles, thread); // may block |
922 JNIHandleBlock::release_block(old_handles, thread); // may block |
742 result = JNIHandles::make_local(thread, result_handle()); |
923 result = JNIHandles::make_local(thread, result_handle()); |
743 } |
924 } |
|
925 #ifndef USDT2 |
744 DTRACE_PROBE1(hotspot_jni, PopLocalFrame__return, result); |
926 DTRACE_PROBE1(hotspot_jni, PopLocalFrame__return, result); |
|
927 #else /* USDT2 */ |
|
928 HOTSPOT_JNI_POPLOCALFRAME_RETURN( |
|
929 result); |
|
930 #endif /* USDT2 */ |
745 return result; |
931 return result; |
746 JNI_END |
932 JNI_END |
747 |
933 |
748 |
934 |
749 JNI_ENTRY(jobject, jni_NewGlobalRef(JNIEnv *env, jobject ref)) |
935 JNI_ENTRY(jobject, jni_NewGlobalRef(JNIEnv *env, jobject ref)) |
750 JNIWrapper("NewGlobalRef"); |
936 JNIWrapper("NewGlobalRef"); |
|
937 #ifndef USDT2 |
751 DTRACE_PROBE2(hotspot_jni, NewGlobalRef__entry, env, ref); |
938 DTRACE_PROBE2(hotspot_jni, NewGlobalRef__entry, env, ref); |
|
939 #else /* USDT2 */ |
|
940 HOTSPOT_JNI_NEWGLOBALREF_ENTRY( |
|
941 env, ref); |
|
942 #endif /* USDT2 */ |
752 Handle ref_handle(thread, JNIHandles::resolve(ref)); |
943 Handle ref_handle(thread, JNIHandles::resolve(ref)); |
753 jobject ret = JNIHandles::make_global(ref_handle); |
944 jobject ret = JNIHandles::make_global(ref_handle); |
|
945 #ifndef USDT2 |
754 DTRACE_PROBE1(hotspot_jni, NewGlobalRef__return, ret); |
946 DTRACE_PROBE1(hotspot_jni, NewGlobalRef__return, ret); |
|
947 #else /* USDT2 */ |
|
948 HOTSPOT_JNI_NEWGLOBALREF_RETURN( |
|
949 ret); |
|
950 #endif /* USDT2 */ |
755 return ret; |
951 return ret; |
756 JNI_END |
952 JNI_END |
757 |
953 |
758 // Must be JNI_ENTRY (with HandleMark) |
954 // Must be JNI_ENTRY (with HandleMark) |
759 JNI_ENTRY_NO_PRESERVE(void, jni_DeleteGlobalRef(JNIEnv *env, jobject ref)) |
955 JNI_ENTRY_NO_PRESERVE(void, jni_DeleteGlobalRef(JNIEnv *env, jobject ref)) |
760 JNIWrapper("DeleteGlobalRef"); |
956 JNIWrapper("DeleteGlobalRef"); |
|
957 #ifndef USDT2 |
761 DTRACE_PROBE2(hotspot_jni, DeleteGlobalRef__entry, env, ref); |
958 DTRACE_PROBE2(hotspot_jni, DeleteGlobalRef__entry, env, ref); |
|
959 #else /* USDT2 */ |
|
960 HOTSPOT_JNI_DELETEGLOBALREF_ENTRY( |
|
961 env, ref); |
|
962 #endif /* USDT2 */ |
762 JNIHandles::destroy_global(ref); |
963 JNIHandles::destroy_global(ref); |
|
964 #ifndef USDT2 |
763 DTRACE_PROBE(hotspot_jni, DeleteGlobalRef__return); |
965 DTRACE_PROBE(hotspot_jni, DeleteGlobalRef__return); |
|
966 #else /* USDT2 */ |
|
967 HOTSPOT_JNI_DELETEGLOBALREF_RETURN( |
|
968 ); |
|
969 #endif /* USDT2 */ |
764 JNI_END |
970 JNI_END |
765 |
971 |
766 JNI_QUICK_ENTRY(void, jni_DeleteLocalRef(JNIEnv *env, jobject obj)) |
972 JNI_QUICK_ENTRY(void, jni_DeleteLocalRef(JNIEnv *env, jobject obj)) |
767 JNIWrapper("DeleteLocalRef"); |
973 JNIWrapper("DeleteLocalRef"); |
|
974 #ifndef USDT2 |
768 DTRACE_PROBE2(hotspot_jni, DeleteLocalRef__entry, env, obj); |
975 DTRACE_PROBE2(hotspot_jni, DeleteLocalRef__entry, env, obj); |
|
976 #else /* USDT2 */ |
|
977 HOTSPOT_JNI_DELETELOCALREF_ENTRY( |
|
978 env, obj); |
|
979 #endif /* USDT2 */ |
769 JNIHandles::destroy_local(obj); |
980 JNIHandles::destroy_local(obj); |
|
981 #ifndef USDT2 |
770 DTRACE_PROBE(hotspot_jni, DeleteLocalRef__return); |
982 DTRACE_PROBE(hotspot_jni, DeleteLocalRef__return); |
|
983 #else /* USDT2 */ |
|
984 HOTSPOT_JNI_DELETELOCALREF_RETURN( |
|
985 ); |
|
986 #endif /* USDT2 */ |
771 JNI_END |
987 JNI_END |
772 |
988 |
773 JNI_QUICK_ENTRY(jboolean, jni_IsSameObject(JNIEnv *env, jobject r1, jobject r2)) |
989 JNI_QUICK_ENTRY(jboolean, jni_IsSameObject(JNIEnv *env, jobject r1, jobject r2)) |
774 JNIWrapper("IsSameObject"); |
990 JNIWrapper("IsSameObject"); |
|
991 #ifndef USDT2 |
775 DTRACE_PROBE3(hotspot_jni, IsSameObject__entry, env, r1, r2); |
992 DTRACE_PROBE3(hotspot_jni, IsSameObject__entry, env, r1, r2); |
|
993 #else /* USDT2 */ |
|
994 HOTSPOT_JNI_ISSAMEOBJECT_ENTRY( |
|
995 env, r1, r2); |
|
996 #endif /* USDT2 */ |
776 oop a = JNIHandles::resolve(r1); |
997 oop a = JNIHandles::resolve(r1); |
777 oop b = JNIHandles::resolve(r2); |
998 oop b = JNIHandles::resolve(r2); |
778 jboolean ret = (a == b) ? JNI_TRUE : JNI_FALSE; |
999 jboolean ret = (a == b) ? JNI_TRUE : JNI_FALSE; |
|
1000 #ifndef USDT2 |
779 DTRACE_PROBE1(hotspot_jni, IsSameObject__return, ret); |
1001 DTRACE_PROBE1(hotspot_jni, IsSameObject__return, ret); |
|
1002 #else /* USDT2 */ |
|
1003 HOTSPOT_JNI_ISSAMEOBJECT_RETURN( |
|
1004 ret); |
|
1005 #endif /* USDT2 */ |
780 return ret; |
1006 return ret; |
781 JNI_END |
1007 JNI_END |
782 |
1008 |
783 |
1009 |
784 JNI_ENTRY(jobject, jni_NewLocalRef(JNIEnv *env, jobject ref)) |
1010 JNI_ENTRY(jobject, jni_NewLocalRef(JNIEnv *env, jobject ref)) |
785 JNIWrapper("NewLocalRef"); |
1011 JNIWrapper("NewLocalRef"); |
|
1012 #ifndef USDT2 |
786 DTRACE_PROBE2(hotspot_jni, NewLocalRef__entry, env, ref); |
1013 DTRACE_PROBE2(hotspot_jni, NewLocalRef__entry, env, ref); |
|
1014 #else /* USDT2 */ |
|
1015 HOTSPOT_JNI_NEWLOCALREF_ENTRY( |
|
1016 env, ref); |
|
1017 #endif /* USDT2 */ |
787 jobject ret = JNIHandles::make_local(env, JNIHandles::resolve(ref)); |
1018 jobject ret = JNIHandles::make_local(env, JNIHandles::resolve(ref)); |
|
1019 #ifndef USDT2 |
788 DTRACE_PROBE1(hotspot_jni, NewLocalRef__return, ret); |
1020 DTRACE_PROBE1(hotspot_jni, NewLocalRef__return, ret); |
|
1021 #else /* USDT2 */ |
|
1022 HOTSPOT_JNI_NEWLOCALREF_RETURN( |
|
1023 ret); |
|
1024 #endif /* USDT2 */ |
789 return ret; |
1025 return ret; |
790 JNI_END |
1026 JNI_END |
791 |
1027 |
792 JNI_LEAF(jint, jni_EnsureLocalCapacity(JNIEnv *env, jint capacity)) |
1028 JNI_LEAF(jint, jni_EnsureLocalCapacity(JNIEnv *env, jint capacity)) |
793 JNIWrapper("EnsureLocalCapacity"); |
1029 JNIWrapper("EnsureLocalCapacity"); |
|
1030 #ifndef USDT2 |
794 DTRACE_PROBE2(hotspot_jni, EnsureLocalCapacity__entry, env, capacity); |
1031 DTRACE_PROBE2(hotspot_jni, EnsureLocalCapacity__entry, env, capacity); |
|
1032 #else /* USDT2 */ |
|
1033 HOTSPOT_JNI_ENSURELOCALCAPACITY_ENTRY( |
|
1034 env, capacity); |
|
1035 #endif /* USDT2 */ |
795 jint ret; |
1036 jint ret; |
796 if (capacity >= 0 && capacity <= MAX_REASONABLE_LOCAL_CAPACITY) { |
1037 if (capacity >= 0 && capacity <= MAX_REASONABLE_LOCAL_CAPACITY) { |
797 ret = JNI_OK; |
1038 ret = JNI_OK; |
798 } else { |
1039 } else { |
799 ret = JNI_ERR; |
1040 ret = JNI_ERR; |
800 } |
1041 } |
|
1042 #ifndef USDT2 |
801 DTRACE_PROBE1(hotspot_jni, EnsureLocalCapacity__return, ret); |
1043 DTRACE_PROBE1(hotspot_jni, EnsureLocalCapacity__return, ret); |
|
1044 #else /* USDT2 */ |
|
1045 HOTSPOT_JNI_ENSURELOCALCAPACITY_RETURN( |
|
1046 ret); |
|
1047 #endif /* USDT2 */ |
802 return ret; |
1048 return ret; |
803 JNI_END |
1049 JNI_END |
804 |
1050 |
805 // Return the Handle Type |
1051 // Return the Handle Type |
806 JNI_LEAF(jobjectRefType, jni_GetObjectRefType(JNIEnv *env, jobject obj)) |
1052 JNI_LEAF(jobjectRefType, jni_GetObjectRefType(JNIEnv *env, jobject obj)) |
807 JNIWrapper("GetObjectRefType"); |
1053 JNIWrapper("GetObjectRefType"); |
|
1054 #ifndef USDT2 |
808 DTRACE_PROBE2(hotspot_jni, GetObjectRefType__entry, env, obj); |
1055 DTRACE_PROBE2(hotspot_jni, GetObjectRefType__entry, env, obj); |
|
1056 #else /* USDT2 */ |
|
1057 HOTSPOT_JNI_GETOBJECTREFTYPE_ENTRY( |
|
1058 env, obj); |
|
1059 #endif /* USDT2 */ |
809 jobjectRefType ret; |
1060 jobjectRefType ret; |
810 if (JNIHandles::is_local_handle(thread, obj) || |
1061 if (JNIHandles::is_local_handle(thread, obj) || |
811 JNIHandles::is_frame_handle(thread, obj)) |
1062 JNIHandles::is_frame_handle(thread, obj)) |
812 ret = JNILocalRefType; |
1063 ret = JNILocalRefType; |
813 else if (JNIHandles::is_global_handle(obj)) |
1064 else if (JNIHandles::is_global_handle(obj)) |
814 ret = JNIGlobalRefType; |
1065 ret = JNIGlobalRefType; |
815 else if (JNIHandles::is_weak_global_handle(obj)) |
1066 else if (JNIHandles::is_weak_global_handle(obj)) |
816 ret = JNIWeakGlobalRefType; |
1067 ret = JNIWeakGlobalRefType; |
817 else |
1068 else |
818 ret = JNIInvalidRefType; |
1069 ret = JNIInvalidRefType; |
|
1070 #ifndef USDT2 |
819 DTRACE_PROBE1(hotspot_jni, GetObjectRefType__return, ret); |
1071 DTRACE_PROBE1(hotspot_jni, GetObjectRefType__return, ret); |
|
1072 #else /* USDT2 */ |
|
1073 HOTSPOT_JNI_GETOBJECTREFTYPE_RETURN( |
|
1074 (void *) ret); |
|
1075 #endif /* USDT2 */ |
820 return ret; |
1076 return ret; |
821 JNI_END |
1077 JNI_END |
822 |
1078 |
823 |
1079 |
824 class JNI_ArgumentPusher : public SignatureIterator { |
1080 class JNI_ArgumentPusher : public SignatureIterator { |
1165 instanceKlass::cast(k())->initialize(CHECK_NULL); |
1421 instanceKlass::cast(k())->initialize(CHECK_NULL); |
1166 instanceOop ih = instanceKlass::cast(k())->allocate_instance(THREAD); |
1422 instanceOop ih = instanceKlass::cast(k())->allocate_instance(THREAD); |
1167 return ih; |
1423 return ih; |
1168 } |
1424 } |
1169 |
1425 |
|
1426 #ifndef USDT2 |
1170 DT_RETURN_MARK_DECL(AllocObject, jobject); |
1427 DT_RETURN_MARK_DECL(AllocObject, jobject); |
|
1428 #else /* USDT2 */ |
|
1429 DT_RETURN_MARK_DECL(AllocObject, jobject |
|
1430 , HOTSPOT_JNI_ALLOCOBJECT_RETURN(_ret_ref)); |
|
1431 #endif /* USDT2 */ |
1171 |
1432 |
1172 JNI_ENTRY(jobject, jni_AllocObject(JNIEnv *env, jclass clazz)) |
1433 JNI_ENTRY(jobject, jni_AllocObject(JNIEnv *env, jclass clazz)) |
1173 JNIWrapper("AllocObject"); |
1434 JNIWrapper("AllocObject"); |
1174 |
1435 |
|
1436 #ifndef USDT2 |
1175 DTRACE_PROBE2(hotspot_jni, AllocObject__entry, env, clazz); |
1437 DTRACE_PROBE2(hotspot_jni, AllocObject__entry, env, clazz); |
|
1438 #else /* USDT2 */ |
|
1439 HOTSPOT_JNI_ALLOCOBJECT_ENTRY( |
|
1440 env, clazz); |
|
1441 #endif /* USDT2 */ |
1176 jobject ret = NULL; |
1442 jobject ret = NULL; |
1177 DT_RETURN_MARK(AllocObject, jobject, (const jobject&)ret); |
1443 DT_RETURN_MARK(AllocObject, jobject, (const jobject&)ret); |
1178 |
1444 |
1179 instanceOop i = alloc_object(clazz, CHECK_NULL); |
1445 instanceOop i = alloc_object(clazz, CHECK_NULL); |
1180 ret = JNIHandles::make_local(env, i); |
1446 ret = JNIHandles::make_local(env, i); |
1181 return ret; |
1447 return ret; |
1182 JNI_END |
1448 JNI_END |
1183 |
1449 |
|
1450 #ifndef USDT2 |
1184 DT_RETURN_MARK_DECL(NewObjectA, jobject); |
1451 DT_RETURN_MARK_DECL(NewObjectA, jobject); |
|
1452 #else /* USDT2 */ |
|
1453 DT_RETURN_MARK_DECL(NewObjectA, jobject |
|
1454 , HOTSPOT_JNI_NEWOBJECTA_RETURN(_ret_ref)); |
|
1455 #endif /* USDT2 */ |
1185 |
1456 |
1186 JNI_ENTRY(jobject, jni_NewObjectA(JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args)) |
1457 JNI_ENTRY(jobject, jni_NewObjectA(JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args)) |
1187 JNIWrapper("NewObjectA"); |
1458 JNIWrapper("NewObjectA"); |
|
1459 #ifndef USDT2 |
1188 DTRACE_PROBE3(hotspot_jni, NewObjectA__entry, env, clazz, methodID); |
1460 DTRACE_PROBE3(hotspot_jni, NewObjectA__entry, env, clazz, methodID); |
|
1461 #else /* USDT2 */ |
|
1462 HOTSPOT_JNI_NEWOBJECTA_ENTRY( |
|
1463 env, clazz, (uintptr_t) methodID); |
|
1464 #endif /* USDT2 */ |
1189 jobject obj = NULL; |
1465 jobject obj = NULL; |
1190 DT_RETURN_MARK(NewObjectA, jobject, (const jobject)obj); |
1466 DT_RETURN_MARK(NewObjectA, jobject, (const jobject)obj); |
1191 |
1467 |
1192 instanceOop i = alloc_object(clazz, CHECK_NULL); |
1468 instanceOop i = alloc_object(clazz, CHECK_NULL); |
1193 obj = JNIHandles::make_local(env, i); |
1469 obj = JNIHandles::make_local(env, i); |
1315 |
1631 |
1316 |
1632 |
1317 JNI_ENTRY(jmethodID, jni_GetMethodID(JNIEnv *env, jclass clazz, |
1633 JNI_ENTRY(jmethodID, jni_GetMethodID(JNIEnv *env, jclass clazz, |
1318 const char *name, const char *sig)) |
1634 const char *name, const char *sig)) |
1319 JNIWrapper("GetMethodID"); |
1635 JNIWrapper("GetMethodID"); |
|
1636 #ifndef USDT2 |
1320 DTRACE_PROBE4(hotspot_jni, GetMethodID__entry, env, clazz, name, sig); |
1637 DTRACE_PROBE4(hotspot_jni, GetMethodID__entry, env, clazz, name, sig); |
|
1638 #else /* USDT2 */ |
|
1639 HOTSPOT_JNI_GETMETHODID_ENTRY( |
|
1640 env, clazz, (char *) name, (char *) sig); |
|
1641 #endif /* USDT2 */ |
1321 jmethodID ret = get_method_id(env, clazz, name, sig, false, thread); |
1642 jmethodID ret = get_method_id(env, clazz, name, sig, false, thread); |
|
1643 #ifndef USDT2 |
1322 DTRACE_PROBE1(hotspot_jni, GetMethodID__return, ret); |
1644 DTRACE_PROBE1(hotspot_jni, GetMethodID__return, ret); |
|
1645 #else /* USDT2 */ |
|
1646 HOTSPOT_JNI_GETMETHODID_RETURN( |
|
1647 (uintptr_t) ret); |
|
1648 #endif /* USDT2 */ |
1323 return ret; |
1649 return ret; |
1324 JNI_END |
1650 JNI_END |
1325 |
1651 |
1326 |
1652 |
1327 JNI_ENTRY(jmethodID, jni_GetStaticMethodID(JNIEnv *env, jclass clazz, |
1653 JNI_ENTRY(jmethodID, jni_GetStaticMethodID(JNIEnv *env, jclass clazz, |
1328 const char *name, const char *sig)) |
1654 const char *name, const char *sig)) |
1329 JNIWrapper("GetStaticMethodID"); |
1655 JNIWrapper("GetStaticMethodID"); |
|
1656 #ifndef USDT2 |
1330 DTRACE_PROBE4(hotspot_jni, GetStaticMethodID__entry, env, clazz, name, sig); |
1657 DTRACE_PROBE4(hotspot_jni, GetStaticMethodID__entry, env, clazz, name, sig); |
|
1658 #else /* USDT2 */ |
|
1659 HOTSPOT_JNI_GETSTATICMETHODID_ENTRY( |
|
1660 env, (char *) clazz, (char *) name, (char *)sig); |
|
1661 #endif /* USDT2 */ |
1331 jmethodID ret = get_method_id(env, clazz, name, sig, true, thread); |
1662 jmethodID ret = get_method_id(env, clazz, name, sig, true, thread); |
|
1663 #ifndef USDT2 |
1332 DTRACE_PROBE1(hotspot_jni, GetStaticMethodID__return, ret); |
1664 DTRACE_PROBE1(hotspot_jni, GetStaticMethodID__return, ret); |
|
1665 #else /* USDT2 */ |
|
1666 HOTSPOT_JNI_GETSTATICMETHODID_RETURN( |
|
1667 (uintptr_t) ret); |
|
1668 #endif /* USDT2 */ |
1333 return ret; |
1669 return ret; |
1334 JNI_END |
1670 JNI_END |
1335 |
1671 |
1336 |
1672 |
1337 |
1673 |
1338 // |
1674 // |
1339 // Calling Methods |
1675 // Calling Methods |
1340 // |
1676 // |
1341 |
1677 |
1342 |
1678 #ifndef USDT2 |
1343 #define DEFINE_CALLMETHOD(ResultType, Result, Tag) \ |
1679 #define DEFINE_CALLMETHOD(ResultType, Result, Tag) \ |
1344 \ |
1680 \ |
1345 DT_RETURN_MARK_DECL_FOR(Result, Call##Result##Method, ResultType);\ |
1681 DT_RETURN_MARK_DECL_FOR(Result, Call##Result##Method, ResultType);\ |
1346 DT_RETURN_MARK_DECL_FOR(Result, Call##Result##MethodV, ResultType);\ |
1682 DT_RETURN_MARK_DECL_FOR(Result, Call##Result##MethodV, ResultType);\ |
1347 DT_RETURN_MARK_DECL_FOR(Result, Call##Result##MethodA, ResultType);\ |
1683 DT_RETURN_MARK_DECL_FOR(Result, Call##Result##MethodA, ResultType);\ |
1348 \ |
1684 \ |
1349 JNI_ENTRY(ResultType, \ |
1685 JNI_ENTRY(ResultType, \ |
1350 jni_Call##Result##Method(JNIEnv *env, jobject obj, jmethodID methodID, ...)) \ |
1686 jni_Call##Result##Method(JNIEnv *env, jobject obj, jmethodID methodID, ...)) \ |
1351 JNIWrapper("Call" XSTR(Result) "Method"); \ |
1687 JNIWrapper("Call" XSTR(Result) "Method"); \ |
1352 \ |
1688 \ |
1353 DTRACE_PROBE3(hotspot_jni, Call##Result##Method__entry, env, obj, methodID);\ |
1689 DTRACE_PROBE3(hotspot_jni, Call##Result##Method__entry, env, obj, methodID); \ |
1354 ResultType ret = 0;\ |
1690 ResultType ret = 0;\ |
1355 DT_RETURN_MARK_FOR(Result, Call##Result##Method, ResultType, \ |
1691 DT_RETURN_MARK_FOR(Result, Call##Result##Method, ResultType, \ |
1356 (const ResultType&)ret);\ |
1692 (const ResultType&)ret);\ |
1357 \ |
1693 \ |
1358 va_list args; \ |
1694 va_list args; \ |
1412 |
1748 |
1413 DT_VOID_RETURN_MARK_DECL(CallVoidMethod); |
1749 DT_VOID_RETURN_MARK_DECL(CallVoidMethod); |
1414 DT_VOID_RETURN_MARK_DECL(CallVoidMethodV); |
1750 DT_VOID_RETURN_MARK_DECL(CallVoidMethodV); |
1415 DT_VOID_RETURN_MARK_DECL(CallVoidMethodA); |
1751 DT_VOID_RETURN_MARK_DECL(CallVoidMethodA); |
1416 |
1752 |
|
1753 #else /* USDT2 */ |
|
1754 |
|
1755 #define DEFINE_CALLMETHOD(ResultType, Result, Tag \ |
|
1756 , EntryProbe, ReturnProbe) \ |
|
1757 \ |
|
1758 DT_RETURN_MARK_DECL_FOR(Result, Call##Result##Method, ResultType \ |
|
1759 , ReturnProbe); \ |
|
1760 \ |
|
1761 JNI_ENTRY(ResultType, \ |
|
1762 jni_Call##Result##Method(JNIEnv *env, jobject obj, jmethodID methodID, ...)) \ |
|
1763 JNIWrapper("Call" XSTR(Result) "Method"); \ |
|
1764 \ |
|
1765 EntryProbe; \ |
|
1766 ResultType ret = 0;\ |
|
1767 DT_RETURN_MARK_FOR(Result, Call##Result##Method, ResultType, \ |
|
1768 (const ResultType&)ret);\ |
|
1769 \ |
|
1770 va_list args; \ |
|
1771 va_start(args, methodID); \ |
|
1772 JavaValue jvalue(Tag); \ |
|
1773 JNI_ArgumentPusherVaArg ap(methodID, args); \ |
|
1774 jni_invoke_nonstatic(env, &jvalue, obj, JNI_VIRTUAL, methodID, &ap, CHECK_0); \ |
|
1775 va_end(args); \ |
|
1776 ret = jvalue.get_##ResultType(); \ |
|
1777 return ret;\ |
|
1778 JNI_END |
|
1779 |
|
1780 // the runtime type of subword integral basic types is integer |
|
1781 DEFINE_CALLMETHOD(jboolean, Boolean, T_BOOLEAN |
|
1782 , HOTSPOT_JNI_CALLBOOLEANMETHOD_ENTRY(env, obj, (uintptr_t)methodID), |
|
1783 HOTSPOT_JNI_CALLBOOLEANMETHOD_RETURN(_ret_ref)) |
|
1784 DEFINE_CALLMETHOD(jbyte, Byte, T_BYTE |
|
1785 , HOTSPOT_JNI_CALLBYTEMETHOD_ENTRY(env, obj, (uintptr_t)methodID), |
|
1786 HOTSPOT_JNI_CALLBYTEMETHOD_RETURN(_ret_ref)) |
|
1787 DEFINE_CALLMETHOD(jchar, Char, T_CHAR |
|
1788 , HOTSPOT_JNI_CALLCHARMETHOD_ENTRY(env, obj, (uintptr_t)methodID), |
|
1789 HOTSPOT_JNI_CALLCHARMETHOD_RETURN(_ret_ref)) |
|
1790 DEFINE_CALLMETHOD(jshort, Short, T_SHORT |
|
1791 , HOTSPOT_JNI_CALLSHORTMETHOD_ENTRY(env, obj, (uintptr_t)methodID), |
|
1792 HOTSPOT_JNI_CALLSHORTMETHOD_RETURN(_ret_ref)) |
|
1793 |
|
1794 DEFINE_CALLMETHOD(jobject, Object, T_OBJECT |
|
1795 , HOTSPOT_JNI_CALLOBJECTMETHOD_ENTRY(env, obj, (uintptr_t)methodID), |
|
1796 HOTSPOT_JNI_CALLOBJECTMETHOD_RETURN(_ret_ref)) |
|
1797 DEFINE_CALLMETHOD(jint, Int, T_INT, |
|
1798 HOTSPOT_JNI_CALLINTMETHOD_ENTRY(env, obj, (uintptr_t)methodID), |
|
1799 HOTSPOT_JNI_CALLINTMETHOD_RETURN(_ret_ref)) |
|
1800 DEFINE_CALLMETHOD(jlong, Long, T_LONG |
|
1801 , HOTSPOT_JNI_CALLLONGMETHOD_ENTRY(env, obj, (uintptr_t)methodID), |
|
1802 HOTSPOT_JNI_CALLLONGMETHOD_RETURN(_ret_ref)) |
|
1803 // Float and double probes don't return value because dtrace doesn't currently support it |
|
1804 DEFINE_CALLMETHOD(jfloat, Float, T_FLOAT |
|
1805 , HOTSPOT_JNI_CALLFLOATMETHOD_ENTRY(env, obj, (uintptr_t)methodID), |
|
1806 HOTSPOT_JNI_CALLFLOATMETHOD_RETURN()) |
|
1807 DEFINE_CALLMETHOD(jdouble, Double, T_DOUBLE |
|
1808 , HOTSPOT_JNI_CALLDOUBLEMETHOD_ENTRY(env, obj, (uintptr_t)methodID), |
|
1809 HOTSPOT_JNI_CALLDOUBLEMETHOD_RETURN()) |
|
1810 |
|
1811 #define DEFINE_CALLMETHODV(ResultType, Result, Tag \ |
|
1812 , EntryProbe, ReturnProbe) \ |
|
1813 \ |
|
1814 DT_RETURN_MARK_DECL_FOR(Result, Call##Result##MethodV, ResultType \ |
|
1815 , ReturnProbe); \ |
|
1816 \ |
|
1817 JNI_ENTRY(ResultType, \ |
|
1818 jni_Call##Result##MethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)) \ |
|
1819 JNIWrapper("Call" XSTR(Result) "MethodV"); \ |
|
1820 \ |
|
1821 EntryProbe;\ |
|
1822 ResultType ret = 0;\ |
|
1823 DT_RETURN_MARK_FOR(Result, Call##Result##MethodV, ResultType, \ |
|
1824 (const ResultType&)ret);\ |
|
1825 \ |
|
1826 JavaValue jvalue(Tag); \ |
|
1827 JNI_ArgumentPusherVaArg ap(methodID, args); \ |
|
1828 jni_invoke_nonstatic(env, &jvalue, obj, JNI_VIRTUAL, methodID, &ap, CHECK_0); \ |
|
1829 ret = jvalue.get_##ResultType(); \ |
|
1830 return ret;\ |
|
1831 JNI_END |
|
1832 |
|
1833 // the runtime type of subword integral basic types is integer |
|
1834 DEFINE_CALLMETHODV(jboolean, Boolean, T_BOOLEAN |
|
1835 , HOTSPOT_JNI_CALLBOOLEANMETHOD_ENTRY(env, obj, (uintptr_t)methodID), |
|
1836 HOTSPOT_JNI_CALLBOOLEANMETHOD_RETURN(_ret_ref)) |
|
1837 DEFINE_CALLMETHODV(jbyte, Byte, T_BYTE |
|
1838 , HOTSPOT_JNI_CALLBYTEMETHOD_ENTRY(env, obj, (uintptr_t)methodID), |
|
1839 HOTSPOT_JNI_CALLBYTEMETHOD_RETURN(_ret_ref)) |
|
1840 DEFINE_CALLMETHODV(jchar, Char, T_CHAR |
|
1841 , HOTSPOT_JNI_CALLCHARMETHOD_ENTRY(env, obj, (uintptr_t)methodID), |
|
1842 HOTSPOT_JNI_CALLCHARMETHOD_RETURN(_ret_ref)) |
|
1843 DEFINE_CALLMETHODV(jshort, Short, T_SHORT |
|
1844 , HOTSPOT_JNI_CALLSHORTMETHOD_ENTRY(env, obj, (uintptr_t)methodID), |
|
1845 HOTSPOT_JNI_CALLSHORTMETHOD_RETURN(_ret_ref)) |
|
1846 |
|
1847 DEFINE_CALLMETHODV(jobject, Object, T_OBJECT |
|
1848 , HOTSPOT_JNI_CALLOBJECTMETHOD_ENTRY(env, obj, (uintptr_t)methodID), |
|
1849 HOTSPOT_JNI_CALLOBJECTMETHOD_RETURN(_ret_ref)) |
|
1850 DEFINE_CALLMETHODV(jint, Int, T_INT, |
|
1851 HOTSPOT_JNI_CALLINTMETHOD_ENTRY(env, obj, (uintptr_t)methodID), |
|
1852 HOTSPOT_JNI_CALLINTMETHOD_RETURN(_ret_ref)) |
|
1853 DEFINE_CALLMETHODV(jlong, Long, T_LONG |
|
1854 , HOTSPOT_JNI_CALLLONGMETHOD_ENTRY(env, obj, (uintptr_t)methodID), |
|
1855 HOTSPOT_JNI_CALLLONGMETHOD_RETURN(_ret_ref)) |
|
1856 // Float and double probes don't return value because dtrace doesn't currently support it |
|
1857 DEFINE_CALLMETHODV(jfloat, Float, T_FLOAT |
|
1858 , HOTSPOT_JNI_CALLFLOATMETHOD_ENTRY(env, obj, (uintptr_t)methodID), |
|
1859 HOTSPOT_JNI_CALLFLOATMETHOD_RETURN()) |
|
1860 DEFINE_CALLMETHODV(jdouble, Double, T_DOUBLE |
|
1861 , HOTSPOT_JNI_CALLDOUBLEMETHOD_ENTRY(env, obj, (uintptr_t)methodID), |
|
1862 HOTSPOT_JNI_CALLDOUBLEMETHOD_RETURN()) |
|
1863 |
|
1864 #define DEFINE_CALLMETHODA(ResultType, Result, Tag \ |
|
1865 , EntryProbe, ReturnProbe) \ |
|
1866 \ |
|
1867 DT_RETURN_MARK_DECL_FOR(Result, Call##Result##MethodA, ResultType \ |
|
1868 , ReturnProbe); \ |
|
1869 \ |
|
1870 JNI_ENTRY(ResultType, \ |
|
1871 jni_Call##Result##MethodA(JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args)) \ |
|
1872 JNIWrapper("Call" XSTR(Result) "MethodA"); \ |
|
1873 EntryProbe; \ |
|
1874 ResultType ret = 0;\ |
|
1875 DT_RETURN_MARK_FOR(Result, Call##Result##MethodA, ResultType, \ |
|
1876 (const ResultType&)ret);\ |
|
1877 \ |
|
1878 JavaValue jvalue(Tag); \ |
|
1879 JNI_ArgumentPusherArray ap(methodID, args); \ |
|
1880 jni_invoke_nonstatic(env, &jvalue, obj, JNI_VIRTUAL, methodID, &ap, CHECK_0); \ |
|
1881 ret = jvalue.get_##ResultType(); \ |
|
1882 return ret;\ |
|
1883 JNI_END |
|
1884 |
|
1885 // the runtime type of subword integral basic types is integer |
|
1886 DEFINE_CALLMETHODA(jboolean, Boolean, T_BOOLEAN |
|
1887 , HOTSPOT_JNI_CALLBOOLEANMETHOD_ENTRY(env, obj, (uintptr_t)methodID), |
|
1888 HOTSPOT_JNI_CALLBOOLEANMETHOD_RETURN(_ret_ref)) |
|
1889 DEFINE_CALLMETHODA(jbyte, Byte, T_BYTE |
|
1890 , HOTSPOT_JNI_CALLBYTEMETHOD_ENTRY(env, obj, (uintptr_t)methodID), |
|
1891 HOTSPOT_JNI_CALLBYTEMETHOD_RETURN(_ret_ref)) |
|
1892 DEFINE_CALLMETHODA(jchar, Char, T_CHAR |
|
1893 , HOTSPOT_JNI_CALLCHARMETHOD_ENTRY(env, obj, (uintptr_t)methodID), |
|
1894 HOTSPOT_JNI_CALLCHARMETHOD_RETURN(_ret_ref)) |
|
1895 DEFINE_CALLMETHODA(jshort, Short, T_SHORT |
|
1896 , HOTSPOT_JNI_CALLSHORTMETHOD_ENTRY(env, obj, (uintptr_t)methodID), |
|
1897 HOTSPOT_JNI_CALLSHORTMETHOD_RETURN(_ret_ref)) |
|
1898 |
|
1899 DEFINE_CALLMETHODA(jobject, Object, T_OBJECT |
|
1900 , HOTSPOT_JNI_CALLOBJECTMETHOD_ENTRY(env, obj, (uintptr_t)methodID), |
|
1901 HOTSPOT_JNI_CALLOBJECTMETHOD_RETURN(_ret_ref)) |
|
1902 DEFINE_CALLMETHODA(jint, Int, T_INT, |
|
1903 HOTSPOT_JNI_CALLINTMETHOD_ENTRY(env, obj, (uintptr_t)methodID), |
|
1904 HOTSPOT_JNI_CALLINTMETHOD_RETURN(_ret_ref)) |
|
1905 DEFINE_CALLMETHODA(jlong, Long, T_LONG |
|
1906 , HOTSPOT_JNI_CALLLONGMETHOD_ENTRY(env, obj, (uintptr_t)methodID), |
|
1907 HOTSPOT_JNI_CALLLONGMETHOD_RETURN(_ret_ref)) |
|
1908 // Float and double probes don't return value because dtrace doesn't currently support it |
|
1909 DEFINE_CALLMETHODA(jfloat, Float, T_FLOAT |
|
1910 , HOTSPOT_JNI_CALLFLOATMETHOD_ENTRY(env, obj, (uintptr_t)methodID), |
|
1911 HOTSPOT_JNI_CALLFLOATMETHOD_RETURN()) |
|
1912 DEFINE_CALLMETHODA(jdouble, Double, T_DOUBLE |
|
1913 , HOTSPOT_JNI_CALLDOUBLEMETHOD_ENTRY(env, obj, (uintptr_t)methodID), |
|
1914 HOTSPOT_JNI_CALLDOUBLEMETHOD_RETURN()) |
|
1915 |
|
1916 DT_VOID_RETURN_MARK_DECL(CallVoidMethod, HOTSPOT_JNI_CALLVOIDMETHOD_RETURN()); |
|
1917 DT_VOID_RETURN_MARK_DECL(CallVoidMethodV, HOTSPOT_JNI_CALLVOIDMETHODV_RETURN()); |
|
1918 DT_VOID_RETURN_MARK_DECL(CallVoidMethodA, HOTSPOT_JNI_CALLVOIDMETHODA_RETURN()); |
|
1919 |
|
1920 #endif /* USDT2 */ |
|
1921 |
1417 JNI_ENTRY(void, jni_CallVoidMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)) |
1922 JNI_ENTRY(void, jni_CallVoidMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)) |
1418 JNIWrapper("CallVoidMethod"); |
1923 JNIWrapper("CallVoidMethod"); |
|
1924 #ifndef USDT2 |
1419 DTRACE_PROBE3(hotspot_jni, CallVoidMethod__entry, env, obj, methodID); |
1925 DTRACE_PROBE3(hotspot_jni, CallVoidMethod__entry, env, obj, methodID); |
|
1926 #else /* USDT2 */ |
|
1927 HOTSPOT_JNI_CALLVOIDMETHOD_ENTRY( |
|
1928 env, obj, (uintptr_t) methodID); |
|
1929 #endif /* USDT2 */ |
1420 DT_VOID_RETURN_MARK(CallVoidMethod); |
1930 DT_VOID_RETURN_MARK(CallVoidMethod); |
1421 |
1931 |
1422 va_list args; |
1932 va_list args; |
1423 va_start(args, methodID); |
1933 va_start(args, methodID); |
1424 JavaValue jvalue(T_VOID); |
1934 JavaValue jvalue(T_VOID); |
1428 JNI_END |
1938 JNI_END |
1429 |
1939 |
1430 |
1940 |
1431 JNI_ENTRY(void, jni_CallVoidMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)) |
1941 JNI_ENTRY(void, jni_CallVoidMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)) |
1432 JNIWrapper("CallVoidMethodV"); |
1942 JNIWrapper("CallVoidMethodV"); |
|
1943 #ifndef USDT2 |
1433 DTRACE_PROBE3(hotspot_jni, CallVoidMethodV__entry, env, obj, methodID); |
1944 DTRACE_PROBE3(hotspot_jni, CallVoidMethodV__entry, env, obj, methodID); |
|
1945 #else /* USDT2 */ |
|
1946 HOTSPOT_JNI_CALLVOIDMETHODV_ENTRY( |
|
1947 env, obj, (uintptr_t) methodID); |
|
1948 #endif /* USDT2 */ |
1434 DT_VOID_RETURN_MARK(CallVoidMethodV); |
1949 DT_VOID_RETURN_MARK(CallVoidMethodV); |
1435 |
1950 |
1436 JavaValue jvalue(T_VOID); |
1951 JavaValue jvalue(T_VOID); |
1437 JNI_ArgumentPusherVaArg ap(methodID, args); |
1952 JNI_ArgumentPusherVaArg ap(methodID, args); |
1438 jni_invoke_nonstatic(env, &jvalue, obj, JNI_VIRTUAL, methodID, &ap, CHECK); |
1953 jni_invoke_nonstatic(env, &jvalue, obj, JNI_VIRTUAL, methodID, &ap, CHECK); |
1439 JNI_END |
1954 JNI_END |
1440 |
1955 |
1441 |
1956 |
1442 JNI_ENTRY(void, jni_CallVoidMethodA(JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args)) |
1957 JNI_ENTRY(void, jni_CallVoidMethodA(JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args)) |
1443 JNIWrapper("CallVoidMethodA"); |
1958 JNIWrapper("CallVoidMethodA"); |
|
1959 #ifndef USDT2 |
1444 DTRACE_PROBE3(hotspot_jni, CallVoidMethodA__entry, env, obj, methodID); |
1960 DTRACE_PROBE3(hotspot_jni, CallVoidMethodA__entry, env, obj, methodID); |
|
1961 #else /* USDT2 */ |
|
1962 HOTSPOT_JNI_CALLVOIDMETHODA_ENTRY( |
|
1963 env, obj, (uintptr_t) methodID); |
|
1964 #endif /* USDT2 */ |
1445 DT_VOID_RETURN_MARK(CallVoidMethodA); |
1965 DT_VOID_RETURN_MARK(CallVoidMethodA); |
1446 |
1966 |
1447 JavaValue jvalue(T_VOID); |
1967 JavaValue jvalue(T_VOID); |
1448 JNI_ArgumentPusherArray ap(methodID, args); |
1968 JNI_ArgumentPusherArray ap(methodID, args); |
1449 jni_invoke_nonstatic(env, &jvalue, obj, JNI_VIRTUAL, methodID, &ap, CHECK); |
1969 jni_invoke_nonstatic(env, &jvalue, obj, JNI_VIRTUAL, methodID, &ap, CHECK); |
1450 JNI_END |
1970 JNI_END |
1451 |
1971 |
1452 |
1972 |
|
1973 #ifndef USDT2 |
1453 #define DEFINE_CALLNONVIRTUALMETHOD(ResultType, Result, Tag) \ |
1974 #define DEFINE_CALLNONVIRTUALMETHOD(ResultType, Result, Tag) \ |
1454 \ |
1975 \ |
1455 DT_RETURN_MARK_DECL_FOR(Result, CallNonvirtual##Result##Method, ResultType);\ |
1976 DT_RETURN_MARK_DECL_FOR(Result, CallNonvirtual##Result##Method, ResultType);\ |
1456 DT_RETURN_MARK_DECL_FOR(Result, CallNonvirtual##Result##MethodV, ResultType);\ |
1977 DT_RETURN_MARK_DECL_FOR(Result, CallNonvirtual##Result##MethodV, ResultType);\ |
1457 DT_RETURN_MARK_DECL_FOR(Result, CallNonvirtual##Result##MethodA, ResultType);\ |
1978 DT_RETURN_MARK_DECL_FOR(Result, CallNonvirtual##Result##MethodA, ResultType);\ |
1520 |
2041 |
1521 DT_VOID_RETURN_MARK_DECL(CallNonvirtualVoidMethod); |
2042 DT_VOID_RETURN_MARK_DECL(CallNonvirtualVoidMethod); |
1522 DT_VOID_RETURN_MARK_DECL(CallNonvirtualVoidMethodV); |
2043 DT_VOID_RETURN_MARK_DECL(CallNonvirtualVoidMethodV); |
1523 DT_VOID_RETURN_MARK_DECL(CallNonvirtualVoidMethodA); |
2044 DT_VOID_RETURN_MARK_DECL(CallNonvirtualVoidMethodA); |
1524 |
2045 |
|
2046 #else /* USDT2 */ |
|
2047 |
|
2048 #define DEFINE_CALLNONVIRTUALMETHOD(ResultType, Result, Tag \ |
|
2049 , EntryProbe, ReturnProbe) \ |
|
2050 \ |
|
2051 DT_RETURN_MARK_DECL_FOR(Result, CallNonvirtual##Result##Method, ResultType \ |
|
2052 , ReturnProbe);\ |
|
2053 \ |
|
2054 JNI_ENTRY(ResultType, \ |
|
2055 jni_CallNonvirtual##Result##Method(JNIEnv *env, jobject obj, jclass cls, jmethodID methodID, ...)) \ |
|
2056 JNIWrapper("CallNonvitual" XSTR(Result) "Method"); \ |
|
2057 \ |
|
2058 EntryProbe;\ |
|
2059 ResultType ret;\ |
|
2060 DT_RETURN_MARK_FOR(Result, CallNonvirtual##Result##Method, ResultType, \ |
|
2061 (const ResultType&)ret);\ |
|
2062 \ |
|
2063 va_list args; \ |
|
2064 va_start(args, methodID); \ |
|
2065 JavaValue jvalue(Tag); \ |
|
2066 JNI_ArgumentPusherVaArg ap(methodID, args); \ |
|
2067 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK_0); \ |
|
2068 va_end(args); \ |
|
2069 ret = jvalue.get_##ResultType(); \ |
|
2070 return ret;\ |
|
2071 JNI_END |
|
2072 |
|
2073 // the runtime type of subword integral basic types is integer |
|
2074 DEFINE_CALLNONVIRTUALMETHOD(jboolean, Boolean, T_BOOLEAN |
|
2075 , HOTSPOT_JNI_CALLNONVIRTUALBOOLEANMETHOD_ENTRY(env, obj, cls, (uintptr_t)methodID), |
|
2076 HOTSPOT_JNI_CALLNONVIRTUALBOOLEANMETHOD_RETURN(_ret_ref)) |
|
2077 DEFINE_CALLNONVIRTUALMETHOD(jbyte, Byte, T_BYTE |
|
2078 , HOTSPOT_JNI_CALLNONVIRTUALBYTEMETHOD_ENTRY(env, obj, cls, (uintptr_t)methodID), |
|
2079 HOTSPOT_JNI_CALLNONVIRTUALBYTEMETHOD_RETURN(_ret_ref)) |
|
2080 DEFINE_CALLNONVIRTUALMETHOD(jchar, Char, T_CHAR |
|
2081 , HOTSPOT_JNI_CALLNONVIRTUALCHARMETHOD_ENTRY(env, obj, cls, (uintptr_t)methodID), |
|
2082 HOTSPOT_JNI_CALLNONVIRTUALCHARMETHOD_RETURN(_ret_ref)) |
|
2083 DEFINE_CALLNONVIRTUALMETHOD(jshort, Short, T_SHORT |
|
2084 , HOTSPOT_JNI_CALLNONVIRTUALSHORTMETHOD_ENTRY(env, obj, cls, (uintptr_t)methodID), |
|
2085 HOTSPOT_JNI_CALLNONVIRTUALSHORTMETHOD_RETURN(_ret_ref)) |
|
2086 |
|
2087 DEFINE_CALLNONVIRTUALMETHOD(jobject, Object, T_OBJECT |
|
2088 , HOTSPOT_JNI_CALLNONVIRTUALOBJECTMETHOD_ENTRY(env, obj, cls, (uintptr_t)methodID), |
|
2089 HOTSPOT_JNI_CALLNONVIRTUALOBJECTMETHOD_RETURN(_ret_ref)) |
|
2090 DEFINE_CALLNONVIRTUALMETHOD(jint, Int, T_INT |
|
2091 , HOTSPOT_JNI_CALLNONVIRTUALINTMETHOD_ENTRY(env, obj, cls, (uintptr_t)methodID), |
|
2092 HOTSPOT_JNI_CALLNONVIRTUALINTMETHOD_RETURN(_ret_ref)) |
|
2093 DEFINE_CALLNONVIRTUALMETHOD(jlong, Long, T_LONG |
|
2094 , HOTSPOT_JNI_CALLNONVIRTUALLONGMETHOD_ENTRY(env, obj, cls, (uintptr_t)methodID), |
|
2095 // Float and double probes don't return value because dtrace doesn't currently support it |
|
2096 HOTSPOT_JNI_CALLNONVIRTUALLONGMETHOD_RETURN(_ret_ref)) |
|
2097 DEFINE_CALLNONVIRTUALMETHOD(jfloat, Float, T_FLOAT |
|
2098 , HOTSPOT_JNI_CALLNONVIRTUALFLOATMETHOD_ENTRY(env, obj, cls, (uintptr_t)methodID), |
|
2099 HOTSPOT_JNI_CALLNONVIRTUALFLOATMETHOD_RETURN()) |
|
2100 DEFINE_CALLNONVIRTUALMETHOD(jdouble, Double, T_DOUBLE |
|
2101 , HOTSPOT_JNI_CALLNONVIRTUALDOUBLEMETHOD_ENTRY(env, obj, cls, (uintptr_t)methodID), |
|
2102 HOTSPOT_JNI_CALLNONVIRTUALDOUBLEMETHOD_RETURN()) |
|
2103 |
|
2104 #define DEFINE_CALLNONVIRTUALMETHODV(ResultType, Result, Tag \ |
|
2105 , EntryProbe, ReturnProbe) \ |
|
2106 \ |
|
2107 DT_RETURN_MARK_DECL_FOR(Result, CallNonvirtual##Result##MethodV, ResultType \ |
|
2108 , ReturnProbe);\ |
|
2109 \ |
|
2110 JNI_ENTRY(ResultType, \ |
|
2111 jni_CallNonvirtual##Result##MethodV(JNIEnv *env, jobject obj, jclass cls, jmethodID methodID, va_list args)) \ |
|
2112 JNIWrapper("CallNonvitual" XSTR(Result) "MethodV"); \ |
|
2113 \ |
|
2114 EntryProbe;\ |
|
2115 ResultType ret;\ |
|
2116 DT_RETURN_MARK_FOR(Result, CallNonvirtual##Result##MethodV, ResultType, \ |
|
2117 (const ResultType&)ret);\ |
|
2118 \ |
|
2119 JavaValue jvalue(Tag); \ |
|
2120 JNI_ArgumentPusherVaArg ap(methodID, args); \ |
|
2121 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK_0); \ |
|
2122 ret = jvalue.get_##ResultType(); \ |
|
2123 return ret;\ |
|
2124 JNI_END |
|
2125 |
|
2126 // the runtime type of subword integral basic types is integer |
|
2127 DEFINE_CALLNONVIRTUALMETHODV(jboolean, Boolean, T_BOOLEAN |
|
2128 , HOTSPOT_JNI_CALLNONVIRTUALBOOLEANMETHODV_ENTRY(env, obj, cls, (uintptr_t)methodID), |
|
2129 HOTSPOT_JNI_CALLNONVIRTUALBOOLEANMETHODV_RETURN(_ret_ref)) |
|
2130 DEFINE_CALLNONVIRTUALMETHODV(jbyte, Byte, T_BYTE |
|
2131 , HOTSPOT_JNI_CALLNONVIRTUALBYTEMETHODV_ENTRY(env, obj, cls, (uintptr_t)methodID), |
|
2132 HOTSPOT_JNI_CALLNONVIRTUALBYTEMETHODV_RETURN(_ret_ref)) |
|
2133 DEFINE_CALLNONVIRTUALMETHODV(jchar, Char, T_CHAR |
|
2134 , HOTSPOT_JNI_CALLNONVIRTUALCHARMETHODV_ENTRY(env, obj, cls, (uintptr_t)methodID), |
|
2135 HOTSPOT_JNI_CALLNONVIRTUALCHARMETHODV_RETURN(_ret_ref)) |
|
2136 DEFINE_CALLNONVIRTUALMETHODV(jshort, Short, T_SHORT |
|
2137 , HOTSPOT_JNI_CALLNONVIRTUALSHORTMETHODV_ENTRY(env, obj, cls, (uintptr_t)methodID), |
|
2138 HOTSPOT_JNI_CALLNONVIRTUALSHORTMETHODV_RETURN(_ret_ref)) |
|
2139 |
|
2140 DEFINE_CALLNONVIRTUALMETHODV(jobject, Object, T_OBJECT |
|
2141 , HOTSPOT_JNI_CALLNONVIRTUALOBJECTMETHODV_ENTRY(env, obj, cls, (uintptr_t)methodID), |
|
2142 HOTSPOT_JNI_CALLNONVIRTUALOBJECTMETHODV_RETURN(_ret_ref)) |
|
2143 DEFINE_CALLNONVIRTUALMETHODV(jint, Int, T_INT |
|
2144 , HOTSPOT_JNI_CALLNONVIRTUALINTMETHODV_ENTRY(env, obj, cls, (uintptr_t)methodID), |
|
2145 HOTSPOT_JNI_CALLNONVIRTUALINTMETHODV_RETURN(_ret_ref)) |
|
2146 DEFINE_CALLNONVIRTUALMETHODV(jlong, Long, T_LONG |
|
2147 , HOTSPOT_JNI_CALLNONVIRTUALLONGMETHODV_ENTRY(env, obj, cls, (uintptr_t)methodID), |
|
2148 // Float and double probes don't return value because dtrace doesn't currently support it |
|
2149 HOTSPOT_JNI_CALLNONVIRTUALLONGMETHODV_RETURN(_ret_ref)) |
|
2150 DEFINE_CALLNONVIRTUALMETHODV(jfloat, Float, T_FLOAT |
|
2151 , HOTSPOT_JNI_CALLNONVIRTUALFLOATMETHODV_ENTRY(env, obj, cls, (uintptr_t)methodID), |
|
2152 HOTSPOT_JNI_CALLNONVIRTUALFLOATMETHODV_RETURN()) |
|
2153 DEFINE_CALLNONVIRTUALMETHODV(jdouble, Double, T_DOUBLE |
|
2154 , HOTSPOT_JNI_CALLNONVIRTUALDOUBLEMETHODV_ENTRY(env, obj, cls, (uintptr_t)methodID), |
|
2155 HOTSPOT_JNI_CALLNONVIRTUALDOUBLEMETHODV_RETURN()) |
|
2156 |
|
2157 #define DEFINE_CALLNONVIRTUALMETHODA(ResultType, Result, Tag \ |
|
2158 , EntryProbe, ReturnProbe) \ |
|
2159 \ |
|
2160 DT_RETURN_MARK_DECL_FOR(Result, CallNonvirtual##Result##MethodA, ResultType \ |
|
2161 , ReturnProbe);\ |
|
2162 \ |
|
2163 JNI_ENTRY(ResultType, \ |
|
2164 jni_CallNonvirtual##Result##MethodA(JNIEnv *env, jobject obj, jclass cls, jmethodID methodID, const jvalue *args)) \ |
|
2165 JNIWrapper("CallNonvitual" XSTR(Result) "MethodA"); \ |
|
2166 \ |
|
2167 EntryProbe;\ |
|
2168 ResultType ret;\ |
|
2169 DT_RETURN_MARK_FOR(Result, CallNonvirtual##Result##MethodA, ResultType, \ |
|
2170 (const ResultType&)ret);\ |
|
2171 \ |
|
2172 JavaValue jvalue(Tag); \ |
|
2173 JNI_ArgumentPusherArray ap(methodID, args); \ |
|
2174 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK_0); \ |
|
2175 ret = jvalue.get_##ResultType(); \ |
|
2176 return ret;\ |
|
2177 JNI_END |
|
2178 |
|
2179 // the runtime type of subword integral basic types is integer |
|
2180 DEFINE_CALLNONVIRTUALMETHODA(jboolean, Boolean, T_BOOLEAN |
|
2181 , HOTSPOT_JNI_CALLNONVIRTUALBOOLEANMETHODA_ENTRY(env, obj, cls, (uintptr_t)methodID), |
|
2182 HOTSPOT_JNI_CALLNONVIRTUALBOOLEANMETHODA_RETURN(_ret_ref)) |
|
2183 DEFINE_CALLNONVIRTUALMETHODA(jbyte, Byte, T_BYTE |
|
2184 , HOTSPOT_JNI_CALLNONVIRTUALBYTEMETHODA_ENTRY(env, obj, cls, (uintptr_t)methodID), |
|
2185 HOTSPOT_JNI_CALLNONVIRTUALBYTEMETHODA_RETURN(_ret_ref)) |
|
2186 DEFINE_CALLNONVIRTUALMETHODA(jchar, Char, T_CHAR |
|
2187 , HOTSPOT_JNI_CALLNONVIRTUALCHARMETHODA_ENTRY(env, obj, cls, (uintptr_t)methodID), |
|
2188 HOTSPOT_JNI_CALLNONVIRTUALCHARMETHODA_RETURN(_ret_ref)) |
|
2189 DEFINE_CALLNONVIRTUALMETHODA(jshort, Short, T_SHORT |
|
2190 , HOTSPOT_JNI_CALLNONVIRTUALSHORTMETHODA_ENTRY(env, obj, cls, (uintptr_t)methodID), |
|
2191 HOTSPOT_JNI_CALLNONVIRTUALSHORTMETHODA_RETURN(_ret_ref)) |
|
2192 |
|
2193 DEFINE_CALLNONVIRTUALMETHODA(jobject, Object, T_OBJECT |
|
2194 , HOTSPOT_JNI_CALLNONVIRTUALOBJECTMETHODA_ENTRY(env, obj, cls, (uintptr_t)methodID), |
|
2195 HOTSPOT_JNI_CALLNONVIRTUALOBJECTMETHODA_RETURN(_ret_ref)) |
|
2196 DEFINE_CALLNONVIRTUALMETHODA(jint, Int, T_INT |
|
2197 , HOTSPOT_JNI_CALLNONVIRTUALINTMETHODA_ENTRY(env, obj, cls, (uintptr_t)methodID), |
|
2198 HOTSPOT_JNI_CALLNONVIRTUALINTMETHODA_RETURN(_ret_ref)) |
|
2199 DEFINE_CALLNONVIRTUALMETHODA(jlong, Long, T_LONG |
|
2200 , HOTSPOT_JNI_CALLNONVIRTUALLONGMETHODA_ENTRY(env, obj, cls, (uintptr_t)methodID), |
|
2201 // Float and double probes don't return value because dtrace doesn't currently support it |
|
2202 HOTSPOT_JNI_CALLNONVIRTUALLONGMETHODA_RETURN(_ret_ref)) |
|
2203 DEFINE_CALLNONVIRTUALMETHODA(jfloat, Float, T_FLOAT |
|
2204 , HOTSPOT_JNI_CALLNONVIRTUALFLOATMETHODA_ENTRY(env, obj, cls, (uintptr_t)methodID), |
|
2205 HOTSPOT_JNI_CALLNONVIRTUALFLOATMETHODA_RETURN()) |
|
2206 DEFINE_CALLNONVIRTUALMETHODA(jdouble, Double, T_DOUBLE |
|
2207 , HOTSPOT_JNI_CALLNONVIRTUALDOUBLEMETHODA_ENTRY(env, obj, cls, (uintptr_t)methodID), |
|
2208 HOTSPOT_JNI_CALLNONVIRTUALDOUBLEMETHODA_RETURN()) |
|
2209 |
|
2210 DT_VOID_RETURN_MARK_DECL(CallNonvirtualVoidMethod |
|
2211 , HOTSPOT_JNI_CALLNONVIRTUALVOIDMETHOD_RETURN()); |
|
2212 DT_VOID_RETURN_MARK_DECL(CallNonvirtualVoidMethodV |
|
2213 , HOTSPOT_JNI_CALLNONVIRTUALVOIDMETHODV_RETURN()); |
|
2214 DT_VOID_RETURN_MARK_DECL(CallNonvirtualVoidMethodA |
|
2215 , HOTSPOT_JNI_CALLNONVIRTUALVOIDMETHODA_RETURN()); |
|
2216 #endif /* USDT2 */ |
|
2217 |
1525 JNI_ENTRY(void, jni_CallNonvirtualVoidMethod(JNIEnv *env, jobject obj, jclass cls, jmethodID methodID, ...)) |
2218 JNI_ENTRY(void, jni_CallNonvirtualVoidMethod(JNIEnv *env, jobject obj, jclass cls, jmethodID methodID, ...)) |
1526 JNIWrapper("CallNonvirtualVoidMethod"); |
2219 JNIWrapper("CallNonvirtualVoidMethod"); |
1527 |
2220 |
|
2221 #ifndef USDT2 |
1528 DTRACE_PROBE4(hotspot_jni, CallNonvirtualVoidMethod__entry, |
2222 DTRACE_PROBE4(hotspot_jni, CallNonvirtualVoidMethod__entry, |
1529 env, obj, cls, methodID); |
2223 env, obj, cls, methodID); |
|
2224 #else /* USDT2 */ |
|
2225 HOTSPOT_JNI_CALLNONVIRTUALVOIDMETHOD_ENTRY( |
|
2226 env, obj, cls, (uintptr_t) methodID); |
|
2227 #endif /* USDT2 */ |
1530 DT_VOID_RETURN_MARK(CallNonvirtualVoidMethod); |
2228 DT_VOID_RETURN_MARK(CallNonvirtualVoidMethod); |
1531 |
2229 |
1532 va_list args; |
2230 va_list args; |
1533 va_start(args, methodID); |
2231 va_start(args, methodID); |
1534 JavaValue jvalue(T_VOID); |
2232 JavaValue jvalue(T_VOID); |
1539 |
2237 |
1540 |
2238 |
1541 JNI_ENTRY(void, jni_CallNonvirtualVoidMethodV(JNIEnv *env, jobject obj, jclass cls, jmethodID methodID, va_list args)) |
2239 JNI_ENTRY(void, jni_CallNonvirtualVoidMethodV(JNIEnv *env, jobject obj, jclass cls, jmethodID methodID, va_list args)) |
1542 JNIWrapper("CallNonvirtualVoidMethodV"); |
2240 JNIWrapper("CallNonvirtualVoidMethodV"); |
1543 |
2241 |
|
2242 #ifndef USDT2 |
1544 DTRACE_PROBE4(hotspot_jni, CallNonvirtualVoidMethodV__entry, |
2243 DTRACE_PROBE4(hotspot_jni, CallNonvirtualVoidMethodV__entry, |
1545 env, obj, cls, methodID); |
2244 env, obj, cls, methodID); |
|
2245 #else /* USDT2 */ |
|
2246 HOTSPOT_JNI_CALLNONVIRTUALVOIDMETHODV_ENTRY( |
|
2247 env, obj, cls, (uintptr_t) methodID); |
|
2248 #endif /* USDT2 */ |
1546 DT_VOID_RETURN_MARK(CallNonvirtualVoidMethodV); |
2249 DT_VOID_RETURN_MARK(CallNonvirtualVoidMethodV); |
1547 |
2250 |
1548 JavaValue jvalue(T_VOID); |
2251 JavaValue jvalue(T_VOID); |
1549 JNI_ArgumentPusherVaArg ap(methodID, args); |
2252 JNI_ArgumentPusherVaArg ap(methodID, args); |
1550 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK); |
2253 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK); |
1551 JNI_END |
2254 JNI_END |
1552 |
2255 |
1553 |
2256 |
1554 JNI_ENTRY(void, jni_CallNonvirtualVoidMethodA(JNIEnv *env, jobject obj, jclass cls, jmethodID methodID, const jvalue *args)) |
2257 JNI_ENTRY(void, jni_CallNonvirtualVoidMethodA(JNIEnv *env, jobject obj, jclass cls, jmethodID methodID, const jvalue *args)) |
1555 JNIWrapper("CallNonvirtualVoidMethodA"); |
2258 JNIWrapper("CallNonvirtualVoidMethodA"); |
|
2259 #ifndef USDT2 |
1556 DTRACE_PROBE4(hotspot_jni, CallNonvirtualVoidMethodA__entry, |
2260 DTRACE_PROBE4(hotspot_jni, CallNonvirtualVoidMethodA__entry, |
1557 env, obj, cls, methodID); |
2261 env, obj, cls, methodID); |
|
2262 #else /* USDT2 */ |
|
2263 HOTSPOT_JNI_CALLNONVIRTUALVOIDMETHODA_ENTRY( |
|
2264 env, obj, cls, (uintptr_t) methodID); |
|
2265 #endif /* USDT2 */ |
1558 DT_VOID_RETURN_MARK(CallNonvirtualVoidMethodA); |
2266 DT_VOID_RETURN_MARK(CallNonvirtualVoidMethodA); |
1559 JavaValue jvalue(T_VOID); |
2267 JavaValue jvalue(T_VOID); |
1560 JNI_ArgumentPusherArray ap(methodID, args); |
2268 JNI_ArgumentPusherArray ap(methodID, args); |
1561 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK); |
2269 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK); |
1562 JNI_END |
2270 JNI_END |
1563 |
2271 |
1564 |
2272 |
|
2273 #ifndef USDT2 |
1565 #define DEFINE_CALLSTATICMETHOD(ResultType, Result, Tag) \ |
2274 #define DEFINE_CALLSTATICMETHOD(ResultType, Result, Tag) \ |
1566 \ |
2275 \ |
1567 DT_RETURN_MARK_DECL_FOR(Result, CallStatic##Result##Method, ResultType);\ |
2276 DT_RETURN_MARK_DECL_FOR(Result, CallStatic##Result##Method, ResultType);\ |
1568 DT_RETURN_MARK_DECL_FOR(Result, CallStatic##Result##MethodV, ResultType);\ |
2277 DT_RETURN_MARK_DECL_FOR(Result, CallStatic##Result##MethodV, ResultType);\ |
1569 DT_RETURN_MARK_DECL_FOR(Result, CallStatic##Result##MethodA, ResultType);\ |
2278 DT_RETURN_MARK_DECL_FOR(Result, CallStatic##Result##MethodA, ResultType);\ |
1632 |
2341 |
1633 DT_VOID_RETURN_MARK_DECL(CallStaticVoidMethod); |
2342 DT_VOID_RETURN_MARK_DECL(CallStaticVoidMethod); |
1634 DT_VOID_RETURN_MARK_DECL(CallStaticVoidMethodV); |
2343 DT_VOID_RETURN_MARK_DECL(CallStaticVoidMethodV); |
1635 DT_VOID_RETURN_MARK_DECL(CallStaticVoidMethodA); |
2344 DT_VOID_RETURN_MARK_DECL(CallStaticVoidMethodA); |
1636 |
2345 |
|
2346 #else /* USDT2 */ |
|
2347 |
|
2348 #define DEFINE_CALLSTATICMETHOD(ResultType, Result, Tag \ |
|
2349 , EntryProbe, ResultProbe) \ |
|
2350 \ |
|
2351 DT_RETURN_MARK_DECL_FOR(Result, CallStatic##Result##Method, ResultType \ |
|
2352 , ResultProbe); \ |
|
2353 \ |
|
2354 JNI_ENTRY(ResultType, \ |
|
2355 jni_CallStatic##Result##Method(JNIEnv *env, jclass cls, jmethodID methodID, ...)) \ |
|
2356 JNIWrapper("CallStatic" XSTR(Result) "Method"); \ |
|
2357 \ |
|
2358 EntryProbe; \ |
|
2359 ResultType ret = 0;\ |
|
2360 DT_RETURN_MARK_FOR(Result, CallStatic##Result##Method, ResultType, \ |
|
2361 (const ResultType&)ret);\ |
|
2362 \ |
|
2363 va_list args; \ |
|
2364 va_start(args, methodID); \ |
|
2365 JavaValue jvalue(Tag); \ |
|
2366 JNI_ArgumentPusherVaArg ap(methodID, args); \ |
|
2367 jni_invoke_static(env, &jvalue, NULL, JNI_STATIC, methodID, &ap, CHECK_0); \ |
|
2368 va_end(args); \ |
|
2369 ret = jvalue.get_##ResultType(); \ |
|
2370 return ret;\ |
|
2371 JNI_END |
|
2372 |
|
2373 // the runtime type of subword integral basic types is integer |
|
2374 DEFINE_CALLSTATICMETHOD(jboolean, Boolean, T_BOOLEAN |
|
2375 , HOTSPOT_JNI_CALLSTATICBOOLEANMETHOD_ENTRY(env, cls, (uintptr_t)methodID), |
|
2376 HOTSPOT_JNI_CALLSTATICBOOLEANMETHOD_RETURN(_ret_ref)); |
|
2377 DEFINE_CALLSTATICMETHOD(jbyte, Byte, T_BYTE |
|
2378 , HOTSPOT_JNI_CALLSTATICBYTEMETHOD_ENTRY(env, cls, (uintptr_t)methodID), |
|
2379 HOTSPOT_JNI_CALLSTATICBYTEMETHOD_RETURN(_ret_ref)); |
|
2380 DEFINE_CALLSTATICMETHOD(jchar, Char, T_CHAR |
|
2381 , HOTSPOT_JNI_CALLSTATICCHARMETHOD_ENTRY(env, cls, (uintptr_t)methodID), |
|
2382 HOTSPOT_JNI_CALLSTATICCHARMETHOD_RETURN(_ret_ref)); |
|
2383 DEFINE_CALLSTATICMETHOD(jshort, Short, T_SHORT |
|
2384 , HOTSPOT_JNI_CALLSTATICSHORTMETHOD_ENTRY(env, cls, (uintptr_t)methodID), |
|
2385 HOTSPOT_JNI_CALLSTATICSHORTMETHOD_RETURN(_ret_ref)); |
|
2386 |
|
2387 DEFINE_CALLSTATICMETHOD(jobject, Object, T_OBJECT |
|
2388 , HOTSPOT_JNI_CALLSTATICOBJECTMETHOD_ENTRY(env, cls, (uintptr_t)methodID), |
|
2389 HOTSPOT_JNI_CALLSTATICOBJECTMETHOD_RETURN(_ret_ref)); |
|
2390 DEFINE_CALLSTATICMETHOD(jint, Int, T_INT |
|
2391 , HOTSPOT_JNI_CALLSTATICINTMETHOD_ENTRY(env, cls, (uintptr_t)methodID), |
|
2392 HOTSPOT_JNI_CALLSTATICINTMETHOD_RETURN(_ret_ref)); |
|
2393 DEFINE_CALLSTATICMETHOD(jlong, Long, T_LONG |
|
2394 , HOTSPOT_JNI_CALLSTATICLONGMETHOD_ENTRY(env, cls, (uintptr_t)methodID), |
|
2395 HOTSPOT_JNI_CALLSTATICLONGMETHOD_RETURN(_ret_ref)); |
|
2396 // Float and double probes don't return value because dtrace doesn't currently support it |
|
2397 DEFINE_CALLSTATICMETHOD(jfloat, Float, T_FLOAT |
|
2398 , HOTSPOT_JNI_CALLSTATICFLOATMETHOD_ENTRY(env, cls, (uintptr_t)methodID), |
|
2399 HOTSPOT_JNI_CALLSTATICFLOATMETHOD_RETURN()); |
|
2400 DEFINE_CALLSTATICMETHOD(jdouble, Double, T_DOUBLE |
|
2401 , HOTSPOT_JNI_CALLSTATICDOUBLEMETHOD_ENTRY(env, cls, (uintptr_t)methodID), |
|
2402 HOTSPOT_JNI_CALLSTATICDOUBLEMETHOD_RETURN()); |
|
2403 |
|
2404 #define DEFINE_CALLSTATICMETHODV(ResultType, Result, Tag \ |
|
2405 , EntryProbe, ResultProbe) \ |
|
2406 \ |
|
2407 DT_RETURN_MARK_DECL_FOR(Result, CallStatic##Result##MethodV, ResultType \ |
|
2408 , ResultProbe); \ |
|
2409 \ |
|
2410 JNI_ENTRY(ResultType, \ |
|
2411 jni_CallStatic##Result##MethodV(JNIEnv *env, jclass cls, jmethodID methodID, va_list args)) \ |
|
2412 JNIWrapper("CallStatic" XSTR(Result) "MethodV"); \ |
|
2413 \ |
|
2414 EntryProbe; \ |
|
2415 ResultType ret = 0;\ |
|
2416 DT_RETURN_MARK_FOR(Result, CallStatic##Result##MethodV, ResultType, \ |
|
2417 (const ResultType&)ret);\ |
|
2418 \ |
|
2419 JavaValue jvalue(Tag); \ |
|
2420 JNI_ArgumentPusherVaArg ap(methodID, args); \ |
|
2421 /* Make sure class is initialized before trying to invoke its method */ \ |
|
2422 KlassHandle k(THREAD, java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls))); \ |
|
2423 Klass::cast(k())->initialize(CHECK_0); \ |
|
2424 jni_invoke_static(env, &jvalue, NULL, JNI_STATIC, methodID, &ap, CHECK_0); \ |
|
2425 va_end(args); \ |
|
2426 ret = jvalue.get_##ResultType(); \ |
|
2427 return ret;\ |
|
2428 JNI_END |
|
2429 |
|
2430 // the runtime type of subword integral basic types is integer |
|
2431 DEFINE_CALLSTATICMETHODV(jboolean, Boolean, T_BOOLEAN |
|
2432 , HOTSPOT_JNI_CALLSTATICBOOLEANMETHODV_ENTRY(env, cls, (uintptr_t)methodID), |
|
2433 HOTSPOT_JNI_CALLSTATICBOOLEANMETHODV_RETURN(_ret_ref)); |
|
2434 DEFINE_CALLSTATICMETHODV(jbyte, Byte, T_BYTE |
|
2435 , HOTSPOT_JNI_CALLSTATICBYTEMETHODV_ENTRY(env, cls, (uintptr_t)methodID), |
|
2436 HOTSPOT_JNI_CALLSTATICBYTEMETHODV_RETURN(_ret_ref)); |
|
2437 DEFINE_CALLSTATICMETHODV(jchar, Char, T_CHAR |
|
2438 , HOTSPOT_JNI_CALLSTATICCHARMETHODV_ENTRY(env, cls, (uintptr_t)methodID), |
|
2439 HOTSPOT_JNI_CALLSTATICCHARMETHODV_RETURN(_ret_ref)); |
|
2440 DEFINE_CALLSTATICMETHODV(jshort, Short, T_SHORT |
|
2441 , HOTSPOT_JNI_CALLSTATICSHORTMETHODV_ENTRY(env, cls, (uintptr_t)methodID), |
|
2442 HOTSPOT_JNI_CALLSTATICSHORTMETHODV_RETURN(_ret_ref)); |
|
2443 |
|
2444 DEFINE_CALLSTATICMETHODV(jobject, Object, T_OBJECT |
|
2445 , HOTSPOT_JNI_CALLSTATICOBJECTMETHODV_ENTRY(env, cls, (uintptr_t)methodID), |
|
2446 HOTSPOT_JNI_CALLSTATICOBJECTMETHODV_RETURN(_ret_ref)); |
|
2447 DEFINE_CALLSTATICMETHODV(jint, Int, T_INT |
|
2448 , HOTSPOT_JNI_CALLSTATICINTMETHODV_ENTRY(env, cls, (uintptr_t)methodID), |
|
2449 HOTSPOT_JNI_CALLSTATICINTMETHODV_RETURN(_ret_ref)); |
|
2450 DEFINE_CALLSTATICMETHODV(jlong, Long, T_LONG |
|
2451 , HOTSPOT_JNI_CALLSTATICLONGMETHODV_ENTRY(env, cls, (uintptr_t)methodID), |
|
2452 HOTSPOT_JNI_CALLSTATICLONGMETHODV_RETURN(_ret_ref)); |
|
2453 // Float and double probes don't return value because dtrace doesn't currently support it |
|
2454 DEFINE_CALLSTATICMETHODV(jfloat, Float, T_FLOAT |
|
2455 , HOTSPOT_JNI_CALLSTATICFLOATMETHODV_ENTRY(env, cls, (uintptr_t)methodID), |
|
2456 HOTSPOT_JNI_CALLSTATICFLOATMETHODV_RETURN()); |
|
2457 DEFINE_CALLSTATICMETHODV(jdouble, Double, T_DOUBLE |
|
2458 , HOTSPOT_JNI_CALLSTATICDOUBLEMETHODV_ENTRY(env, cls, (uintptr_t)methodID), |
|
2459 HOTSPOT_JNI_CALLSTATICDOUBLEMETHODV_RETURN()); |
|
2460 |
|
2461 #define DEFINE_CALLSTATICMETHODA(ResultType, Result, Tag \ |
|
2462 , EntryProbe, ResultProbe) \ |
|
2463 \ |
|
2464 DT_RETURN_MARK_DECL_FOR(Result, CallStatic##Result##MethodA, ResultType \ |
|
2465 , ResultProbe); \ |
|
2466 \ |
|
2467 JNI_ENTRY(ResultType, \ |
|
2468 jni_CallStatic##Result##MethodA(JNIEnv *env, jclass cls, jmethodID methodID, const jvalue *args)) \ |
|
2469 JNIWrapper("CallStatic" XSTR(Result) "MethodA"); \ |
|
2470 \ |
|
2471 EntryProbe; \ |
|
2472 ResultType ret = 0;\ |
|
2473 DT_RETURN_MARK_FOR(Result, CallStatic##Result##MethodA, ResultType, \ |
|
2474 (const ResultType&)ret);\ |
|
2475 \ |
|
2476 JavaValue jvalue(Tag); \ |
|
2477 JNI_ArgumentPusherArray ap(methodID, args); \ |
|
2478 jni_invoke_static(env, &jvalue, NULL, JNI_STATIC, methodID, &ap, CHECK_0); \ |
|
2479 ret = jvalue.get_##ResultType(); \ |
|
2480 return ret;\ |
|
2481 JNI_END |
|
2482 |
|
2483 // the runtime type of subword integral basic types is integer |
|
2484 DEFINE_CALLSTATICMETHODA(jboolean, Boolean, T_BOOLEAN |
|
2485 , HOTSPOT_JNI_CALLSTATICBOOLEANMETHODA_ENTRY(env, cls, (uintptr_t)methodID), |
|
2486 HOTSPOT_JNI_CALLSTATICBOOLEANMETHODA_RETURN(_ret_ref)); |
|
2487 DEFINE_CALLSTATICMETHODA(jbyte, Byte, T_BYTE |
|
2488 , HOTSPOT_JNI_CALLSTATICBYTEMETHODA_ENTRY(env, cls, (uintptr_t)methodID), |
|
2489 HOTSPOT_JNI_CALLSTATICBYTEMETHODA_RETURN(_ret_ref)); |
|
2490 DEFINE_CALLSTATICMETHODA(jchar, Char, T_CHAR |
|
2491 , HOTSPOT_JNI_CALLSTATICCHARMETHODA_ENTRY(env, cls, (uintptr_t)methodID), |
|
2492 HOTSPOT_JNI_CALLSTATICCHARMETHODA_RETURN(_ret_ref)); |
|
2493 DEFINE_CALLSTATICMETHODA(jshort, Short, T_SHORT |
|
2494 , HOTSPOT_JNI_CALLSTATICSHORTMETHODA_ENTRY(env, cls, (uintptr_t)methodID), |
|
2495 HOTSPOT_JNI_CALLSTATICSHORTMETHODA_RETURN(_ret_ref)); |
|
2496 |
|
2497 DEFINE_CALLSTATICMETHODA(jobject, Object, T_OBJECT |
|
2498 , HOTSPOT_JNI_CALLSTATICOBJECTMETHODA_ENTRY(env, cls, (uintptr_t)methodID), |
|
2499 HOTSPOT_JNI_CALLSTATICOBJECTMETHODA_RETURN(_ret_ref)); |
|
2500 DEFINE_CALLSTATICMETHODA(jint, Int, T_INT |
|
2501 , HOTSPOT_JNI_CALLSTATICINTMETHODA_ENTRY(env, cls, (uintptr_t)methodID), |
|
2502 HOTSPOT_JNI_CALLSTATICINTMETHODA_RETURN(_ret_ref)); |
|
2503 DEFINE_CALLSTATICMETHODA(jlong, Long, T_LONG |
|
2504 , HOTSPOT_JNI_CALLSTATICLONGMETHODA_ENTRY(env, cls, (uintptr_t)methodID), |
|
2505 HOTSPOT_JNI_CALLSTATICLONGMETHODA_RETURN(_ret_ref)); |
|
2506 // Float and double probes don't return value because dtrace doesn't currently support it |
|
2507 DEFINE_CALLSTATICMETHODA(jfloat, Float, T_FLOAT |
|
2508 , HOTSPOT_JNI_CALLSTATICFLOATMETHODA_ENTRY(env, cls, (uintptr_t)methodID), |
|
2509 HOTSPOT_JNI_CALLSTATICFLOATMETHODA_RETURN()); |
|
2510 DEFINE_CALLSTATICMETHODA(jdouble, Double, T_DOUBLE |
|
2511 , HOTSPOT_JNI_CALLSTATICDOUBLEMETHODA_ENTRY(env, cls, (uintptr_t)methodID), |
|
2512 HOTSPOT_JNI_CALLSTATICDOUBLEMETHODA_RETURN()); |
|
2513 |
|
2514 DT_VOID_RETURN_MARK_DECL(CallStaticVoidMethod |
|
2515 , HOTSPOT_JNI_CALLSTATICVOIDMETHOD_RETURN()); |
|
2516 DT_VOID_RETURN_MARK_DECL(CallStaticVoidMethodV |
|
2517 , HOTSPOT_JNI_CALLSTATICVOIDMETHODV_RETURN()); |
|
2518 DT_VOID_RETURN_MARK_DECL(CallStaticVoidMethodA |
|
2519 , HOTSPOT_JNI_CALLSTATICVOIDMETHODA_RETURN()); |
|
2520 #endif /* USDT2 */ |
|
2521 |
1637 JNI_ENTRY(void, jni_CallStaticVoidMethod(JNIEnv *env, jclass cls, jmethodID methodID, ...)) |
2522 JNI_ENTRY(void, jni_CallStaticVoidMethod(JNIEnv *env, jclass cls, jmethodID methodID, ...)) |
1638 JNIWrapper("CallStaticVoidMethod"); |
2523 JNIWrapper("CallStaticVoidMethod"); |
|
2524 #ifndef USDT2 |
1639 DTRACE_PROBE3(hotspot_jni, CallStaticVoidMethod__entry, env, cls, methodID); |
2525 DTRACE_PROBE3(hotspot_jni, CallStaticVoidMethod__entry, env, cls, methodID); |
|
2526 #else /* USDT2 */ |
|
2527 HOTSPOT_JNI_CALLSTATICVOIDMETHOD_ENTRY( |
|
2528 env, cls, (uintptr_t) methodID); |
|
2529 #endif /* USDT2 */ |
1640 DT_VOID_RETURN_MARK(CallStaticVoidMethod); |
2530 DT_VOID_RETURN_MARK(CallStaticVoidMethod); |
1641 |
2531 |
1642 va_list args; |
2532 va_list args; |
1643 va_start(args, methodID); |
2533 va_start(args, methodID); |
1644 JavaValue jvalue(T_VOID); |
2534 JavaValue jvalue(T_VOID); |
1648 JNI_END |
2538 JNI_END |
1649 |
2539 |
1650 |
2540 |
1651 JNI_ENTRY(void, jni_CallStaticVoidMethodV(JNIEnv *env, jclass cls, jmethodID methodID, va_list args)) |
2541 JNI_ENTRY(void, jni_CallStaticVoidMethodV(JNIEnv *env, jclass cls, jmethodID methodID, va_list args)) |
1652 JNIWrapper("CallStaticVoidMethodV"); |
2542 JNIWrapper("CallStaticVoidMethodV"); |
|
2543 #ifndef USDT2 |
1653 DTRACE_PROBE3(hotspot_jni, CallStaticVoidMethodV__entry, env, cls, methodID); |
2544 DTRACE_PROBE3(hotspot_jni, CallStaticVoidMethodV__entry, env, cls, methodID); |
|
2545 #else /* USDT2 */ |
|
2546 HOTSPOT_JNI_CALLSTATICVOIDMETHODV_ENTRY( |
|
2547 env, cls, (uintptr_t) methodID); |
|
2548 #endif /* USDT2 */ |
1654 DT_VOID_RETURN_MARK(CallStaticVoidMethodV); |
2549 DT_VOID_RETURN_MARK(CallStaticVoidMethodV); |
1655 |
2550 |
1656 JavaValue jvalue(T_VOID); |
2551 JavaValue jvalue(T_VOID); |
1657 JNI_ArgumentPusherVaArg ap(methodID, args); |
2552 JNI_ArgumentPusherVaArg ap(methodID, args); |
1658 jni_invoke_static(env, &jvalue, NULL, JNI_STATIC, methodID, &ap, CHECK); |
2553 jni_invoke_static(env, &jvalue, NULL, JNI_STATIC, methodID, &ap, CHECK); |
1659 JNI_END |
2554 JNI_END |
1660 |
2555 |
1661 |
2556 |
1662 JNI_ENTRY(void, jni_CallStaticVoidMethodA(JNIEnv *env, jclass cls, jmethodID methodID, const jvalue *args)) |
2557 JNI_ENTRY(void, jni_CallStaticVoidMethodA(JNIEnv *env, jclass cls, jmethodID methodID, const jvalue *args)) |
1663 JNIWrapper("CallStaticVoidMethodA"); |
2558 JNIWrapper("CallStaticVoidMethodA"); |
|
2559 #ifndef USDT2 |
1664 DTRACE_PROBE3(hotspot_jni, CallStaticVoidMethodA__entry, env, cls, methodID); |
2560 DTRACE_PROBE3(hotspot_jni, CallStaticVoidMethodA__entry, env, cls, methodID); |
|
2561 #else /* USDT2 */ |
|
2562 HOTSPOT_JNI_CALLSTATICVOIDMETHODA_ENTRY( |
|
2563 env, cls, (uintptr_t) methodID); |
|
2564 #endif /* USDT2 */ |
1665 DT_VOID_RETURN_MARK(CallStaticVoidMethodA); |
2565 DT_VOID_RETURN_MARK(CallStaticVoidMethodA); |
1666 |
2566 |
1667 JavaValue jvalue(T_VOID); |
2567 JavaValue jvalue(T_VOID); |
1668 JNI_ArgumentPusherArray ap(methodID, args); |
2568 JNI_ArgumentPusherArray ap(methodID, args); |
1669 jni_invoke_static(env, &jvalue, NULL, JNI_STATIC, methodID, &ap, CHECK); |
2569 jni_invoke_static(env, &jvalue, NULL, JNI_STATIC, methodID, &ap, CHECK); |
1777 DEFINE_GETFIELD(jshort, short, Short) |
2698 DEFINE_GETFIELD(jshort, short, Short) |
1778 DEFINE_GETFIELD(jint, int, Int) |
2699 DEFINE_GETFIELD(jint, int, Int) |
1779 DEFINE_GETFIELD(jlong, long, Long) |
2700 DEFINE_GETFIELD(jlong, long, Long) |
1780 DEFINE_GETFIELD(jfloat, float, Float) |
2701 DEFINE_GETFIELD(jfloat, float, Float) |
1781 DEFINE_GETFIELD(jdouble, double, Double) |
2702 DEFINE_GETFIELD(jdouble, double, Double) |
|
2703 |
|
2704 #else /* USDT2 */ |
|
2705 |
|
2706 #define DEFINE_GETFIELD(Return,Fieldname,Result \ |
|
2707 , EntryProbe, ReturnProbe) \ |
|
2708 \ |
|
2709 DT_RETURN_MARK_DECL_FOR(Result, Get##Result##Field, Return \ |
|
2710 , ReturnProbe); \ |
|
2711 \ |
|
2712 JNI_QUICK_ENTRY(Return, jni_Get##Result##Field(JNIEnv *env, jobject obj, jfieldID fieldID)) \ |
|
2713 JNIWrapper("Get" XSTR(Result) "Field"); \ |
|
2714 \ |
|
2715 EntryProbe; \ |
|
2716 Return ret = 0;\ |
|
2717 DT_RETURN_MARK_FOR(Result, Get##Result##Field, Return, (const Return&)ret);\ |
|
2718 \ |
|
2719 oop o = JNIHandles::resolve_non_null(obj); \ |
|
2720 klassOop k = o->klass(); \ |
|
2721 int offset = jfieldIDWorkaround::from_instance_jfieldID(k, fieldID); \ |
|
2722 /* Keep JVMTI addition small and only check enabled flag here. */ \ |
|
2723 /* jni_GetField_probe_nh() assumes that is not okay to create handles */ \ |
|
2724 /* and creates a ResetNoHandleMark. */ \ |
|
2725 if (JvmtiExport::should_post_field_access()) { \ |
|
2726 o = JvmtiExport::jni_GetField_probe_nh(thread, obj, o, k, fieldID, false); \ |
|
2727 } \ |
|
2728 ret = o->Fieldname##_field(offset); \ |
|
2729 return ret; \ |
|
2730 JNI_END |
|
2731 |
|
2732 DEFINE_GETFIELD(jboolean, bool, Boolean |
|
2733 , HOTSPOT_JNI_GETBOOLEANFIELD_ENTRY(env, obj, (uintptr_t)fieldID), |
|
2734 HOTSPOT_JNI_GETBOOLEANFIELD_RETURN(_ret_ref)) |
|
2735 DEFINE_GETFIELD(jbyte, byte, Byte |
|
2736 , HOTSPOT_JNI_GETBYTEFIELD_ENTRY(env, obj, (uintptr_t)fieldID), |
|
2737 HOTSPOT_JNI_GETBYTEFIELD_RETURN(_ret_ref)) |
|
2738 DEFINE_GETFIELD(jchar, char, Char |
|
2739 , HOTSPOT_JNI_GETCHARFIELD_ENTRY(env, obj, (uintptr_t)fieldID), |
|
2740 HOTSPOT_JNI_GETCHARFIELD_RETURN(_ret_ref)) |
|
2741 DEFINE_GETFIELD(jshort, short, Short |
|
2742 , HOTSPOT_JNI_GETSHORTFIELD_ENTRY(env, obj, (uintptr_t)fieldID), |
|
2743 HOTSPOT_JNI_GETSHORTFIELD_RETURN(_ret_ref)) |
|
2744 DEFINE_GETFIELD(jint, int, Int |
|
2745 , HOTSPOT_JNI_GETINTFIELD_ENTRY(env, obj, (uintptr_t)fieldID), |
|
2746 HOTSPOT_JNI_GETINTFIELD_RETURN(_ret_ref)) |
|
2747 DEFINE_GETFIELD(jlong, long, Long |
|
2748 , HOTSPOT_JNI_GETLONGFIELD_ENTRY(env, obj, (uintptr_t)fieldID), |
|
2749 HOTSPOT_JNI_GETLONGFIELD_RETURN(_ret_ref)) |
|
2750 // Float and double probes don't return value because dtrace doesn't currently support it |
|
2751 DEFINE_GETFIELD(jfloat, float, Float |
|
2752 , HOTSPOT_JNI_GETFLOATFIELD_ENTRY(env, obj, (uintptr_t)fieldID), |
|
2753 HOTSPOT_JNI_GETFLOATFIELD_RETURN()) |
|
2754 DEFINE_GETFIELD(jdouble, double, Double |
|
2755 , HOTSPOT_JNI_GETDOUBLEFIELD_ENTRY(env, obj, (uintptr_t)fieldID), |
|
2756 HOTSPOT_JNI_GETDOUBLEFIELD_RETURN()) |
|
2757 #endif /* USDT2 */ |
1782 |
2758 |
1783 address jni_GetBooleanField_addr() { |
2759 address jni_GetBooleanField_addr() { |
1784 return (address)jni_GetBooleanField; |
2760 return (address)jni_GetBooleanField; |
1785 } |
2761 } |
1786 address jni_GetByteField_addr() { |
2762 address jni_GetByteField_addr() { |
1855 DEFINE_SETFIELD(jint, int, Int, 'I', i) |
2842 DEFINE_SETFIELD(jint, int, Int, 'I', i) |
1856 DEFINE_SETFIELD(jlong, long, Long, 'J', j) |
2843 DEFINE_SETFIELD(jlong, long, Long, 'J', j) |
1857 DEFINE_SETFIELD(jfloat, float, Float, 'F', f) |
2844 DEFINE_SETFIELD(jfloat, float, Float, 'F', f) |
1858 DEFINE_SETFIELD(jdouble, double, Double, 'D', d) |
2845 DEFINE_SETFIELD(jdouble, double, Double, 'D', d) |
1859 |
2846 |
|
2847 #else /* USDT2 */ |
|
2848 |
|
2849 #define DEFINE_SETFIELD(Argument,Fieldname,Result,SigType,unionType \ |
|
2850 , EntryProbe, ReturnProbe) \ |
|
2851 \ |
|
2852 JNI_QUICK_ENTRY(void, jni_Set##Result##Field(JNIEnv *env, jobject obj, jfieldID fieldID, Argument value)) \ |
|
2853 JNIWrapper("Set" XSTR(Result) "Field"); \ |
|
2854 \ |
|
2855 EntryProbe; \ |
|
2856 \ |
|
2857 oop o = JNIHandles::resolve_non_null(obj); \ |
|
2858 klassOop k = o->klass(); \ |
|
2859 int offset = jfieldIDWorkaround::from_instance_jfieldID(k, fieldID); \ |
|
2860 /* Keep JVMTI addition small and only check enabled flag here. */ \ |
|
2861 /* jni_SetField_probe_nh() assumes that is not okay to create handles */ \ |
|
2862 /* and creates a ResetNoHandleMark. */ \ |
|
2863 if (JvmtiExport::should_post_field_modification()) { \ |
|
2864 jvalue field_value; \ |
|
2865 field_value.unionType = value; \ |
|
2866 o = JvmtiExport::jni_SetField_probe_nh(thread, obj, o, k, fieldID, false, SigType, (jvalue *)&field_value); \ |
|
2867 } \ |
|
2868 o->Fieldname##_field_put(offset, value); \ |
|
2869 ReturnProbe; \ |
|
2870 JNI_END |
|
2871 |
|
2872 DEFINE_SETFIELD(jboolean, bool, Boolean, 'Z', z |
|
2873 , HOTSPOT_JNI_SETBOOLEANFIELD_ENTRY(env, obj, (uintptr_t)fieldID, value), |
|
2874 HOTSPOT_JNI_SETBOOLEANFIELD_RETURN()) |
|
2875 DEFINE_SETFIELD(jbyte, byte, Byte, 'B', b |
|
2876 , HOTSPOT_JNI_SETBYTEFIELD_ENTRY(env, obj, (uintptr_t)fieldID, value), |
|
2877 HOTSPOT_JNI_SETBYTEFIELD_RETURN()) |
|
2878 DEFINE_SETFIELD(jchar, char, Char, 'C', c |
|
2879 , HOTSPOT_JNI_SETCHARFIELD_ENTRY(env, obj, (uintptr_t)fieldID, value), |
|
2880 HOTSPOT_JNI_SETCHARFIELD_RETURN()) |
|
2881 DEFINE_SETFIELD(jshort, short, Short, 'S', s |
|
2882 , HOTSPOT_JNI_SETSHORTFIELD_ENTRY(env, obj, (uintptr_t)fieldID, value), |
|
2883 HOTSPOT_JNI_SETSHORTFIELD_RETURN()) |
|
2884 DEFINE_SETFIELD(jint, int, Int, 'I', i |
|
2885 , HOTSPOT_JNI_SETINTFIELD_ENTRY(env, obj, (uintptr_t)fieldID, value), |
|
2886 HOTSPOT_JNI_SETINTFIELD_RETURN()) |
|
2887 DEFINE_SETFIELD(jlong, long, Long, 'J', j |
|
2888 , HOTSPOT_JNI_SETLONGFIELD_ENTRY(env, obj, (uintptr_t)fieldID, value), |
|
2889 HOTSPOT_JNI_SETLONGFIELD_RETURN()) |
|
2890 // Float and double probes don't return value because dtrace doesn't currently support it |
|
2891 DEFINE_SETFIELD(jfloat, float, Float, 'F', f |
|
2892 , HOTSPOT_JNI_SETFLOATFIELD_ENTRY(env, obj, (uintptr_t)fieldID), |
|
2893 HOTSPOT_JNI_SETFLOATFIELD_RETURN()) |
|
2894 DEFINE_SETFIELD(jdouble, double, Double, 'D', d |
|
2895 , HOTSPOT_JNI_SETDOUBLEFIELD_ENTRY(env, obj, (uintptr_t)fieldID), |
|
2896 HOTSPOT_JNI_SETDOUBLEFIELD_RETURN()) |
|
2897 #endif /* USDT2 */ |
|
2898 |
|
2899 #ifndef USDT2 |
1860 DT_RETURN_MARK_DECL(ToReflectedField, jobject); |
2900 DT_RETURN_MARK_DECL(ToReflectedField, jobject); |
|
2901 #else /* USDT2 */ |
|
2902 DT_RETURN_MARK_DECL(ToReflectedField, jobject |
|
2903 , HOTSPOT_JNI_TOREFLECTEDFIELD_RETURN(_ret_ref)); |
|
2904 #endif /* USDT2 */ |
1861 |
2905 |
1862 JNI_ENTRY(jobject, jni_ToReflectedField(JNIEnv *env, jclass cls, jfieldID fieldID, jboolean isStatic)) |
2906 JNI_ENTRY(jobject, jni_ToReflectedField(JNIEnv *env, jclass cls, jfieldID fieldID, jboolean isStatic)) |
1863 JNIWrapper("ToReflectedField"); |
2907 JNIWrapper("ToReflectedField"); |
|
2908 #ifndef USDT2 |
1864 DTRACE_PROBE4(hotspot_jni, ToReflectedField__entry, |
2909 DTRACE_PROBE4(hotspot_jni, ToReflectedField__entry, |
1865 env, cls, fieldID, isStatic); |
2910 env, cls, fieldID, isStatic); |
|
2911 #else /* USDT2 */ |
|
2912 HOTSPOT_JNI_TOREFLECTEDFIELD_ENTRY( |
|
2913 env, cls, (uintptr_t) fieldID, isStatic); |
|
2914 #endif /* USDT2 */ |
1866 jobject ret = NULL; |
2915 jobject ret = NULL; |
1867 DT_RETURN_MARK(ToReflectedField, jobject, (const jobject&)ret); |
2916 DT_RETURN_MARK(ToReflectedField, jobject, (const jobject&)ret); |
1868 |
2917 |
1869 fieldDescriptor fd; |
2918 fieldDescriptor fd; |
1870 bool found = false; |
2919 bool found = false; |
1977 DEFINE_GETSTATICFIELD(jint, int, Int) |
3047 DEFINE_GETSTATICFIELD(jint, int, Int) |
1978 DEFINE_GETSTATICFIELD(jlong, long, Long) |
3048 DEFINE_GETSTATICFIELD(jlong, long, Long) |
1979 DEFINE_GETSTATICFIELD(jfloat, float, Float) |
3049 DEFINE_GETSTATICFIELD(jfloat, float, Float) |
1980 DEFINE_GETSTATICFIELD(jdouble, double, Double) |
3050 DEFINE_GETSTATICFIELD(jdouble, double, Double) |
1981 |
3051 |
|
3052 #else /* USDT2 */ |
|
3053 |
|
3054 #define DEFINE_GETSTATICFIELD(Return,Fieldname,Result \ |
|
3055 , EntryProbe, ReturnProbe) \ |
|
3056 \ |
|
3057 DT_RETURN_MARK_DECL_FOR(Result, GetStatic##Result##Field, Return \ |
|
3058 , ReturnProbe); \ |
|
3059 \ |
|
3060 JNI_ENTRY(Return, jni_GetStatic##Result##Field(JNIEnv *env, jclass clazz, jfieldID fieldID)) \ |
|
3061 JNIWrapper("GetStatic" XSTR(Result) "Field"); \ |
|
3062 EntryProbe; \ |
|
3063 Return ret = 0;\ |
|
3064 DT_RETURN_MARK_FOR(Result, GetStatic##Result##Field, Return, \ |
|
3065 (const Return&)ret);\ |
|
3066 JNIid* id = jfieldIDWorkaround::from_static_jfieldID(fieldID); \ |
|
3067 assert(id->is_static_field_id(), "invalid static field id"); \ |
|
3068 /* Keep JVMTI addition small and only check enabled flag here. */ \ |
|
3069 /* jni_GetField_probe() assumes that is okay to create handles. */ \ |
|
3070 if (JvmtiExport::should_post_field_access()) { \ |
|
3071 JvmtiExport::jni_GetField_probe(thread, NULL, NULL, id->holder(), fieldID, true); \ |
|
3072 } \ |
|
3073 ret = id->holder()->java_mirror()-> Fieldname##_field (id->offset()); \ |
|
3074 return ret;\ |
|
3075 JNI_END |
|
3076 |
|
3077 DEFINE_GETSTATICFIELD(jboolean, bool, Boolean |
|
3078 , HOTSPOT_JNI_GETSTATICBOOLEANFIELD_ENTRY(env, clazz, (uintptr_t) fieldID), HOTSPOT_JNI_GETSTATICBOOLEANFIELD_RETURN(_ret_ref)) |
|
3079 DEFINE_GETSTATICFIELD(jbyte, byte, Byte |
|
3080 , HOTSPOT_JNI_GETSTATICBYTEFIELD_ENTRY(env, clazz, (uintptr_t) fieldID), HOTSPOT_JNI_GETSTATICBYTEFIELD_RETURN(_ret_ref) ) |
|
3081 DEFINE_GETSTATICFIELD(jchar, char, Char |
|
3082 , HOTSPOT_JNI_GETSTATICCHARFIELD_ENTRY(env, clazz, (uintptr_t) fieldID), HOTSPOT_JNI_GETSTATICCHARFIELD_RETURN(_ret_ref) ) |
|
3083 DEFINE_GETSTATICFIELD(jshort, short, Short |
|
3084 , HOTSPOT_JNI_GETSTATICSHORTFIELD_ENTRY(env, clazz, (uintptr_t) fieldID), HOTSPOT_JNI_GETSTATICSHORTFIELD_RETURN(_ret_ref) ) |
|
3085 DEFINE_GETSTATICFIELD(jint, int, Int |
|
3086 , HOTSPOT_JNI_GETSTATICINTFIELD_ENTRY(env, clazz, (uintptr_t) fieldID), HOTSPOT_JNI_GETSTATICINTFIELD_RETURN(_ret_ref) ) |
|
3087 DEFINE_GETSTATICFIELD(jlong, long, Long |
|
3088 , HOTSPOT_JNI_GETSTATICLONGFIELD_ENTRY(env, clazz, (uintptr_t) fieldID), HOTSPOT_JNI_GETSTATICLONGFIELD_RETURN(_ret_ref) ) |
|
3089 // Float and double probes don't return value because dtrace doesn't currently support it |
|
3090 DEFINE_GETSTATICFIELD(jfloat, float, Float |
|
3091 , HOTSPOT_JNI_GETSTATICFLOATFIELD_ENTRY(env, clazz, (uintptr_t) fieldID), HOTSPOT_JNI_GETSTATICFLOATFIELD_RETURN() ) |
|
3092 DEFINE_GETSTATICFIELD(jdouble, double, Double |
|
3093 , HOTSPOT_JNI_GETSTATICDOUBLEFIELD_ENTRY(env, clazz, (uintptr_t) fieldID), HOTSPOT_JNI_GETSTATICDOUBLEFIELD_RETURN() ) |
|
3094 #endif /* USDT2 */ |
1982 |
3095 |
1983 JNI_ENTRY(void, jni_SetStaticObjectField(JNIEnv *env, jclass clazz, jfieldID fieldID, jobject value)) |
3096 JNI_ENTRY(void, jni_SetStaticObjectField(JNIEnv *env, jclass clazz, jfieldID fieldID, jobject value)) |
1984 JNIWrapper("SetStaticObjectField"); |
3097 JNIWrapper("SetStaticObjectField"); |
|
3098 #ifndef USDT2 |
1985 DTRACE_PROBE4(hotspot_jni, SetStaticObjectField__entry, env, clazz, fieldID, value); |
3099 DTRACE_PROBE4(hotspot_jni, SetStaticObjectField__entry, env, clazz, fieldID, value); |
|
3100 #else /* USDT2 */ |
|
3101 HOTSPOT_JNI_SETSTATICOBJECTFIELD_ENTRY( |
|
3102 env, clazz, (uintptr_t) fieldID, value); |
|
3103 #endif /* USDT2 */ |
1986 JNIid* id = jfieldIDWorkaround::from_static_jfieldID(fieldID); |
3104 JNIid* id = jfieldIDWorkaround::from_static_jfieldID(fieldID); |
1987 assert(id->is_static_field_id(), "invalid static field id"); |
3105 assert(id->is_static_field_id(), "invalid static field id"); |
1988 // Keep JVMTI addition small and only check enabled flag here. |
3106 // Keep JVMTI addition small and only check enabled flag here. |
1989 // jni_SetField_probe() assumes that is okay to create handles. |
3107 // jni_SetField_probe() assumes that is okay to create handles. |
1990 if (JvmtiExport::should_post_field_modification()) { |
3108 if (JvmtiExport::should_post_field_modification()) { |
1991 jvalue field_value; |
3109 jvalue field_value; |
1992 field_value.l = value; |
3110 field_value.l = value; |
1993 JvmtiExport::jni_SetField_probe(thread, NULL, NULL, id->holder(), fieldID, true, 'L', (jvalue *)&field_value); |
3111 JvmtiExport::jni_SetField_probe(thread, NULL, NULL, id->holder(), fieldID, true, 'L', (jvalue *)&field_value); |
1994 } |
3112 } |
1995 id->holder()->java_mirror()->obj_field_put(id->offset(), JNIHandles::resolve(value)); |
3113 id->holder()->java_mirror()->obj_field_put(id->offset(), JNIHandles::resolve(value)); |
|
3114 #ifndef USDT2 |
1996 DTRACE_PROBE(hotspot_jni, SetStaticObjectField__return); |
3115 DTRACE_PROBE(hotspot_jni, SetStaticObjectField__return); |
1997 JNI_END |
3116 #else /* USDT2 */ |
1998 |
3117 HOTSPOT_JNI_SETSTATICOBJECTFIELD_RETURN( |
1999 |
3118 ); |
|
3119 #endif /* USDT2 */ |
|
3120 JNI_END |
|
3121 |
|
3122 |
|
3123 #ifndef USDT2 |
2000 #define DEFINE_SETSTATICFIELD(Argument,Fieldname,Result,SigType,unionType) \ |
3124 #define DEFINE_SETSTATICFIELD(Argument,Fieldname,Result,SigType,unionType) \ |
2001 \ |
3125 \ |
2002 JNI_ENTRY(void, jni_SetStatic##Result##Field(JNIEnv *env, jclass clazz, jfieldID fieldID, Argument value)) \ |
3126 JNI_ENTRY(void, jni_SetStatic##Result##Field(JNIEnv *env, jclass clazz, jfieldID fieldID, Argument value)) \ |
2003 JNIWrapper("SetStatic" XSTR(Result) "Field"); \ |
3127 JNIWrapper("SetStatic" XSTR(Result) "Field"); \ |
2004 HS_DTRACE_PROBE_CDECL_N(hotspot_jni, SetStatic##Result##Field__entry,\ |
3128 HS_DTRACE_PROBE_CDECL_N(hotspot_jni, SetStatic##Result##Field__entry,\ |
2026 DEFINE_SETSTATICFIELD(jint, int, Int, 'I', i) |
3150 DEFINE_SETSTATICFIELD(jint, int, Int, 'I', i) |
2027 DEFINE_SETSTATICFIELD(jlong, long, Long, 'J', j) |
3151 DEFINE_SETSTATICFIELD(jlong, long, Long, 'J', j) |
2028 DEFINE_SETSTATICFIELD(jfloat, float, Float, 'F', f) |
3152 DEFINE_SETSTATICFIELD(jfloat, float, Float, 'F', f) |
2029 DEFINE_SETSTATICFIELD(jdouble, double, Double, 'D', d) |
3153 DEFINE_SETSTATICFIELD(jdouble, double, Double, 'D', d) |
2030 |
3154 |
|
3155 #else /* USDT2 */ |
|
3156 |
|
3157 #define DEFINE_SETSTATICFIELD(Argument,Fieldname,Result,SigType,unionType \ |
|
3158 , EntryProbe, ReturnProbe) \ |
|
3159 \ |
|
3160 JNI_ENTRY(void, jni_SetStatic##Result##Field(JNIEnv *env, jclass clazz, jfieldID fieldID, Argument value)) \ |
|
3161 JNIWrapper("SetStatic" XSTR(Result) "Field"); \ |
|
3162 EntryProbe; \ |
|
3163 \ |
|
3164 JNIid* id = jfieldIDWorkaround::from_static_jfieldID(fieldID); \ |
|
3165 assert(id->is_static_field_id(), "invalid static field id"); \ |
|
3166 /* Keep JVMTI addition small and only check enabled flag here. */ \ |
|
3167 /* jni_SetField_probe() assumes that is okay to create handles. */ \ |
|
3168 if (JvmtiExport::should_post_field_modification()) { \ |
|
3169 jvalue field_value; \ |
|
3170 field_value.unionType = value; \ |
|
3171 JvmtiExport::jni_SetField_probe(thread, NULL, NULL, id->holder(), fieldID, true, SigType, (jvalue *)&field_value); \ |
|
3172 } \ |
|
3173 id->holder()->java_mirror()-> Fieldname##_field_put (id->offset(), value); \ |
|
3174 ReturnProbe;\ |
|
3175 JNI_END |
|
3176 |
|
3177 DEFINE_SETSTATICFIELD(jboolean, bool, Boolean, 'Z', z |
|
3178 , HOTSPOT_JNI_SETBOOLEANFIELD_ENTRY(env, clazz, (uintptr_t)fieldID, value), |
|
3179 HOTSPOT_JNI_SETBOOLEANFIELD_RETURN()) |
|
3180 DEFINE_SETSTATICFIELD(jbyte, byte, Byte, 'B', b |
|
3181 , HOTSPOT_JNI_SETSTATICBYTEFIELD_ENTRY(env, clazz, (uintptr_t) fieldID, value), |
|
3182 HOTSPOT_JNI_SETSTATICBYTEFIELD_RETURN()) |
|
3183 DEFINE_SETSTATICFIELD(jchar, char, Char, 'C', c |
|
3184 , HOTSPOT_JNI_SETSTATICCHARFIELD_ENTRY(env, clazz, (uintptr_t) fieldID, value), |
|
3185 HOTSPOT_JNI_SETSTATICCHARFIELD_RETURN()) |
|
3186 DEFINE_SETSTATICFIELD(jshort, short, Short, 'S', s |
|
3187 , HOTSPOT_JNI_SETSTATICSHORTFIELD_ENTRY(env, clazz, (uintptr_t) fieldID, value), |
|
3188 HOTSPOT_JNI_SETSTATICSHORTFIELD_RETURN()) |
|
3189 DEFINE_SETSTATICFIELD(jint, int, Int, 'I', i |
|
3190 , HOTSPOT_JNI_SETSTATICINTFIELD_ENTRY(env, clazz, (uintptr_t) fieldID, value), |
|
3191 HOTSPOT_JNI_SETSTATICINTFIELD_RETURN()) |
|
3192 DEFINE_SETSTATICFIELD(jlong, long, Long, 'J', j |
|
3193 , HOTSPOT_JNI_SETSTATICLONGFIELD_ENTRY(env, clazz, (uintptr_t) fieldID, value), |
|
3194 HOTSPOT_JNI_SETSTATICLONGFIELD_RETURN()) |
|
3195 // Float and double probes don't return value because dtrace doesn't currently support it |
|
3196 DEFINE_SETSTATICFIELD(jfloat, float, Float, 'F', f |
|
3197 , HOTSPOT_JNI_SETSTATICFLOATFIELD_ENTRY(env, clazz, (uintptr_t) fieldID), |
|
3198 HOTSPOT_JNI_SETSTATICFLOATFIELD_RETURN()) |
|
3199 DEFINE_SETSTATICFIELD(jdouble, double, Double, 'D', d |
|
3200 , HOTSPOT_JNI_SETSTATICDOUBLEFIELD_ENTRY(env, clazz, (uintptr_t) fieldID), |
|
3201 HOTSPOT_JNI_SETSTATICDOUBLEFIELD_RETURN()) |
|
3202 #endif /* USDT2 */ |
2031 |
3203 |
2032 // |
3204 // |
2033 // String Operations |
3205 // String Operations |
2034 // |
3206 // |
2035 |
3207 |
2036 // Unicode Interface |
3208 // Unicode Interface |
2037 |
3209 |
|
3210 #ifndef USDT2 |
2038 DT_RETURN_MARK_DECL(NewString, jstring); |
3211 DT_RETURN_MARK_DECL(NewString, jstring); |
|
3212 #else /* USDT2 */ |
|
3213 DT_RETURN_MARK_DECL(NewString, jstring |
|
3214 , HOTSPOT_JNI_NEWSTRING_RETURN(_ret_ref)); |
|
3215 #endif /* USDT2 */ |
2039 |
3216 |
2040 JNI_ENTRY(jstring, jni_NewString(JNIEnv *env, const jchar *unicodeChars, jsize len)) |
3217 JNI_ENTRY(jstring, jni_NewString(JNIEnv *env, const jchar *unicodeChars, jsize len)) |
2041 JNIWrapper("NewString"); |
3218 JNIWrapper("NewString"); |
|
3219 #ifndef USDT2 |
2042 DTRACE_PROBE3(hotspot_jni, NewString__entry, env, unicodeChars, len); |
3220 DTRACE_PROBE3(hotspot_jni, NewString__entry, env, unicodeChars, len); |
|
3221 #else /* USDT2 */ |
|
3222 HOTSPOT_JNI_NEWSTRING_ENTRY( |
|
3223 env, (uint16_t *) unicodeChars, len); |
|
3224 #endif /* USDT2 */ |
2043 jstring ret = NULL; |
3225 jstring ret = NULL; |
2044 DT_RETURN_MARK(NewString, jstring, (const jstring&)ret); |
3226 DT_RETURN_MARK(NewString, jstring, (const jstring&)ret); |
2045 oop string=java_lang_String::create_oop_from_unicode((jchar*) unicodeChars, len, CHECK_NULL); |
3227 oop string=java_lang_String::create_oop_from_unicode((jchar*) unicodeChars, len, CHECK_NULL); |
2046 ret = (jstring) JNIHandles::make_local(env, string); |
3228 ret = (jstring) JNIHandles::make_local(env, string); |
2047 return ret; |
3229 return ret; |
2048 JNI_END |
3230 JNI_END |
2049 |
3231 |
2050 |
3232 |
2051 JNI_QUICK_ENTRY(jsize, jni_GetStringLength(JNIEnv *env, jstring string)) |
3233 JNI_QUICK_ENTRY(jsize, jni_GetStringLength(JNIEnv *env, jstring string)) |
2052 JNIWrapper("GetStringLength"); |
3234 JNIWrapper("GetStringLength"); |
|
3235 #ifndef USDT2 |
2053 DTRACE_PROBE2(hotspot_jni, GetStringLength__entry, env, string); |
3236 DTRACE_PROBE2(hotspot_jni, GetStringLength__entry, env, string); |
|
3237 #else /* USDT2 */ |
|
3238 HOTSPOT_JNI_GETSTRINGLENGTH_ENTRY( |
|
3239 env, string); |
|
3240 #endif /* USDT2 */ |
2054 jsize ret = java_lang_String::length(JNIHandles::resolve_non_null(string)); |
3241 jsize ret = java_lang_String::length(JNIHandles::resolve_non_null(string)); |
|
3242 #ifndef USDT2 |
2055 DTRACE_PROBE1(hotspot_jni, GetStringLength__return, ret); |
3243 DTRACE_PROBE1(hotspot_jni, GetStringLength__return, ret); |
|
3244 #else /* USDT2 */ |
|
3245 HOTSPOT_JNI_GETSTRINGLENGTH_RETURN( |
|
3246 ret); |
|
3247 #endif /* USDT2 */ |
2056 return ret; |
3248 return ret; |
2057 JNI_END |
3249 JNI_END |
2058 |
3250 |
2059 |
3251 |
2060 JNI_QUICK_ENTRY(const jchar*, jni_GetStringChars( |
3252 JNI_QUICK_ENTRY(const jchar*, jni_GetStringChars( |
2061 JNIEnv *env, jstring string, jboolean *isCopy)) |
3253 JNIEnv *env, jstring string, jboolean *isCopy)) |
2062 JNIWrapper("GetStringChars"); |
3254 JNIWrapper("GetStringChars"); |
|
3255 #ifndef USDT2 |
2063 DTRACE_PROBE3(hotspot_jni, GetStringChars__entry, env, string, isCopy); |
3256 DTRACE_PROBE3(hotspot_jni, GetStringChars__entry, env, string, isCopy); |
|
3257 #else /* USDT2 */ |
|
3258 HOTSPOT_JNI_GETSTRINGCHARS_ENTRY( |
|
3259 env, string, (uintptr_t *) isCopy); |
|
3260 #endif /* USDT2 */ |
2064 //%note jni_5 |
3261 //%note jni_5 |
2065 if (isCopy != NULL) { |
3262 if (isCopy != NULL) { |
2066 *isCopy = JNI_TRUE; |
3263 *isCopy = JNI_TRUE; |
2067 } |
3264 } |
2068 oop s = JNIHandles::resolve_non_null(string); |
3265 oop s = JNIHandles::resolve_non_null(string); |
2072 jchar* buf = NEW_C_HEAP_ARRAY(jchar, s_len + 1); // add one for zero termination |
3269 jchar* buf = NEW_C_HEAP_ARRAY(jchar, s_len + 1); // add one for zero termination |
2073 if (s_len > 0) { |
3270 if (s_len > 0) { |
2074 memcpy(buf, s_value->char_at_addr(s_offset), sizeof(jchar)*s_len); |
3271 memcpy(buf, s_value->char_at_addr(s_offset), sizeof(jchar)*s_len); |
2075 } |
3272 } |
2076 buf[s_len] = 0; |
3273 buf[s_len] = 0; |
|
3274 #ifndef USDT2 |
2077 DTRACE_PROBE1(hotspot_jni, GetStringChars__return, buf); |
3275 DTRACE_PROBE1(hotspot_jni, GetStringChars__return, buf); |
|
3276 #else /* USDT2 */ |
|
3277 HOTSPOT_JNI_GETSTRINGCHARS_RETURN( |
|
3278 buf); |
|
3279 #endif /* USDT2 */ |
2078 return buf; |
3280 return buf; |
2079 JNI_END |
3281 JNI_END |
2080 |
3282 |
2081 |
3283 |
2082 JNI_QUICK_ENTRY(void, jni_ReleaseStringChars(JNIEnv *env, jstring str, const jchar *chars)) |
3284 JNI_QUICK_ENTRY(void, jni_ReleaseStringChars(JNIEnv *env, jstring str, const jchar *chars)) |
2083 JNIWrapper("ReleaseStringChars"); |
3285 JNIWrapper("ReleaseStringChars"); |
|
3286 #ifndef USDT2 |
2084 DTRACE_PROBE3(hotspot_jni, ReleaseStringChars__entry, env, str, chars); |
3287 DTRACE_PROBE3(hotspot_jni, ReleaseStringChars__entry, env, str, chars); |
|
3288 #else /* USDT2 */ |
|
3289 HOTSPOT_JNI_RELEASESTRINGCHARS_ENTRY( |
|
3290 env, str, (uint16_t *) chars); |
|
3291 #endif /* USDT2 */ |
2085 //%note jni_6 |
3292 //%note jni_6 |
2086 if (chars != NULL) { |
3293 if (chars != NULL) { |
2087 // Since String objects are supposed to be immutable, don't copy any |
3294 // Since String objects are supposed to be immutable, don't copy any |
2088 // new data back. A bad user will have to go after the char array. |
3295 // new data back. A bad user will have to go after the char array. |
2089 FreeHeap((void*) chars); |
3296 FreeHeap((void*) chars); |
2090 } |
3297 } |
|
3298 #ifndef USDT2 |
2091 DTRACE_PROBE(hotspot_jni, ReleaseStringChars__return); |
3299 DTRACE_PROBE(hotspot_jni, ReleaseStringChars__return); |
|
3300 #else /* USDT2 */ |
|
3301 HOTSPOT_JNI_RELEASESTRINGCHARS_RETURN( |
|
3302 ); |
|
3303 #endif /* USDT2 */ |
2092 JNI_END |
3304 JNI_END |
2093 |
3305 |
2094 |
3306 |
2095 // UTF Interface |
3307 // UTF Interface |
2096 |
3308 |
|
3309 #ifndef USDT2 |
2097 DT_RETURN_MARK_DECL(NewStringUTF, jstring); |
3310 DT_RETURN_MARK_DECL(NewStringUTF, jstring); |
|
3311 #else /* USDT2 */ |
|
3312 DT_RETURN_MARK_DECL(NewStringUTF, jstring |
|
3313 , HOTSPOT_JNI_NEWSTRINGUTF_RETURN(_ret_ref)); |
|
3314 #endif /* USDT2 */ |
2098 |
3315 |
2099 JNI_ENTRY(jstring, jni_NewStringUTF(JNIEnv *env, const char *bytes)) |
3316 JNI_ENTRY(jstring, jni_NewStringUTF(JNIEnv *env, const char *bytes)) |
2100 JNIWrapper("NewStringUTF"); |
3317 JNIWrapper("NewStringUTF"); |
|
3318 #ifndef USDT2 |
2101 DTRACE_PROBE2(hotspot_jni, NewStringUTF__entry, env, bytes); |
3319 DTRACE_PROBE2(hotspot_jni, NewStringUTF__entry, env, bytes); |
|
3320 #else /* USDT2 */ |
|
3321 HOTSPOT_JNI_NEWSTRINGUTF_ENTRY( |
|
3322 env, (char *) bytes); |
|
3323 #endif /* USDT2 */ |
2102 jstring ret; |
3324 jstring ret; |
2103 DT_RETURN_MARK(NewStringUTF, jstring, (const jstring&)ret); |
3325 DT_RETURN_MARK(NewStringUTF, jstring, (const jstring&)ret); |
2104 |
3326 |
2105 oop result = java_lang_String::create_oop_from_str((char*) bytes, CHECK_NULL); |
3327 oop result = java_lang_String::create_oop_from_str((char*) bytes, CHECK_NULL); |
2106 ret = (jstring) JNIHandles::make_local(env, result); |
3328 ret = (jstring) JNIHandles::make_local(env, result); |
2108 JNI_END |
3330 JNI_END |
2109 |
3331 |
2110 |
3332 |
2111 JNI_ENTRY(jsize, jni_GetStringUTFLength(JNIEnv *env, jstring string)) |
3333 JNI_ENTRY(jsize, jni_GetStringUTFLength(JNIEnv *env, jstring string)) |
2112 JNIWrapper("GetStringUTFLength"); |
3334 JNIWrapper("GetStringUTFLength"); |
|
3335 #ifndef USDT2 |
2113 DTRACE_PROBE2(hotspot_jni, GetStringUTFLength__entry, env, string); |
3336 DTRACE_PROBE2(hotspot_jni, GetStringUTFLength__entry, env, string); |
|
3337 #else /* USDT2 */ |
|
3338 HOTSPOT_JNI_GETSTRINGUTFLENGTH_ENTRY( |
|
3339 env, string); |
|
3340 #endif /* USDT2 */ |
2114 jsize ret = java_lang_String::utf8_length(JNIHandles::resolve_non_null(string)); |
3341 jsize ret = java_lang_String::utf8_length(JNIHandles::resolve_non_null(string)); |
|
3342 #ifndef USDT2 |
2115 DTRACE_PROBE1(hotspot_jni, GetStringUTFLength__return, ret); |
3343 DTRACE_PROBE1(hotspot_jni, GetStringUTFLength__return, ret); |
|
3344 #else /* USDT2 */ |
|
3345 HOTSPOT_JNI_GETSTRINGUTFLENGTH_RETURN( |
|
3346 ret); |
|
3347 #endif /* USDT2 */ |
2116 return ret; |
3348 return ret; |
2117 JNI_END |
3349 JNI_END |
2118 |
3350 |
2119 |
3351 |
2120 JNI_ENTRY(const char*, jni_GetStringUTFChars(JNIEnv *env, jstring string, jboolean *isCopy)) |
3352 JNI_ENTRY(const char*, jni_GetStringUTFChars(JNIEnv *env, jstring string, jboolean *isCopy)) |
2121 JNIWrapper("GetStringUTFChars"); |
3353 JNIWrapper("GetStringUTFChars"); |
|
3354 #ifndef USDT2 |
2122 DTRACE_PROBE3(hotspot_jni, GetStringUTFChars__entry, env, string, isCopy); |
3355 DTRACE_PROBE3(hotspot_jni, GetStringUTFChars__entry, env, string, isCopy); |
|
3356 #else /* USDT2 */ |
|
3357 HOTSPOT_JNI_GETSTRINGUTFCHARS_ENTRY( |
|
3358 env, string, (uintptr_t *) isCopy); |
|
3359 #endif /* USDT2 */ |
2123 oop java_string = JNIHandles::resolve_non_null(string); |
3360 oop java_string = JNIHandles::resolve_non_null(string); |
2124 size_t length = java_lang_String::utf8_length(java_string); |
3361 size_t length = java_lang_String::utf8_length(java_string); |
2125 char* result = AllocateHeap(length + 1, "GetStringUTFChars"); |
3362 char* result = AllocateHeap(length + 1, "GetStringUTFChars"); |
2126 java_lang_String::as_utf8_string(java_string, result, (int) length + 1); |
3363 java_lang_String::as_utf8_string(java_string, result, (int) length + 1); |
2127 if (isCopy != NULL) *isCopy = JNI_TRUE; |
3364 if (isCopy != NULL) *isCopy = JNI_TRUE; |
|
3365 #ifndef USDT2 |
2128 DTRACE_PROBE1(hotspot_jni, GetStringUTFChars__return, result); |
3366 DTRACE_PROBE1(hotspot_jni, GetStringUTFChars__return, result); |
|
3367 #else /* USDT2 */ |
|
3368 HOTSPOT_JNI_GETSTRINGUTFCHARS_RETURN( |
|
3369 result); |
|
3370 #endif /* USDT2 */ |
2129 return result; |
3371 return result; |
2130 JNI_END |
3372 JNI_END |
2131 |
3373 |
2132 |
3374 |
2133 JNI_LEAF(void, jni_ReleaseStringUTFChars(JNIEnv *env, jstring str, const char *chars)) |
3375 JNI_LEAF(void, jni_ReleaseStringUTFChars(JNIEnv *env, jstring str, const char *chars)) |
2134 JNIWrapper("ReleaseStringUTFChars"); |
3376 JNIWrapper("ReleaseStringUTFChars"); |
|
3377 #ifndef USDT2 |
2135 DTRACE_PROBE3(hotspot_jni, ReleaseStringUTFChars__entry, env, str, chars); |
3378 DTRACE_PROBE3(hotspot_jni, ReleaseStringUTFChars__entry, env, str, chars); |
|
3379 #else /* USDT2 */ |
|
3380 HOTSPOT_JNI_RELEASESTRINGUTFCHARS_ENTRY( |
|
3381 env, str, (char *) chars); |
|
3382 #endif /* USDT2 */ |
2136 if (chars != NULL) { |
3383 if (chars != NULL) { |
2137 FreeHeap((char*) chars); |
3384 FreeHeap((char*) chars); |
2138 } |
3385 } |
|
3386 #ifndef USDT2 |
2139 DTRACE_PROBE(hotspot_jni, ReleaseStringUTFChars__return); |
3387 DTRACE_PROBE(hotspot_jni, ReleaseStringUTFChars__return); |
|
3388 #else /* USDT2 */ |
|
3389 HOTSPOT_JNI_RELEASESTRINGUTFCHARS_RETURN( |
|
3390 ); |
|
3391 #endif /* USDT2 */ |
2140 JNI_END |
3392 JNI_END |
2141 |
3393 |
2142 |
3394 |
2143 JNI_QUICK_ENTRY(jsize, jni_GetArrayLength(JNIEnv *env, jarray array)) |
3395 JNI_QUICK_ENTRY(jsize, jni_GetArrayLength(JNIEnv *env, jarray array)) |
2144 JNIWrapper("GetArrayLength"); |
3396 JNIWrapper("GetArrayLength"); |
|
3397 #ifndef USDT2 |
2145 DTRACE_PROBE2(hotspot_jni, GetArrayLength__entry, env, array); |
3398 DTRACE_PROBE2(hotspot_jni, GetArrayLength__entry, env, array); |
|
3399 #else /* USDT2 */ |
|
3400 HOTSPOT_JNI_GETARRAYLENGTH_ENTRY( |
|
3401 env, array); |
|
3402 #endif /* USDT2 */ |
2146 arrayOop a = arrayOop(JNIHandles::resolve_non_null(array)); |
3403 arrayOop a = arrayOop(JNIHandles::resolve_non_null(array)); |
2147 assert(a->is_array(), "must be array"); |
3404 assert(a->is_array(), "must be array"); |
2148 jsize ret = a->length(); |
3405 jsize ret = a->length(); |
|
3406 #ifndef USDT2 |
2149 DTRACE_PROBE1(hotspot_jni, GetArrayLength__return, ret); |
3407 DTRACE_PROBE1(hotspot_jni, GetArrayLength__return, ret); |
|
3408 #else /* USDT2 */ |
|
3409 HOTSPOT_JNI_GETARRAYLENGTH_RETURN( |
|
3410 ret); |
|
3411 #endif /* USDT2 */ |
2150 return ret; |
3412 return ret; |
2151 JNI_END |
3413 JNI_END |
2152 |
3414 |
2153 |
3415 |
2154 // |
3416 // |
2155 // Object Array Operations |
3417 // Object Array Operations |
2156 // |
3418 // |
2157 |
3419 |
|
3420 #ifndef USDT2 |
2158 DT_RETURN_MARK_DECL(NewObjectArray, jobjectArray); |
3421 DT_RETURN_MARK_DECL(NewObjectArray, jobjectArray); |
|
3422 #else /* USDT2 */ |
|
3423 DT_RETURN_MARK_DECL(NewObjectArray, jobjectArray |
|
3424 , HOTSPOT_JNI_NEWOBJECTARRAY_RETURN(_ret_ref)); |
|
3425 #endif /* USDT2 */ |
2159 |
3426 |
2160 JNI_ENTRY(jobjectArray, jni_NewObjectArray(JNIEnv *env, jsize length, jclass elementClass, jobject initialElement)) |
3427 JNI_ENTRY(jobjectArray, jni_NewObjectArray(JNIEnv *env, jsize length, jclass elementClass, jobject initialElement)) |
2161 JNIWrapper("NewObjectArray"); |
3428 JNIWrapper("NewObjectArray"); |
|
3429 #ifndef USDT2 |
2162 DTRACE_PROBE4(hotspot_jni, NewObjectArray__entry, env, length, elementClass, initialElement); |
3430 DTRACE_PROBE4(hotspot_jni, NewObjectArray__entry, env, length, elementClass, initialElement); |
|
3431 #else /* USDT2 */ |
|
3432 HOTSPOT_JNI_NEWOBJECTARRAY_ENTRY( |
|
3433 env, length, elementClass, initialElement); |
|
3434 #endif /* USDT2 */ |
2163 jobjectArray ret = NULL; |
3435 jobjectArray ret = NULL; |
2164 DT_RETURN_MARK(NewObjectArray, jobjectArray, (const jobjectArray&)ret); |
3436 DT_RETURN_MARK(NewObjectArray, jobjectArray, (const jobjectArray&)ret); |
2165 KlassHandle ek(THREAD, java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(elementClass))); |
3437 KlassHandle ek(THREAD, java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(elementClass))); |
2166 klassOop ako = Klass::cast(ek())->array_klass(CHECK_NULL); |
3438 klassOop ako = Klass::cast(ek())->array_klass(CHECK_NULL); |
2167 KlassHandle ak = KlassHandle(THREAD, ako); |
3439 KlassHandle ak = KlassHandle(THREAD, ako); |
2241 DEFINE_NEWSCALARARRAY(jintArray, new_intArray, Int) |
3534 DEFINE_NEWSCALARARRAY(jintArray, new_intArray, Int) |
2242 DEFINE_NEWSCALARARRAY(jlongArray, new_longArray, Long) |
3535 DEFINE_NEWSCALARARRAY(jlongArray, new_longArray, Long) |
2243 DEFINE_NEWSCALARARRAY(jfloatArray, new_singleArray, Float) |
3536 DEFINE_NEWSCALARARRAY(jfloatArray, new_singleArray, Float) |
2244 DEFINE_NEWSCALARARRAY(jdoubleArray, new_doubleArray, Double) |
3537 DEFINE_NEWSCALARARRAY(jdoubleArray, new_doubleArray, Double) |
2245 |
3538 |
|
3539 #else /* USDT2 */ |
|
3540 |
|
3541 #define DEFINE_NEWSCALARARRAY(Return,Allocator,Result \ |
|
3542 ,EntryProbe,ReturnProbe) \ |
|
3543 \ |
|
3544 DT_RETURN_MARK_DECL(New##Result##Array, Return \ |
|
3545 , ReturnProbe); \ |
|
3546 \ |
|
3547 JNI_ENTRY(Return, \ |
|
3548 jni_New##Result##Array(JNIEnv *env, jsize len)) \ |
|
3549 JNIWrapper("New" XSTR(Result) "Array"); \ |
|
3550 EntryProbe; \ |
|
3551 Return ret = NULL;\ |
|
3552 DT_RETURN_MARK(New##Result##Array, Return, (const Return&)ret);\ |
|
3553 \ |
|
3554 oop obj= oopFactory::Allocator(len, CHECK_0); \ |
|
3555 ret = (Return) JNIHandles::make_local(env, obj); \ |
|
3556 return ret;\ |
|
3557 JNI_END |
|
3558 |
|
3559 DEFINE_NEWSCALARARRAY(jbooleanArray, new_boolArray, Boolean, |
|
3560 HOTSPOT_JNI_NEWBOOLEANARRAY_ENTRY(env, len), |
|
3561 HOTSPOT_JNI_NEWBOOLEANARRAY_RETURN(_ret_ref)) |
|
3562 DEFINE_NEWSCALARARRAY(jbyteArray, new_byteArray, Byte, |
|
3563 HOTSPOT_JNI_NEWBYTEARRAY_ENTRY(env, len), |
|
3564 HOTSPOT_JNI_NEWBYTEARRAY_RETURN(_ret_ref)) |
|
3565 DEFINE_NEWSCALARARRAY(jshortArray, new_shortArray, Short, |
|
3566 HOTSPOT_JNI_NEWSHORTARRAY_ENTRY(env, len), |
|
3567 HOTSPOT_JNI_NEWSHORTARRAY_RETURN(_ret_ref)) |
|
3568 DEFINE_NEWSCALARARRAY(jcharArray, new_charArray, Char, |
|
3569 HOTSPOT_JNI_NEWCHARARRAY_ENTRY(env, len), |
|
3570 HOTSPOT_JNI_NEWCHARARRAY_RETURN(_ret_ref)) |
|
3571 DEFINE_NEWSCALARARRAY(jintArray, new_intArray, Int, |
|
3572 HOTSPOT_JNI_NEWINTARRAY_ENTRY(env, len), |
|
3573 HOTSPOT_JNI_NEWINTARRAY_RETURN(_ret_ref)) |
|
3574 DEFINE_NEWSCALARARRAY(jlongArray, new_longArray, Long, |
|
3575 HOTSPOT_JNI_NEWLONGARRAY_ENTRY(env, len), |
|
3576 HOTSPOT_JNI_NEWLONGARRAY_RETURN(_ret_ref)) |
|
3577 DEFINE_NEWSCALARARRAY(jfloatArray, new_singleArray, Float, |
|
3578 HOTSPOT_JNI_NEWFLOATARRAY_ENTRY(env, len), |
|
3579 HOTSPOT_JNI_NEWFLOATARRAY_RETURN(_ret_ref)) |
|
3580 DEFINE_NEWSCALARARRAY(jdoubleArray, new_doubleArray, Double, |
|
3581 HOTSPOT_JNI_NEWDOUBLEARRAY_ENTRY(env, len), |
|
3582 HOTSPOT_JNI_NEWDOUBLEARRAY_RETURN(_ret_ref)) |
|
3583 #endif /* USDT2 */ |
2246 |
3584 |
2247 // Return an address which will fault if the caller writes to it. |
3585 // Return an address which will fault if the caller writes to it. |
2248 |
3586 |
2249 static char* get_bad_address() { |
3587 static char* get_bad_address() { |
2250 static char* bad_address = NULL; |
3588 static char* bad_address = NULL; |
2292 DEFINE_GETSCALARARRAYELEMENTS(T_INT, jint, Int, int) |
3631 DEFINE_GETSCALARARRAYELEMENTS(T_INT, jint, Int, int) |
2293 DEFINE_GETSCALARARRAYELEMENTS(T_LONG, jlong, Long, long) |
3632 DEFINE_GETSCALARARRAYELEMENTS(T_LONG, jlong, Long, long) |
2294 DEFINE_GETSCALARARRAYELEMENTS(T_FLOAT, jfloat, Float, float) |
3633 DEFINE_GETSCALARARRAYELEMENTS(T_FLOAT, jfloat, Float, float) |
2295 DEFINE_GETSCALARARRAYELEMENTS(T_DOUBLE, jdouble, Double, double) |
3634 DEFINE_GETSCALARARRAYELEMENTS(T_DOUBLE, jdouble, Double, double) |
2296 |
3635 |
2297 |
3636 #else /* USDT2 */ |
|
3637 |
|
3638 #define DEFINE_GETSCALARARRAYELEMENTS(ElementTag,ElementType,Result, Tag \ |
|
3639 , EntryProbe, ReturnProbe) \ |
|
3640 \ |
|
3641 JNI_QUICK_ENTRY(ElementType*, \ |
|
3642 jni_Get##Result##ArrayElements(JNIEnv *env, ElementType##Array array, jboolean *isCopy)) \ |
|
3643 JNIWrapper("Get" XSTR(Result) "ArrayElements"); \ |
|
3644 EntryProbe; \ |
|
3645 /* allocate an chunk of memory in c land */ \ |
|
3646 typeArrayOop a = typeArrayOop(JNIHandles::resolve_non_null(array)); \ |
|
3647 ElementType* result; \ |
|
3648 int len = a->length(); \ |
|
3649 if (len == 0) { \ |
|
3650 /* Empty array: legal but useless, can't return NULL. \ |
|
3651 * Return a pointer to something useless. \ |
|
3652 * Avoid asserts in typeArrayOop. */ \ |
|
3653 result = (ElementType*)get_bad_address(); \ |
|
3654 } else { \ |
|
3655 result = NEW_C_HEAP_ARRAY(ElementType, len); \ |
|
3656 /* copy the array to the c chunk */ \ |
|
3657 memcpy(result, a->Tag##_at_addr(0), sizeof(ElementType)*len); \ |
|
3658 } \ |
|
3659 if (isCopy) *isCopy = JNI_TRUE; \ |
|
3660 ReturnProbe; \ |
|
3661 return result; \ |
|
3662 JNI_END |
|
3663 |
|
3664 DEFINE_GETSCALARARRAYELEMENTS(T_BOOLEAN, jboolean, Boolean, bool |
|
3665 , HOTSPOT_JNI_GETBOOLEANARRAYELEMENTS_ENTRY(env, array, (uintptr_t *) isCopy), |
|
3666 HOTSPOT_JNI_GETBOOLEANARRAYELEMENTS_RETURN((uintptr_t*)result)) |
|
3667 DEFINE_GETSCALARARRAYELEMENTS(T_BYTE, jbyte, Byte, byte |
|
3668 , HOTSPOT_JNI_GETBYTEARRAYELEMENTS_ENTRY(env, array, (uintptr_t *) isCopy), |
|
3669 HOTSPOT_JNI_GETBYTEARRAYELEMENTS_RETURN((char*)result)) |
|
3670 DEFINE_GETSCALARARRAYELEMENTS(T_SHORT, jshort, Short, short |
|
3671 , HOTSPOT_JNI_GETSHORTARRAYELEMENTS_ENTRY(env, (uint16_t*) array, (uintptr_t *) isCopy), |
|
3672 HOTSPOT_JNI_GETSHORTARRAYELEMENTS_RETURN((uint16_t*)result)) |
|
3673 DEFINE_GETSCALARARRAYELEMENTS(T_CHAR, jchar, Char, char |
|
3674 , HOTSPOT_JNI_GETCHARARRAYELEMENTS_ENTRY(env, (uint16_t*) array, (uintptr_t *) isCopy), |
|
3675 HOTSPOT_JNI_GETCHARARRAYELEMENTS_RETURN(result)) |
|
3676 DEFINE_GETSCALARARRAYELEMENTS(T_INT, jint, Int, int |
|
3677 , HOTSPOT_JNI_GETINTARRAYELEMENTS_ENTRY(env, array, (uintptr_t *) isCopy), |
|
3678 HOTSPOT_JNI_GETINTARRAYELEMENTS_RETURN((uint32_t*)result)) |
|
3679 DEFINE_GETSCALARARRAYELEMENTS(T_LONG, jlong, Long, long |
|
3680 , HOTSPOT_JNI_GETLONGARRAYELEMENTS_ENTRY(env, array, (uintptr_t *) isCopy), |
|
3681 HOTSPOT_JNI_GETLONGARRAYELEMENTS_RETURN(((uintptr_t*)result))) |
|
3682 // Float and double probes don't return value because dtrace doesn't currently support it |
|
3683 DEFINE_GETSCALARARRAYELEMENTS(T_FLOAT, jfloat, Float, float |
|
3684 , HOTSPOT_JNI_GETFLOATARRAYELEMENTS_ENTRY(env, array, (uintptr_t *) isCopy), |
|
3685 HOTSPOT_JNI_GETFLOATARRAYELEMENTS_RETURN(result)) |
|
3686 DEFINE_GETSCALARARRAYELEMENTS(T_DOUBLE, jdouble, Double, double |
|
3687 , HOTSPOT_JNI_GETDOUBLEARRAYELEMENTS_ENTRY(env, array, (uintptr_t *) isCopy), |
|
3688 HOTSPOT_JNI_GETDOUBLEARRAYELEMENTS_RETURN(result)) |
|
3689 #endif /* USDT2 */ |
|
3690 |
|
3691 #ifndef USDT2 |
2298 #define DEFINE_RELEASESCALARARRAYELEMENTS(ElementTag,ElementType,Result,Tag) \ |
3692 #define DEFINE_RELEASESCALARARRAYELEMENTS(ElementTag,ElementType,Result,Tag) \ |
2299 \ |
3693 \ |
2300 JNI_QUICK_ENTRY(void, \ |
3694 JNI_QUICK_ENTRY(void, \ |
2301 jni_Release##Result##ArrayElements(JNIEnv *env, ElementType##Array array, \ |
3695 jni_Release##Result##ArrayElements(JNIEnv *env, ElementType##Array array, \ |
2302 ElementType *buf, jint mode)) \ |
3696 ElementType *buf, jint mode)) \ |
2322 DEFINE_RELEASESCALARARRAYELEMENTS(T_INT, jint, Int, int) |
3716 DEFINE_RELEASESCALARARRAYELEMENTS(T_INT, jint, Int, int) |
2323 DEFINE_RELEASESCALARARRAYELEMENTS(T_LONG, jlong, Long, long) |
3717 DEFINE_RELEASESCALARARRAYELEMENTS(T_LONG, jlong, Long, long) |
2324 DEFINE_RELEASESCALARARRAYELEMENTS(T_FLOAT, jfloat, Float, float) |
3718 DEFINE_RELEASESCALARARRAYELEMENTS(T_FLOAT, jfloat, Float, float) |
2325 DEFINE_RELEASESCALARARRAYELEMENTS(T_DOUBLE, jdouble, Double, double) |
3719 DEFINE_RELEASESCALARARRAYELEMENTS(T_DOUBLE, jdouble, Double, double) |
2326 |
3720 |
|
3721 #else /* USDT2 */ |
|
3722 |
|
3723 #define DEFINE_RELEASESCALARARRAYELEMENTS(ElementTag,ElementType,Result,Tag \ |
|
3724 , EntryProbe, ReturnProbe);\ |
|
3725 \ |
|
3726 JNI_QUICK_ENTRY(void, \ |
|
3727 jni_Release##Result##ArrayElements(JNIEnv *env, ElementType##Array array, \ |
|
3728 ElementType *buf, jint mode)) \ |
|
3729 JNIWrapper("Release" XSTR(Result) "ArrayElements"); \ |
|
3730 EntryProbe; \ |
|
3731 typeArrayOop a = typeArrayOop(JNIHandles::resolve_non_null(array)); \ |
|
3732 int len = a->length(); \ |
|
3733 if (len != 0) { /* Empty array: nothing to free or copy. */ \ |
|
3734 if ((mode == 0) || (mode == JNI_COMMIT)) { \ |
|
3735 memcpy(a->Tag##_at_addr(0), buf, sizeof(ElementType)*len); \ |
|
3736 } \ |
|
3737 if ((mode == 0) || (mode == JNI_ABORT)) { \ |
|
3738 FreeHeap(buf); \ |
|
3739 } \ |
|
3740 } \ |
|
3741 ReturnProbe; \ |
|
3742 JNI_END |
|
3743 |
|
3744 DEFINE_RELEASESCALARARRAYELEMENTS(T_BOOLEAN, jboolean, Boolean, bool |
|
3745 , HOTSPOT_JNI_RELEASEBOOLEANARRAYELEMENTS_ENTRY(env, array, (uintptr_t *) buf, mode), |
|
3746 HOTSPOT_JNI_RELEASEBOOLEANARRAYELEMENTS_RETURN()) |
|
3747 DEFINE_RELEASESCALARARRAYELEMENTS(T_BYTE, jbyte, Byte, byte |
|
3748 , HOTSPOT_JNI_RELEASEBYTEARRAYELEMENTS_ENTRY(env, array, (char *) buf, mode), |
|
3749 HOTSPOT_JNI_RELEASEBYTEARRAYELEMENTS_RETURN()) |
|
3750 DEFINE_RELEASESCALARARRAYELEMENTS(T_SHORT, jshort, Short, short |
|
3751 , HOTSPOT_JNI_RELEASESHORTARRAYELEMENTS_ENTRY(env, array, (uint16_t *) buf, mode), |
|
3752 HOTSPOT_JNI_RELEASESHORTARRAYELEMENTS_RETURN()) |
|
3753 DEFINE_RELEASESCALARARRAYELEMENTS(T_CHAR, jchar, Char, char |
|
3754 , HOTSPOT_JNI_RELEASECHARARRAYELEMENTS_ENTRY(env, array, (uint16_t *) buf, mode), |
|
3755 HOTSPOT_JNI_RELEASECHARARRAYELEMENTS_RETURN()) |
|
3756 DEFINE_RELEASESCALARARRAYELEMENTS(T_INT, jint, Int, int |
|
3757 , HOTSPOT_JNI_RELEASEINTARRAYELEMENTS_ENTRY(env, array, (uint32_t *) buf, mode), |
|
3758 HOTSPOT_JNI_RELEASEINTARRAYELEMENTS_RETURN()) |
|
3759 DEFINE_RELEASESCALARARRAYELEMENTS(T_LONG, jlong, Long, long |
|
3760 , HOTSPOT_JNI_RELEASELONGARRAYELEMENTS_ENTRY(env, array, (uintptr_t *) buf, mode), |
|
3761 HOTSPOT_JNI_RELEASELONGARRAYELEMENTS_RETURN()) |
|
3762 DEFINE_RELEASESCALARARRAYELEMENTS(T_FLOAT, jfloat, Float, float |
|
3763 , HOTSPOT_JNI_RELEASEFLOATARRAYELEMENTS_ENTRY(env, array, (float *) buf, mode), |
|
3764 HOTSPOT_JNI_RELEASEFLOATARRAYELEMENTS_RETURN()) |
|
3765 DEFINE_RELEASESCALARARRAYELEMENTS(T_DOUBLE, jdouble, Double, double |
|
3766 , HOTSPOT_JNI_RELEASEDOUBLEARRAYELEMENTS_ENTRY(env, array, (double *) buf, mode), |
|
3767 HOTSPOT_JNI_RELEASEDOUBLEARRAYELEMENTS_RETURN()) |
|
3768 #endif /* USDT2 */ |
|
3769 |
|
3770 #ifndef USDT2 |
2327 #define DEFINE_GETSCALARARRAYREGION(ElementTag,ElementType,Result, Tag) \ |
3771 #define DEFINE_GETSCALARARRAYREGION(ElementTag,ElementType,Result, Tag) \ |
2328 DT_VOID_RETURN_MARK_DECL(Get##Result##ArrayRegion);\ |
3772 DT_VOID_RETURN_MARK_DECL(Get##Result##ArrayRegion);\ |
2329 \ |
3773 \ |
2330 JNI_ENTRY(void, \ |
3774 JNI_ENTRY(void, \ |
2331 jni_Get##Result##ArrayRegion(JNIEnv *env, ElementType##Array array, jsize start, \ |
3775 jni_Get##Result##ArrayRegion(JNIEnv *env, ElementType##Array array, jsize start, \ |
2353 DEFINE_GETSCALARARRAYREGION(T_INT, jint, Int, int) |
3797 DEFINE_GETSCALARARRAYREGION(T_INT, jint, Int, int) |
2354 DEFINE_GETSCALARARRAYREGION(T_LONG, jlong, Long, long) |
3798 DEFINE_GETSCALARARRAYREGION(T_LONG, jlong, Long, long) |
2355 DEFINE_GETSCALARARRAYREGION(T_FLOAT, jfloat, Float, float) |
3799 DEFINE_GETSCALARARRAYREGION(T_FLOAT, jfloat, Float, float) |
2356 DEFINE_GETSCALARARRAYREGION(T_DOUBLE, jdouble, Double, double) |
3800 DEFINE_GETSCALARARRAYREGION(T_DOUBLE, jdouble, Double, double) |
2357 |
3801 |
|
3802 #else /* USDT2 */ |
|
3803 |
|
3804 #define DEFINE_GETSCALARARRAYREGION(ElementTag,ElementType,Result, Tag \ |
|
3805 , EntryProbe, ReturnProbe); \ |
|
3806 DT_VOID_RETURN_MARK_DECL(Get##Result##ArrayRegion \ |
|
3807 , ReturnProbe); \ |
|
3808 \ |
|
3809 JNI_ENTRY(void, \ |
|
3810 jni_Get##Result##ArrayRegion(JNIEnv *env, ElementType##Array array, jsize start, \ |
|
3811 jsize len, ElementType *buf)) \ |
|
3812 JNIWrapper("Get" XSTR(Result) "ArrayRegion"); \ |
|
3813 EntryProbe; \ |
|
3814 DT_VOID_RETURN_MARK(Get##Result##ArrayRegion); \ |
|
3815 typeArrayOop src = typeArrayOop(JNIHandles::resolve_non_null(array)); \ |
|
3816 if (start < 0 || len < 0 || ((unsigned int)start + (unsigned int)len > (unsigned int)src->length())) { \ |
|
3817 THROW(vmSymbols::java_lang_ArrayIndexOutOfBoundsException()); \ |
|
3818 } else { \ |
|
3819 if (len > 0) { \ |
|
3820 int sc = typeArrayKlass::cast(src->klass())->log2_element_size(); \ |
|
3821 memcpy((u_char*) buf, \ |
|
3822 (u_char*) src->Tag##_at_addr(start), \ |
|
3823 len << sc); \ |
|
3824 } \ |
|
3825 } \ |
|
3826 JNI_END |
|
3827 |
|
3828 DEFINE_GETSCALARARRAYREGION(T_BOOLEAN, jboolean,Boolean, bool |
|
3829 , HOTSPOT_JNI_GETBOOLEANARRAYREGION_ENTRY(env, array, start, len, (uintptr_t *) buf), |
|
3830 HOTSPOT_JNI_GETBOOLEANARRAYREGION_RETURN()); |
|
3831 DEFINE_GETSCALARARRAYREGION(T_BYTE, jbyte, Byte, byte |
|
3832 , HOTSPOT_JNI_GETBYTEARRAYREGION_ENTRY(env, array, start, len, (char *) buf), |
|
3833 HOTSPOT_JNI_GETBYTEARRAYREGION_RETURN()); |
|
3834 DEFINE_GETSCALARARRAYREGION(T_SHORT, jshort, Short, short |
|
3835 , HOTSPOT_JNI_GETSHORTARRAYREGION_ENTRY(env, array, start, len, (uint16_t *) buf), |
|
3836 HOTSPOT_JNI_GETSHORTARRAYREGION_RETURN()); |
|
3837 DEFINE_GETSCALARARRAYREGION(T_CHAR, jchar, Char, char |
|
3838 , HOTSPOT_JNI_GETCHARARRAYREGION_ENTRY(env, array, start, len, (uint16_t*) buf), |
|
3839 HOTSPOT_JNI_GETCHARARRAYREGION_RETURN()); |
|
3840 DEFINE_GETSCALARARRAYREGION(T_INT, jint, Int, int |
|
3841 , HOTSPOT_JNI_GETINTARRAYREGION_ENTRY(env, array, start, len, (uint32_t*) buf), |
|
3842 HOTSPOT_JNI_GETINTARRAYREGION_RETURN()); |
|
3843 DEFINE_GETSCALARARRAYREGION(T_LONG, jlong, Long, long |
|
3844 , HOTSPOT_JNI_GETLONGARRAYREGION_ENTRY(env, array, start, len, (uintptr_t *) buf), |
|
3845 HOTSPOT_JNI_GETLONGARRAYREGION_RETURN()); |
|
3846 DEFINE_GETSCALARARRAYREGION(T_FLOAT, jfloat, Float, float |
|
3847 , HOTSPOT_JNI_GETFLOATARRAYREGION_ENTRY(env, array, start, len, (float *) buf), |
|
3848 HOTSPOT_JNI_GETFLOATARRAYREGION_RETURN()); |
|
3849 DEFINE_GETSCALARARRAYREGION(T_DOUBLE, jdouble, Double, double |
|
3850 , HOTSPOT_JNI_GETDOUBLEARRAYREGION_ENTRY(env, array, start, len, (double *) buf), |
|
3851 HOTSPOT_JNI_GETDOUBLEARRAYREGION_RETURN()); |
|
3852 #endif /* USDT2 */ |
|
3853 |
|
3854 #ifndef USDT2 |
2358 #define DEFINE_SETSCALARARRAYREGION(ElementTag,ElementType,Result, Tag) \ |
3855 #define DEFINE_SETSCALARARRAYREGION(ElementTag,ElementType,Result, Tag) \ |
2359 DT_VOID_RETURN_MARK_DECL(Set##Result##ArrayRegion);\ |
3856 DT_VOID_RETURN_MARK_DECL(Set##Result##ArrayRegion);\ |
2360 \ |
3857 \ |
2361 JNI_ENTRY(void, \ |
3858 JNI_ENTRY(void, \ |
2362 jni_Set##Result##ArrayRegion(JNIEnv *env, ElementType##Array array, jsize start, \ |
3859 jni_Set##Result##ArrayRegion(JNIEnv *env, ElementType##Array array, jsize start, \ |
2383 DEFINE_SETSCALARARRAYREGION(T_CHAR, jchar, Char, char) |
3880 DEFINE_SETSCALARARRAYREGION(T_CHAR, jchar, Char, char) |
2384 DEFINE_SETSCALARARRAYREGION(T_INT, jint, Int, int) |
3881 DEFINE_SETSCALARARRAYREGION(T_INT, jint, Int, int) |
2385 DEFINE_SETSCALARARRAYREGION(T_LONG, jlong, Long, long) |
3882 DEFINE_SETSCALARARRAYREGION(T_LONG, jlong, Long, long) |
2386 DEFINE_SETSCALARARRAYREGION(T_FLOAT, jfloat, Float, float) |
3883 DEFINE_SETSCALARARRAYREGION(T_FLOAT, jfloat, Float, float) |
2387 DEFINE_SETSCALARARRAYREGION(T_DOUBLE, jdouble, Double, double) |
3884 DEFINE_SETSCALARARRAYREGION(T_DOUBLE, jdouble, Double, double) |
|
3885 |
|
3886 #else /* USDT2 */ |
|
3887 |
|
3888 #define DEFINE_SETSCALARARRAYREGION(ElementTag,ElementType,Result, Tag \ |
|
3889 , EntryProbe, ReturnProbe); \ |
|
3890 DT_VOID_RETURN_MARK_DECL(Set##Result##ArrayRegion \ |
|
3891 ,ReturnProbe); \ |
|
3892 \ |
|
3893 JNI_ENTRY(void, \ |
|
3894 jni_Set##Result##ArrayRegion(JNIEnv *env, ElementType##Array array, jsize start, \ |
|
3895 jsize len, const ElementType *buf)) \ |
|
3896 JNIWrapper("Set" XSTR(Result) "ArrayRegion"); \ |
|
3897 EntryProbe; \ |
|
3898 DT_VOID_RETURN_MARK(Set##Result##ArrayRegion); \ |
|
3899 typeArrayOop dst = typeArrayOop(JNIHandles::resolve_non_null(array)); \ |
|
3900 if (start < 0 || len < 0 || ((unsigned int)start + (unsigned int)len > (unsigned int)dst->length())) { \ |
|
3901 THROW(vmSymbols::java_lang_ArrayIndexOutOfBoundsException()); \ |
|
3902 } else { \ |
|
3903 if (len > 0) { \ |
|
3904 int sc = typeArrayKlass::cast(dst->klass())->log2_element_size(); \ |
|
3905 memcpy((u_char*) dst->Tag##_at_addr(start), \ |
|
3906 (u_char*) buf, \ |
|
3907 len << sc); \ |
|
3908 } \ |
|
3909 } \ |
|
3910 JNI_END |
|
3911 |
|
3912 DEFINE_SETSCALARARRAYREGION(T_BOOLEAN, jboolean, Boolean, bool |
|
3913 , HOTSPOT_JNI_SETBOOLEANARRAYREGION_ENTRY(env, array, start, len, (uintptr_t *)buf), |
|
3914 HOTSPOT_JNI_SETBOOLEANARRAYREGION_RETURN()) |
|
3915 DEFINE_SETSCALARARRAYREGION(T_BYTE, jbyte, Byte, byte |
|
3916 , HOTSPOT_JNI_SETBYTEARRAYREGION_ENTRY(env, array, start, len, (char *) buf), |
|
3917 HOTSPOT_JNI_SETBYTEARRAYREGION_RETURN()) |
|
3918 DEFINE_SETSCALARARRAYREGION(T_SHORT, jshort, Short, short |
|
3919 , HOTSPOT_JNI_SETSHORTARRAYREGION_ENTRY(env, array, start, len, (uint16_t *) buf), |
|
3920 HOTSPOT_JNI_SETSHORTARRAYREGION_RETURN()) |
|
3921 DEFINE_SETSCALARARRAYREGION(T_CHAR, jchar, Char, char |
|
3922 , HOTSPOT_JNI_SETCHARARRAYREGION_ENTRY(env, array, start, len, (uint16_t *) buf), |
|
3923 HOTSPOT_JNI_SETCHARARRAYREGION_RETURN()) |
|
3924 DEFINE_SETSCALARARRAYREGION(T_INT, jint, Int, int |
|
3925 , HOTSPOT_JNI_SETINTARRAYREGION_ENTRY(env, array, start, len, (uint32_t *) buf), |
|
3926 HOTSPOT_JNI_SETINTARRAYREGION_RETURN()) |
|
3927 DEFINE_SETSCALARARRAYREGION(T_LONG, jlong, Long, long |
|
3928 , HOTSPOT_JNI_SETLONGARRAYREGION_ENTRY(env, array, start, len, (uintptr_t *) buf), |
|
3929 HOTSPOT_JNI_SETLONGARRAYREGION_RETURN()) |
|
3930 DEFINE_SETSCALARARRAYREGION(T_FLOAT, jfloat, Float, float |
|
3931 , HOTSPOT_JNI_SETFLOATARRAYREGION_ENTRY(env, array, start, len, (float *) buf), |
|
3932 HOTSPOT_JNI_SETFLOATARRAYREGION_RETURN()) |
|
3933 DEFINE_SETSCALARARRAYREGION(T_DOUBLE, jdouble, Double, double |
|
3934 , HOTSPOT_JNI_SETDOUBLEARRAYREGION_ENTRY(env, array, start, len, (double *) buf), |
|
3935 HOTSPOT_JNI_SETDOUBLEARRAYREGION_RETURN()) |
|
3936 #endif /* USDT2 */ |
2388 |
3937 |
2389 |
3938 |
2390 // |
3939 // |
2391 // Interception of natives |
3940 // Interception of natives |
2392 // |
3941 // |
2633 type = T_OBJECT; |
4247 type = T_OBJECT; |
2634 } else { |
4248 } else { |
2635 type = typeArrayKlass::cast(a->klass())->element_type(); |
4249 type = typeArrayKlass::cast(a->klass())->element_type(); |
2636 } |
4250 } |
2637 void* ret = arrayOop(a)->base(type); |
4251 void* ret = arrayOop(a)->base(type); |
|
4252 #ifndef USDT2 |
2638 DTRACE_PROBE1(hotspot_jni, GetPrimitiveArrayCritical__return, ret); |
4253 DTRACE_PROBE1(hotspot_jni, GetPrimitiveArrayCritical__return, ret); |
|
4254 #else /* USDT2 */ |
|
4255 HOTSPOT_JNI_GETPRIMITIVEARRAYCRITICAL_RETURN( |
|
4256 ret); |
|
4257 #endif /* USDT2 */ |
2639 return ret; |
4258 return ret; |
2640 JNI_END |
4259 JNI_END |
2641 |
4260 |
2642 |
4261 |
2643 JNI_ENTRY(void, jni_ReleasePrimitiveArrayCritical(JNIEnv *env, jarray array, void *carray, jint mode)) |
4262 JNI_ENTRY(void, jni_ReleasePrimitiveArrayCritical(JNIEnv *env, jarray array, void *carray, jint mode)) |
2644 JNIWrapper("ReleasePrimitiveArrayCritical"); |
4263 JNIWrapper("ReleasePrimitiveArrayCritical"); |
|
4264 #ifndef USDT2 |
2645 DTRACE_PROBE4(hotspot_jni, ReleasePrimitiveArrayCritical__entry, env, array, carray, mode); |
4265 DTRACE_PROBE4(hotspot_jni, ReleasePrimitiveArrayCritical__entry, env, array, carray, mode); |
|
4266 #else /* USDT2 */ |
|
4267 HOTSPOT_JNI_RELEASEPRIMITIVEARRAYCRITICAL_ENTRY( |
|
4268 env, array, carray, mode); |
|
4269 #endif /* USDT2 */ |
2646 // The array, carray and mode arguments are ignored |
4270 // The array, carray and mode arguments are ignored |
2647 GC_locker::unlock_critical(thread); |
4271 GC_locker::unlock_critical(thread); |
|
4272 #ifndef USDT2 |
2648 DTRACE_PROBE(hotspot_jni, ReleasePrimitiveArrayCritical__return); |
4273 DTRACE_PROBE(hotspot_jni, ReleasePrimitiveArrayCritical__return); |
|
4274 #else /* USDT2 */ |
|
4275 HOTSPOT_JNI_RELEASEPRIMITIVEARRAYCRITICAL_RETURN( |
|
4276 ); |
|
4277 #endif /* USDT2 */ |
2649 JNI_END |
4278 JNI_END |
2650 |
4279 |
2651 |
4280 |
2652 JNI_ENTRY(const jchar*, jni_GetStringCritical(JNIEnv *env, jstring string, jboolean *isCopy)) |
4281 JNI_ENTRY(const jchar*, jni_GetStringCritical(JNIEnv *env, jstring string, jboolean *isCopy)) |
2653 JNIWrapper("GetStringCritical"); |
4282 JNIWrapper("GetStringCritical"); |
|
4283 #ifndef USDT2 |
2654 DTRACE_PROBE3(hotspot_jni, GetStringCritical__entry, env, string, isCopy); |
4284 DTRACE_PROBE3(hotspot_jni, GetStringCritical__entry, env, string, isCopy); |
|
4285 #else /* USDT2 */ |
|
4286 HOTSPOT_JNI_GETSTRINGCRITICAL_ENTRY( |
|
4287 env, string, (uintptr_t *) isCopy); |
|
4288 #endif /* USDT2 */ |
2655 GC_locker::lock_critical(thread); |
4289 GC_locker::lock_critical(thread); |
2656 if (isCopy != NULL) { |
4290 if (isCopy != NULL) { |
2657 *isCopy = JNI_FALSE; |
4291 *isCopy = JNI_FALSE; |
2658 } |
4292 } |
2659 oop s = JNIHandles::resolve_non_null(string); |
4293 oop s = JNIHandles::resolve_non_null(string); |
2664 if (s_len > 0) { |
4298 if (s_len > 0) { |
2665 ret = s_value->char_at_addr(s_offset); |
4299 ret = s_value->char_at_addr(s_offset); |
2666 } else { |
4300 } else { |
2667 ret = (jchar*) s_value->base(T_CHAR); |
4301 ret = (jchar*) s_value->base(T_CHAR); |
2668 } |
4302 } |
|
4303 #ifndef USDT2 |
2669 DTRACE_PROBE1(hotspot_jni, GetStringCritical__return, ret); |
4304 DTRACE_PROBE1(hotspot_jni, GetStringCritical__return, ret); |
|
4305 #else /* USDT2 */ |
|
4306 HOTSPOT_JNI_GETSTRINGCRITICAL_RETURN( |
|
4307 (uint16_t *) ret); |
|
4308 #endif /* USDT2 */ |
2670 return ret; |
4309 return ret; |
2671 JNI_END |
4310 JNI_END |
2672 |
4311 |
2673 |
4312 |
2674 JNI_ENTRY(void, jni_ReleaseStringCritical(JNIEnv *env, jstring str, const jchar *chars)) |
4313 JNI_ENTRY(void, jni_ReleaseStringCritical(JNIEnv *env, jstring str, const jchar *chars)) |
2675 JNIWrapper("ReleaseStringCritical"); |
4314 JNIWrapper("ReleaseStringCritical"); |
|
4315 #ifndef USDT2 |
2676 DTRACE_PROBE3(hotspot_jni, ReleaseStringCritical__entry, env, str, chars); |
4316 DTRACE_PROBE3(hotspot_jni, ReleaseStringCritical__entry, env, str, chars); |
|
4317 #else /* USDT2 */ |
|
4318 HOTSPOT_JNI_RELEASESTRINGCRITICAL_ENTRY( |
|
4319 env, str, (uint16_t *) chars); |
|
4320 #endif /* USDT2 */ |
2677 // The str and chars arguments are ignored |
4321 // The str and chars arguments are ignored |
2678 GC_locker::unlock_critical(thread); |
4322 GC_locker::unlock_critical(thread); |
|
4323 #ifndef USDT2 |
2679 DTRACE_PROBE(hotspot_jni, ReleaseStringCritical__return); |
4324 DTRACE_PROBE(hotspot_jni, ReleaseStringCritical__return); |
|
4325 #else /* USDT2 */ |
|
4326 HOTSPOT_JNI_RELEASESTRINGCRITICAL_RETURN( |
|
4327 ); |
|
4328 #endif /* USDT2 */ |
2680 JNI_END |
4329 JNI_END |
2681 |
4330 |
2682 |
4331 |
2683 JNI_ENTRY(jweak, jni_NewWeakGlobalRef(JNIEnv *env, jobject ref)) |
4332 JNI_ENTRY(jweak, jni_NewWeakGlobalRef(JNIEnv *env, jobject ref)) |
2684 JNIWrapper("jni_NewWeakGlobalRef"); |
4333 JNIWrapper("jni_NewWeakGlobalRef"); |
|
4334 #ifndef USDT2 |
2685 DTRACE_PROBE2(hotspot_jni, NewWeakGlobalRef__entry, env, ref); |
4335 DTRACE_PROBE2(hotspot_jni, NewWeakGlobalRef__entry, env, ref); |
|
4336 #else /* USDT2 */ |
|
4337 HOTSPOT_JNI_NEWWEAKGLOBALREF_ENTRY( |
|
4338 env, ref); |
|
4339 #endif /* USDT2 */ |
2686 Handle ref_handle(thread, JNIHandles::resolve(ref)); |
4340 Handle ref_handle(thread, JNIHandles::resolve(ref)); |
2687 jweak ret = JNIHandles::make_weak_global(ref_handle); |
4341 jweak ret = JNIHandles::make_weak_global(ref_handle); |
|
4342 #ifndef USDT2 |
2688 DTRACE_PROBE1(hotspot_jni, NewWeakGlobalRef__return, ret); |
4343 DTRACE_PROBE1(hotspot_jni, NewWeakGlobalRef__return, ret); |
|
4344 #else /* USDT2 */ |
|
4345 HOTSPOT_JNI_NEWWEAKGLOBALREF_RETURN( |
|
4346 ret); |
|
4347 #endif /* USDT2 */ |
2689 return ret; |
4348 return ret; |
2690 JNI_END |
4349 JNI_END |
2691 |
4350 |
2692 // Must be JNI_ENTRY (with HandleMark) |
4351 // Must be JNI_ENTRY (with HandleMark) |
2693 JNI_ENTRY(void, jni_DeleteWeakGlobalRef(JNIEnv *env, jweak ref)) |
4352 JNI_ENTRY(void, jni_DeleteWeakGlobalRef(JNIEnv *env, jweak ref)) |
2694 JNIWrapper("jni_DeleteWeakGlobalRef"); |
4353 JNIWrapper("jni_DeleteWeakGlobalRef"); |
|
4354 #ifndef USDT2 |
2695 DTRACE_PROBE2(hotspot_jni, DeleteWeakGlobalRef__entry, env, ref); |
4355 DTRACE_PROBE2(hotspot_jni, DeleteWeakGlobalRef__entry, env, ref); |
|
4356 #else /* USDT2 */ |
|
4357 HOTSPOT_JNI_DELETEWEAKGLOBALREF_ENTRY( |
|
4358 env, ref); |
|
4359 #endif /* USDT2 */ |
2696 JNIHandles::destroy_weak_global(ref); |
4360 JNIHandles::destroy_weak_global(ref); |
|
4361 #ifndef USDT2 |
2697 DTRACE_PROBE(hotspot_jni, DeleteWeakGlobalRef__return); |
4362 DTRACE_PROBE(hotspot_jni, DeleteWeakGlobalRef__return); |
|
4363 #else /* USDT2 */ |
|
4364 HOTSPOT_JNI_DELETEWEAKGLOBALREF_RETURN( |
|
4365 ); |
|
4366 #endif /* USDT2 */ |
2698 JNI_END |
4367 JNI_END |
2699 |
4368 |
2700 |
4369 |
2701 JNI_QUICK_ENTRY(jboolean, jni_ExceptionCheck(JNIEnv *env)) |
4370 JNI_QUICK_ENTRY(jboolean, jni_ExceptionCheck(JNIEnv *env)) |
2702 JNIWrapper("jni_ExceptionCheck"); |
4371 JNIWrapper("jni_ExceptionCheck"); |
|
4372 #ifndef USDT2 |
2703 DTRACE_PROBE1(hotspot_jni, ExceptionCheck__entry, env); |
4373 DTRACE_PROBE1(hotspot_jni, ExceptionCheck__entry, env); |
|
4374 #else /* USDT2 */ |
|
4375 HOTSPOT_JNI_EXCEPTIONCHECK_ENTRY( |
|
4376 env); |
|
4377 #endif /* USDT2 */ |
2704 jni_check_async_exceptions(thread); |
4378 jni_check_async_exceptions(thread); |
2705 jboolean ret = (thread->has_pending_exception()) ? JNI_TRUE : JNI_FALSE; |
4379 jboolean ret = (thread->has_pending_exception()) ? JNI_TRUE : JNI_FALSE; |
|
4380 #ifndef USDT2 |
2706 DTRACE_PROBE1(hotspot_jni, ExceptionCheck__return, ret); |
4381 DTRACE_PROBE1(hotspot_jni, ExceptionCheck__return, ret); |
|
4382 #else /* USDT2 */ |
|
4383 HOTSPOT_JNI_EXCEPTIONCHECK_RETURN( |
|
4384 ret); |
|
4385 #endif /* USDT2 */ |
2707 return ret; |
4386 return ret; |
2708 JNI_END |
4387 JNI_END |
2709 |
4388 |
2710 |
4389 |
2711 // Initialization state for three routines below relating to |
4390 // Initialization state for three routines below relating to |
2793 { |
4472 { |
2794 // thread_from_jni_environment() will block if VM is gone. |
4473 // thread_from_jni_environment() will block if VM is gone. |
2795 JavaThread* thread = JavaThread::thread_from_jni_environment(env); |
4474 JavaThread* thread = JavaThread::thread_from_jni_environment(env); |
2796 |
4475 |
2797 JNIWrapper("jni_NewDirectByteBuffer"); |
4476 JNIWrapper("jni_NewDirectByteBuffer"); |
|
4477 #ifndef USDT2 |
2798 DTRACE_PROBE3(hotspot_jni, NewDirectByteBuffer__entry, env, address, capacity); |
4478 DTRACE_PROBE3(hotspot_jni, NewDirectByteBuffer__entry, env, address, capacity); |
|
4479 #else /* USDT2 */ |
|
4480 HOTSPOT_JNI_NEWDIRECTBYTEBUFFER_ENTRY( |
|
4481 env, address, capacity); |
|
4482 #endif /* USDT2 */ |
2799 |
4483 |
2800 if (!directBufferSupportInitializeEnded) { |
4484 if (!directBufferSupportInitializeEnded) { |
2801 if (!initializeDirectBufferSupport(env, thread)) { |
4485 if (!initializeDirectBufferSupport(env, thread)) { |
|
4486 #ifndef USDT2 |
2802 DTRACE_PROBE1(hotspot_jni, NewDirectByteBuffer__return, NULL); |
4487 DTRACE_PROBE1(hotspot_jni, NewDirectByteBuffer__return, NULL); |
|
4488 #else /* USDT2 */ |
|
4489 HOTSPOT_JNI_NEWDIRECTBYTEBUFFER_RETURN( |
|
4490 NULL); |
|
4491 #endif /* USDT2 */ |
2803 return NULL; |
4492 return NULL; |
2804 } |
4493 } |
2805 } |
4494 } |
2806 |
4495 |
2807 // Being paranoid about accidental sign extension on address |
4496 // Being paranoid about accidental sign extension on address |
2808 jlong addr = (jlong) ((uintptr_t) address); |
4497 jlong addr = (jlong) ((uintptr_t) address); |
2809 // NOTE that package-private DirectByteBuffer constructor currently |
4498 // NOTE that package-private DirectByteBuffer constructor currently |
2810 // takes int capacity |
4499 // takes int capacity |
2811 jint cap = (jint) capacity; |
4500 jint cap = (jint) capacity; |
2812 jobject ret = env->NewObject(directByteBufferClass, directByteBufferConstructor, addr, cap); |
4501 jobject ret = env->NewObject(directByteBufferClass, directByteBufferConstructor, addr, cap); |
|
4502 #ifndef USDT2 |
2813 DTRACE_PROBE1(hotspot_jni, NewDirectByteBuffer__return, ret); |
4503 DTRACE_PROBE1(hotspot_jni, NewDirectByteBuffer__return, ret); |
|
4504 #else /* USDT2 */ |
|
4505 HOTSPOT_JNI_NEWDIRECTBYTEBUFFER_RETURN( |
|
4506 ret); |
|
4507 #endif /* USDT2 */ |
2814 return ret; |
4508 return ret; |
2815 } |
4509 } |
2816 |
4510 |
|
4511 #ifndef USDT2 |
2817 DT_RETURN_MARK_DECL(GetDirectBufferAddress, void*); |
4512 DT_RETURN_MARK_DECL(GetDirectBufferAddress, void*); |
|
4513 #else /* USDT2 */ |
|
4514 DT_RETURN_MARK_DECL(GetDirectBufferAddress, void* |
|
4515 , HOTSPOT_JNI_GETDIRECTBUFFERADDRESS_RETURN((void*) _ret_ref)); |
|
4516 #endif /* USDT2 */ |
2818 |
4517 |
2819 extern "C" void* JNICALL jni_GetDirectBufferAddress(JNIEnv *env, jobject buf) |
4518 extern "C" void* JNICALL jni_GetDirectBufferAddress(JNIEnv *env, jobject buf) |
2820 { |
4519 { |
2821 // thread_from_jni_environment() will block if VM is gone. |
4520 // thread_from_jni_environment() will block if VM is gone. |
2822 JavaThread* thread = JavaThread::thread_from_jni_environment(env); |
4521 JavaThread* thread = JavaThread::thread_from_jni_environment(env); |
2823 |
4522 |
2824 JNIWrapper("jni_GetDirectBufferAddress"); |
4523 JNIWrapper("jni_GetDirectBufferAddress"); |
|
4524 #ifndef USDT2 |
2825 DTRACE_PROBE2(hotspot_jni, GetDirectBufferAddress__entry, env, buf); |
4525 DTRACE_PROBE2(hotspot_jni, GetDirectBufferAddress__entry, env, buf); |
|
4526 #else /* USDT2 */ |
|
4527 HOTSPOT_JNI_GETDIRECTBUFFERADDRESS_ENTRY( |
|
4528 env, buf); |
|
4529 #endif /* USDT2 */ |
2826 void* ret = NULL; |
4530 void* ret = NULL; |
2827 DT_RETURN_MARK(GetDirectBufferAddress, void*, (const void*&)ret); |
4531 DT_RETURN_MARK(GetDirectBufferAddress, void*, (const void*&)ret); |
2828 |
4532 |
2829 if (!directBufferSupportInitializeEnded) { |
4533 if (!directBufferSupportInitializeEnded) { |
2830 if (!initializeDirectBufferSupport(env, thread)) { |
4534 if (!initializeDirectBufferSupport(env, thread)) { |
3396 NOT_PRODUCT(test_error_handler(ErrorHandlerTest)); |
5150 NOT_PRODUCT(test_error_handler(ErrorHandlerTest)); |
3397 NOT_PRODUCT(execute_internal_vm_tests()); |
5151 NOT_PRODUCT(execute_internal_vm_tests()); |
3398 return result; |
5152 return result; |
3399 } |
5153 } |
3400 |
5154 |
|
5155 #ifndef USDT2 |
3401 HS_DTRACE_PROBE_DECL3(hotspot_jni, GetCreatedJavaVMs__entry, \ |
5156 HS_DTRACE_PROBE_DECL3(hotspot_jni, GetCreatedJavaVMs__entry, \ |
3402 JavaVM**, jsize, jsize*); |
5157 JavaVM**, jsize, jsize*); |
3403 HS_DTRACE_PROBE_DECL1(hotspot_jni, GetCreatedJavaVMs__return, jint); |
5158 HS_DTRACE_PROBE_DECL1(hotspot_jni, GetCreatedJavaVMs__return, jint); |
|
5159 #endif /* !USDT2 */ |
3404 |
5160 |
3405 _JNI_IMPORT_OR_EXPORT_ jint JNICALL JNI_GetCreatedJavaVMs(JavaVM **vm_buf, jsize bufLen, jsize *numVMs) { |
5161 _JNI_IMPORT_OR_EXPORT_ jint JNICALL JNI_GetCreatedJavaVMs(JavaVM **vm_buf, jsize bufLen, jsize *numVMs) { |
3406 // See bug 4367188, the wrapper can sometimes cause VM crashes |
5162 // See bug 4367188, the wrapper can sometimes cause VM crashes |
3407 // JNIWrapper("GetCreatedJavaVMs"); |
5163 // JNIWrapper("GetCreatedJavaVMs"); |
|
5164 #ifndef USDT2 |
3408 HS_DTRACE_PROBE3(hotspot_jni, GetCreatedJavaVMs__entry, \ |
5165 HS_DTRACE_PROBE3(hotspot_jni, GetCreatedJavaVMs__entry, \ |
3409 vm_buf, bufLen, numVMs); |
5166 vm_buf, bufLen, numVMs); |
|
5167 #else /* USDT2 */ |
|
5168 HOTSPOT_JNI_GETCREATEDJAVAVMS_ENTRY( |
|
5169 (void **) vm_buf, bufLen, (uintptr_t *) numVMs); |
|
5170 #endif /* USDT2 */ |
3410 if (vm_created) { |
5171 if (vm_created) { |
3411 if (numVMs != NULL) *numVMs = 1; |
5172 if (numVMs != NULL) *numVMs = 1; |
3412 if (bufLen > 0) *vm_buf = (JavaVM *)(&main_vm); |
5173 if (bufLen > 0) *vm_buf = (JavaVM *)(&main_vm); |
3413 } else { |
5174 } else { |
3414 if (numVMs != NULL) *numVMs = 0; |
5175 if (numVMs != NULL) *numVMs = 0; |
3415 } |
5176 } |
|
5177 #ifndef USDT2 |
3416 HS_DTRACE_PROBE1(hotspot_jni, GetCreatedJavaVMs__return, JNI_OK); |
5178 HS_DTRACE_PROBE1(hotspot_jni, GetCreatedJavaVMs__return, JNI_OK); |
|
5179 #else /* USDT2 */ |
|
5180 HOTSPOT_JNI_GETCREATEDJAVAVMS_RETURN( |
|
5181 JNI_OK); |
|
5182 #endif /* USDT2 */ |
3417 return JNI_OK; |
5183 return JNI_OK; |
3418 } |
5184 } |
3419 |
5185 |
3420 extern "C" { |
5186 extern "C" { |
3421 |
5187 |
|
5188 #ifndef USDT2 |
3422 DT_RETURN_MARK_DECL(DestroyJavaVM, jint); |
5189 DT_RETURN_MARK_DECL(DestroyJavaVM, jint); |
|
5190 #else /* USDT2 */ |
|
5191 DT_RETURN_MARK_DECL(DestroyJavaVM, jint |
|
5192 , HOTSPOT_JNI_DESTROYJAVAVM_RETURN(_ret_ref)); |
|
5193 #endif /* USDT2 */ |
3423 |
5194 |
3424 jint JNICALL jni_DestroyJavaVM(JavaVM *vm) { |
5195 jint JNICALL jni_DestroyJavaVM(JavaVM *vm) { |
|
5196 #ifndef USDT2 |
3425 DTRACE_PROBE1(hotspot_jni, DestroyJavaVM__entry, vm); |
5197 DTRACE_PROBE1(hotspot_jni, DestroyJavaVM__entry, vm); |
|
5198 #else /* USDT2 */ |
|
5199 HOTSPOT_JNI_DESTROYJAVAVM_ENTRY( |
|
5200 vm); |
|
5201 #endif /* USDT2 */ |
3426 jint res = JNI_ERR; |
5202 jint res = JNI_ERR; |
3427 DT_RETURN_MARK(DestroyJavaVM, jint, (const jint&)res); |
5203 DT_RETURN_MARK(DestroyJavaVM, jint, (const jint&)res); |
3428 |
5204 |
3429 if (!vm_created) { |
5205 if (!vm_created) { |
3430 res = JNI_ERR; |
5206 res = JNI_ERR; |
3566 return JNI_OK; |
5342 return JNI_OK; |
3567 } |
5343 } |
3568 |
5344 |
3569 |
5345 |
3570 jint JNICALL jni_AttachCurrentThread(JavaVM *vm, void **penv, void *_args) { |
5346 jint JNICALL jni_AttachCurrentThread(JavaVM *vm, void **penv, void *_args) { |
|
5347 #ifndef USDT2 |
3571 DTRACE_PROBE3(hotspot_jni, AttachCurrentThread__entry, vm, penv, _args); |
5348 DTRACE_PROBE3(hotspot_jni, AttachCurrentThread__entry, vm, penv, _args); |
|
5349 #else /* USDT2 */ |
|
5350 HOTSPOT_JNI_ATTACHCURRENTTHREAD_ENTRY( |
|
5351 vm, penv, _args); |
|
5352 #endif /* USDT2 */ |
3572 if (!vm_created) { |
5353 if (!vm_created) { |
|
5354 #ifndef USDT2 |
3573 DTRACE_PROBE1(hotspot_jni, AttachCurrentThread__return, JNI_ERR); |
5355 DTRACE_PROBE1(hotspot_jni, AttachCurrentThread__return, JNI_ERR); |
|
5356 #else /* USDT2 */ |
|
5357 HOTSPOT_JNI_ATTACHCURRENTTHREAD_RETURN( |
|
5358 (uint32_t) JNI_ERR); |
|
5359 #endif /* USDT2 */ |
3574 return JNI_ERR; |
5360 return JNI_ERR; |
3575 } |
5361 } |
3576 |
5362 |
3577 JNIWrapper("AttachCurrentThread"); |
5363 JNIWrapper("AttachCurrentThread"); |
3578 jint ret = attach_current_thread(vm, penv, _args, false); |
5364 jint ret = attach_current_thread(vm, penv, _args, false); |
|
5365 #ifndef USDT2 |
3579 DTRACE_PROBE1(hotspot_jni, AttachCurrentThread__return, ret); |
5366 DTRACE_PROBE1(hotspot_jni, AttachCurrentThread__return, ret); |
|
5367 #else /* USDT2 */ |
|
5368 HOTSPOT_JNI_ATTACHCURRENTTHREAD_RETURN( |
|
5369 ret); |
|
5370 #endif /* USDT2 */ |
3580 return ret; |
5371 return ret; |
3581 } |
5372 } |
3582 |
5373 |
3583 |
5374 |
3584 jint JNICALL jni_DetachCurrentThread(JavaVM *vm) { |
5375 jint JNICALL jni_DetachCurrentThread(JavaVM *vm) { |
|
5376 #ifndef USDT2 |
3585 DTRACE_PROBE1(hotspot_jni, DetachCurrentThread__entry, vm); |
5377 DTRACE_PROBE1(hotspot_jni, DetachCurrentThread__entry, vm); |
|
5378 #else /* USDT2 */ |
|
5379 HOTSPOT_JNI_DETACHCURRENTTHREAD_ENTRY( |
|
5380 vm); |
|
5381 #endif /* USDT2 */ |
3586 VM_Exit::block_if_vm_exited(); |
5382 VM_Exit::block_if_vm_exited(); |
3587 |
5383 |
3588 JNIWrapper("DetachCurrentThread"); |
5384 JNIWrapper("DetachCurrentThread"); |
3589 |
5385 |
3590 // If the thread has been deattacted the operations is a no-op |
5386 // If the thread has been deattacted the operations is a no-op |
3591 if (ThreadLocalStorage::thread() == NULL) { |
5387 if (ThreadLocalStorage::thread() == NULL) { |
|
5388 #ifndef USDT2 |
3592 DTRACE_PROBE1(hotspot_jni, DetachCurrentThread__return, JNI_OK); |
5389 DTRACE_PROBE1(hotspot_jni, DetachCurrentThread__return, JNI_OK); |
|
5390 #else /* USDT2 */ |
|
5391 HOTSPOT_JNI_DETACHCURRENTTHREAD_RETURN( |
|
5392 JNI_OK); |
|
5393 #endif /* USDT2 */ |
3593 return JNI_OK; |
5394 return JNI_OK; |
3594 } |
5395 } |
3595 |
5396 |
3596 JavaThread* thread = JavaThread::current(); |
5397 JavaThread* thread = JavaThread::current(); |
3597 if (thread->has_last_Java_frame()) { |
5398 if (thread->has_last_Java_frame()) { |
|
5399 #ifndef USDT2 |
3598 DTRACE_PROBE1(hotspot_jni, DetachCurrentThread__return, JNI_ERR); |
5400 DTRACE_PROBE1(hotspot_jni, DetachCurrentThread__return, JNI_ERR); |
|
5401 #else /* USDT2 */ |
|
5402 HOTSPOT_JNI_DETACHCURRENTTHREAD_RETURN( |
|
5403 (uint32_t) JNI_ERR); |
|
5404 #endif /* USDT2 */ |
3599 // Can't detach a thread that's running java, that can't work. |
5405 // Can't detach a thread that's running java, that can't work. |
3600 return JNI_ERR; |
5406 return JNI_ERR; |
3601 } |
5407 } |
3602 |
5408 |
3603 // Safepoint support. Have to do call-back to safepoint code, if in the |
5409 // Safepoint support. Have to do call-back to safepoint code, if in the |