189 |
161 |
190 #define COMMA , |
162 #define COMMA , |
191 |
163 |
192 // Choose DT_RETURN_MARK macros based on the type: float/double -> void |
164 // Choose DT_RETURN_MARK macros based on the type: float/double -> void |
193 // (dtrace doesn't do FP yet) |
165 // (dtrace doesn't do FP yet) |
194 #ifndef USDT2 |
|
195 #define DT_RETURN_MARK_DECL_FOR(TypeName, name, type) \ |
|
196 FP_SELECT(TypeName, \ |
|
197 DT_RETURN_MARK_DECL(name, type), DT_VOID_RETURN_MARK_DECL(name) ) |
|
198 #else /* USDT2 */ |
|
199 #define DT_RETURN_MARK_DECL_FOR(TypeName, name, type, probe) \ |
166 #define DT_RETURN_MARK_DECL_FOR(TypeName, name, type, probe) \ |
200 FP_SELECT(TypeName, \ |
167 FP_SELECT(TypeName, \ |
201 DT_RETURN_MARK_DECL(name, type, probe), DT_VOID_RETURN_MARK_DECL(name, probe) ) |
168 DT_RETURN_MARK_DECL(name, type, probe), DT_VOID_RETURN_MARK_DECL(name, probe) ) |
202 #endif /* USDT2 */ |
|
203 #define DT_RETURN_MARK_FOR(TypeName, name, type, ref) \ |
169 #define DT_RETURN_MARK_FOR(TypeName, name, type, ref) \ |
204 FP_SELECT(TypeName, \ |
170 FP_SELECT(TypeName, \ |
205 DT_RETURN_MARK(name, type, ref), DT_VOID_RETURN_MARK(name) ) |
171 DT_RETURN_MARK(name, type, ref), DT_VOID_RETURN_MARK(name) ) |
206 |
172 |
207 |
173 |
356 #endif |
322 #endif |
357 |
323 |
358 |
324 |
359 // Implementation of JNI entries |
325 // Implementation of JNI entries |
360 |
326 |
361 #ifndef USDT2 |
|
362 DT_RETURN_MARK_DECL(DefineClass, jclass); |
|
363 #else /* USDT2 */ |
|
364 DT_RETURN_MARK_DECL(DefineClass, jclass |
327 DT_RETURN_MARK_DECL(DefineClass, jclass |
365 , HOTSPOT_JNI_DEFINECLASS_RETURN(_ret_ref)); |
328 , HOTSPOT_JNI_DEFINECLASS_RETURN(_ret_ref)); |
366 #endif /* USDT2 */ |
|
367 |
329 |
368 JNI_ENTRY(jclass, jni_DefineClass(JNIEnv *env, const char *name, jobject loaderRef, |
330 JNI_ENTRY(jclass, jni_DefineClass(JNIEnv *env, const char *name, jobject loaderRef, |
369 const jbyte *buf, jsize bufLen)) |
331 const jbyte *buf, jsize bufLen)) |
370 JNIWrapper("DefineClass"); |
332 JNIWrapper("DefineClass"); |
371 |
333 |
372 #ifndef USDT2 |
|
373 DTRACE_PROBE5(hotspot_jni, DefineClass__entry, |
|
374 env, name, loaderRef, buf, bufLen); |
|
375 #else /* USDT2 */ |
|
376 HOTSPOT_JNI_DEFINECLASS_ENTRY( |
334 HOTSPOT_JNI_DEFINECLASS_ENTRY( |
377 env, (char*) name, loaderRef, (char*) buf, bufLen); |
335 env, (char*) name, loaderRef, (char*) buf, bufLen); |
378 #endif /* USDT2 */ |
336 |
379 jclass cls = NULL; |
337 jclass cls = NULL; |
380 DT_RETURN_MARK(DefineClass, jclass, (const jclass&)cls); |
338 DT_RETURN_MARK(DefineClass, jclass, (const jclass&)cls); |
381 |
339 |
382 TempNewSymbol class_name = NULL; |
340 TempNewSymbol class_name = NULL; |
383 // Since exceptions can be thrown, class initialization can take place |
341 // Since exceptions can be thrown, class initialization can take place |
584 assert(InstanceKlass::cast(k1())->contains_field_offset(offset), "stay within object"); |
523 assert(InstanceKlass::cast(k1())->contains_field_offset(offset), "stay within object"); |
585 ret = jfieldIDWorkaround::to_instance_jfieldID(k1(), offset); |
524 ret = jfieldIDWorkaround::to_instance_jfieldID(k1(), offset); |
586 return ret; |
525 return ret; |
587 JNI_END |
526 JNI_END |
588 |
527 |
589 #ifndef USDT2 |
528 |
590 DT_RETURN_MARK_DECL(ToReflectedMethod, jobject); |
|
591 #else /* USDT2 */ |
|
592 DT_RETURN_MARK_DECL(ToReflectedMethod, jobject |
529 DT_RETURN_MARK_DECL(ToReflectedMethod, jobject |
593 , HOTSPOT_JNI_TOREFLECTEDMETHOD_RETURN(_ret_ref)); |
530 , HOTSPOT_JNI_TOREFLECTEDMETHOD_RETURN(_ret_ref)); |
594 #endif /* USDT2 */ |
|
595 |
531 |
596 JNI_ENTRY(jobject, jni_ToReflectedMethod(JNIEnv *env, jclass cls, jmethodID method_id, jboolean isStatic)) |
532 JNI_ENTRY(jobject, jni_ToReflectedMethod(JNIEnv *env, jclass cls, jmethodID method_id, jboolean isStatic)) |
597 JNIWrapper("ToReflectedMethod"); |
533 JNIWrapper("ToReflectedMethod"); |
598 #ifndef USDT2 |
534 |
599 DTRACE_PROBE4(hotspot_jni, ToReflectedMethod__entry, env, cls, method_id, isStatic); |
|
600 #else /* USDT2 */ |
|
601 HOTSPOT_JNI_TOREFLECTEDMETHOD_ENTRY(env, cls, (uintptr_t) method_id, isStatic); |
535 HOTSPOT_JNI_TOREFLECTEDMETHOD_ENTRY(env, cls, (uintptr_t) method_id, isStatic); |
602 #endif /* USDT2 */ |
536 |
603 jobject ret = NULL; |
537 jobject ret = NULL; |
604 DT_RETURN_MARK(ToReflectedMethod, jobject, (const jobject&)ret); |
538 DT_RETURN_MARK(ToReflectedMethod, jobject, (const jobject&)ret); |
605 |
539 |
606 methodHandle m (THREAD, Method::resolve_jmethod_id(method_id)); |
540 methodHandle m (THREAD, Method::resolve_jmethod_id(method_id)); |
607 assert(m->is_static() == (isStatic != 0), "jni_ToReflectedMethod access flags doesn't match"); |
541 assert(m->is_static() == (isStatic != 0), "jni_ToReflectedMethod access flags doesn't match"); |
655 return obj; |
583 return obj; |
656 JNI_END |
584 JNI_END |
657 |
585 |
658 JNI_QUICK_ENTRY(jboolean, jni_IsAssignableFrom(JNIEnv *env, jclass sub, jclass super)) |
586 JNI_QUICK_ENTRY(jboolean, jni_IsAssignableFrom(JNIEnv *env, jclass sub, jclass super)) |
659 JNIWrapper("IsSubclassOf"); |
587 JNIWrapper("IsSubclassOf"); |
660 #ifndef USDT2 |
588 |
661 DTRACE_PROBE3(hotspot_jni, IsAssignableFrom__entry, env, sub, super); |
|
662 #else /* USDT2 */ |
|
663 HOTSPOT_JNI_ISASSIGNABLEFROM_ENTRY(env, sub, super); |
589 HOTSPOT_JNI_ISASSIGNABLEFROM_ENTRY(env, sub, super); |
664 #endif /* USDT2 */ |
590 |
665 oop sub_mirror = JNIHandles::resolve_non_null(sub); |
591 oop sub_mirror = JNIHandles::resolve_non_null(sub); |
666 oop super_mirror = JNIHandles::resolve_non_null(super); |
592 oop super_mirror = JNIHandles::resolve_non_null(super); |
667 if (java_lang_Class::is_primitive(sub_mirror) || |
593 if (java_lang_Class::is_primitive(sub_mirror) || |
668 java_lang_Class::is_primitive(super_mirror)) { |
594 java_lang_Class::is_primitive(super_mirror)) { |
669 jboolean ret = (sub_mirror == super_mirror); |
595 jboolean ret = (sub_mirror == super_mirror); |
670 #ifndef USDT2 |
596 |
671 DTRACE_PROBE1(hotspot_jni, IsAssignableFrom__return, ret); |
|
672 #else /* USDT2 */ |
|
673 HOTSPOT_JNI_ISASSIGNABLEFROM_RETURN(ret); |
597 HOTSPOT_JNI_ISASSIGNABLEFROM_RETURN(ret); |
674 #endif /* USDT2 */ |
|
675 return ret; |
598 return ret; |
676 } |
599 } |
677 Klass* sub_klass = java_lang_Class::as_Klass(sub_mirror); |
600 Klass* sub_klass = java_lang_Class::as_Klass(sub_mirror); |
678 Klass* super_klass = java_lang_Class::as_Klass(super_mirror); |
601 Klass* super_klass = java_lang_Class::as_Klass(super_mirror); |
679 assert(sub_klass != NULL && super_klass != NULL, "invalid arguments to jni_IsAssignableFrom"); |
602 assert(sub_klass != NULL && super_klass != NULL, "invalid arguments to jni_IsAssignableFrom"); |
680 jboolean ret = sub_klass->is_subtype_of(super_klass) ? |
603 jboolean ret = sub_klass->is_subtype_of(super_klass) ? |
681 JNI_TRUE : JNI_FALSE; |
604 JNI_TRUE : JNI_FALSE; |
682 #ifndef USDT2 |
605 |
683 DTRACE_PROBE1(hotspot_jni, IsAssignableFrom__return, ret); |
|
684 #else /* USDT2 */ |
|
685 HOTSPOT_JNI_ISASSIGNABLEFROM_RETURN(ret); |
606 HOTSPOT_JNI_ISASSIGNABLEFROM_RETURN(ret); |
686 #endif /* USDT2 */ |
|
687 return ret; |
607 return ret; |
688 JNI_END |
608 JNI_END |
689 |
609 |
690 #ifndef USDT2 |
610 |
691 DT_RETURN_MARK_DECL(Throw, jint); |
|
692 #else /* USDT2 */ |
|
693 DT_RETURN_MARK_DECL(Throw, jint |
611 DT_RETURN_MARK_DECL(Throw, jint |
694 , HOTSPOT_JNI_THROW_RETURN(_ret_ref)); |
612 , HOTSPOT_JNI_THROW_RETURN(_ret_ref)); |
695 #endif /* USDT2 */ |
|
696 |
613 |
697 JNI_ENTRY(jint, jni_Throw(JNIEnv *env, jthrowable obj)) |
614 JNI_ENTRY(jint, jni_Throw(JNIEnv *env, jthrowable obj)) |
698 JNIWrapper("Throw"); |
615 JNIWrapper("Throw"); |
699 #ifndef USDT2 |
616 |
700 DTRACE_PROBE2(hotspot_jni, Throw__entry, env, obj); |
|
701 #else /* USDT2 */ |
|
702 HOTSPOT_JNI_THROW_ENTRY(env, obj); |
617 HOTSPOT_JNI_THROW_ENTRY(env, obj); |
703 #endif /* USDT2 */ |
618 |
704 jint ret = JNI_OK; |
619 jint ret = JNI_OK; |
705 DT_RETURN_MARK(Throw, jint, (const jint&)ret); |
620 DT_RETURN_MARK(Throw, jint, (const jint&)ret); |
706 |
621 |
707 THROW_OOP_(JNIHandles::resolve(obj), JNI_OK); |
622 THROW_OOP_(JNIHandles::resolve(obj), JNI_OK); |
708 ShouldNotReachHere(); |
623 ShouldNotReachHere(); |
709 JNI_END |
624 JNI_END |
710 |
625 |
711 #ifndef USDT2 |
626 |
712 DT_RETURN_MARK_DECL(ThrowNew, jint); |
|
713 #else /* USDT2 */ |
|
714 DT_RETURN_MARK_DECL(ThrowNew, jint |
627 DT_RETURN_MARK_DECL(ThrowNew, jint |
715 , HOTSPOT_JNI_THROWNEW_RETURN(_ret_ref)); |
628 , HOTSPOT_JNI_THROWNEW_RETURN(_ret_ref)); |
716 #endif /* USDT2 */ |
|
717 |
629 |
718 JNI_ENTRY(jint, jni_ThrowNew(JNIEnv *env, jclass clazz, const char *message)) |
630 JNI_ENTRY(jint, jni_ThrowNew(JNIEnv *env, jclass clazz, const char *message)) |
719 JNIWrapper("ThrowNew"); |
631 JNIWrapper("ThrowNew"); |
720 #ifndef USDT2 |
632 |
721 DTRACE_PROBE3(hotspot_jni, ThrowNew__entry, env, clazz, message); |
|
722 #else /* USDT2 */ |
|
723 HOTSPOT_JNI_THROWNEW_ENTRY(env, clazz, (char *) message); |
633 HOTSPOT_JNI_THROWNEW_ENTRY(env, clazz, (char *) message); |
724 #endif /* USDT2 */ |
634 |
725 jint ret = JNI_OK; |
635 jint ret = JNI_OK; |
726 DT_RETURN_MARK(ThrowNew, jint, (const jint&)ret); |
636 DT_RETURN_MARK(ThrowNew, jint, (const jint&)ret); |
727 |
637 |
728 InstanceKlass* k = InstanceKlass::cast(java_lang_Class::as_Klass(JNIHandles::resolve_non_null(clazz))); |
638 InstanceKlass* k = InstanceKlass::cast(java_lang_Class::as_Klass(JNIHandles::resolve_non_null(clazz))); |
729 Symbol* name = k->name(); |
639 Symbol* name = k->name(); |
748 thread->check_and_handle_async_exceptions(); |
658 thread->check_and_handle_async_exceptions(); |
749 } |
659 } |
750 |
660 |
751 JNI_ENTRY_NO_PRESERVE(jthrowable, jni_ExceptionOccurred(JNIEnv *env)) |
661 JNI_ENTRY_NO_PRESERVE(jthrowable, jni_ExceptionOccurred(JNIEnv *env)) |
752 JNIWrapper("ExceptionOccurred"); |
662 JNIWrapper("ExceptionOccurred"); |
753 #ifndef USDT2 |
663 |
754 DTRACE_PROBE1(hotspot_jni, ExceptionOccurred__entry, env); |
|
755 #else /* USDT2 */ |
|
756 HOTSPOT_JNI_EXCEPTIONOCCURRED_ENTRY(env); |
664 HOTSPOT_JNI_EXCEPTIONOCCURRED_ENTRY(env); |
757 #endif /* USDT2 */ |
665 |
758 jni_check_async_exceptions(thread); |
666 jni_check_async_exceptions(thread); |
759 oop exception = thread->pending_exception(); |
667 oop exception = thread->pending_exception(); |
760 jthrowable ret = (jthrowable) JNIHandles::make_local(env, exception); |
668 jthrowable ret = (jthrowable) JNIHandles::make_local(env, exception); |
761 #ifndef USDT2 |
669 |
762 DTRACE_PROBE1(hotspot_jni, ExceptionOccurred__return, ret); |
|
763 #else /* USDT2 */ |
|
764 HOTSPOT_JNI_EXCEPTIONOCCURRED_RETURN(ret); |
670 HOTSPOT_JNI_EXCEPTIONOCCURRED_RETURN(ret); |
765 #endif /* USDT2 */ |
|
766 return ret; |
671 return ret; |
767 JNI_END |
672 JNI_END |
768 |
673 |
769 |
674 |
770 JNI_ENTRY_NO_PRESERVE(void, jni_ExceptionDescribe(JNIEnv *env)) |
675 JNI_ENTRY_NO_PRESERVE(void, jni_ExceptionDescribe(JNIEnv *env)) |
771 JNIWrapper("ExceptionDescribe"); |
676 JNIWrapper("ExceptionDescribe"); |
772 #ifndef USDT2 |
677 |
773 DTRACE_PROBE1(hotspot_jni, ExceptionDescribe__entry, env); |
|
774 #else /* USDT2 */ |
|
775 HOTSPOT_JNI_EXCEPTIONDESCRIBE_ENTRY(env); |
678 HOTSPOT_JNI_EXCEPTIONDESCRIBE_ENTRY(env); |
776 #endif /* USDT2 */ |
679 |
777 if (thread->has_pending_exception()) { |
680 if (thread->has_pending_exception()) { |
778 Handle ex(thread, thread->pending_exception()); |
681 Handle ex(thread, thread->pending_exception()); |
779 thread->clear_pending_exception(); |
682 thread->clear_pending_exception(); |
780 if (ex->is_a(SystemDictionary::ThreadDeath_klass())) { |
683 if (ex->is_a(SystemDictionary::ThreadDeath_klass())) { |
781 // Don't print anything if we are being killed. |
684 // Don't print anything if we are being killed. |
807 ". Uncaught exception of type %s.", |
710 ". Uncaught exception of type %s.", |
808 ex->klass()->external_name()); |
711 ex->klass()->external_name()); |
809 } |
712 } |
810 } |
713 } |
811 } |
714 } |
812 #ifndef USDT2 |
715 |
813 DTRACE_PROBE(hotspot_jni, ExceptionDescribe__return); |
|
814 #else /* USDT2 */ |
|
815 HOTSPOT_JNI_EXCEPTIONDESCRIBE_RETURN(); |
716 HOTSPOT_JNI_EXCEPTIONDESCRIBE_RETURN(); |
816 #endif /* USDT2 */ |
|
817 JNI_END |
717 JNI_END |
818 |
718 |
819 |
719 |
820 JNI_QUICK_ENTRY(void, jni_ExceptionClear(JNIEnv *env)) |
720 JNI_QUICK_ENTRY(void, jni_ExceptionClear(JNIEnv *env)) |
821 JNIWrapper("ExceptionClear"); |
721 JNIWrapper("ExceptionClear"); |
822 #ifndef USDT2 |
722 |
823 DTRACE_PROBE1(hotspot_jni, ExceptionClear__entry, env); |
|
824 #else /* USDT2 */ |
|
825 HOTSPOT_JNI_EXCEPTIONCLEAR_ENTRY(env); |
723 HOTSPOT_JNI_EXCEPTIONCLEAR_ENTRY(env); |
826 #endif /* USDT2 */ |
|
827 |
724 |
828 // The jni code might be using this API to clear java thrown exception. |
725 // The jni code might be using this API to clear java thrown exception. |
829 // So just mark jvmti thread exception state as exception caught. |
726 // So just mark jvmti thread exception state as exception caught. |
830 JvmtiThreadState *state = JavaThread::current()->jvmti_thread_state(); |
727 JvmtiThreadState *state = JavaThread::current()->jvmti_thread_state(); |
831 if (state != NULL && state->is_exception_detected()) { |
728 if (state != NULL && state->is_exception_detected()) { |
832 state->set_exception_caught(); |
729 state->set_exception_caught(); |
833 } |
730 } |
834 thread->clear_pending_exception(); |
731 thread->clear_pending_exception(); |
835 #ifndef USDT2 |
732 |
836 DTRACE_PROBE(hotspot_jni, ExceptionClear__return); |
|
837 #else /* USDT2 */ |
|
838 HOTSPOT_JNI_EXCEPTIONCLEAR_RETURN(); |
733 HOTSPOT_JNI_EXCEPTIONCLEAR_RETURN(); |
839 #endif /* USDT2 */ |
|
840 JNI_END |
734 JNI_END |
841 |
735 |
842 |
736 |
843 JNI_ENTRY(void, jni_FatalError(JNIEnv *env, const char *msg)) |
737 JNI_ENTRY(void, jni_FatalError(JNIEnv *env, const char *msg)) |
844 JNIWrapper("FatalError"); |
738 JNIWrapper("FatalError"); |
845 #ifndef USDT2 |
739 |
846 DTRACE_PROBE2(hotspot_jni, FatalError__entry, env, msg); |
|
847 #else /* USDT2 */ |
|
848 HOTSPOT_JNI_FATALERROR_ENTRY(env, (char *) msg); |
740 HOTSPOT_JNI_FATALERROR_ENTRY(env, (char *) msg); |
849 #endif /* USDT2 */ |
741 |
850 tty->print_cr("FATAL ERROR in native method: %s", msg); |
742 tty->print_cr("FATAL ERROR in native method: %s", msg); |
851 thread->print_stack(); |
743 thread->print_stack(); |
852 os::abort(); // Dump core and abort |
744 os::abort(); // Dump core and abort |
853 JNI_END |
745 JNI_END |
854 |
746 |
855 |
747 |
856 JNI_ENTRY(jint, jni_PushLocalFrame(JNIEnv *env, jint capacity)) |
748 JNI_ENTRY(jint, jni_PushLocalFrame(JNIEnv *env, jint capacity)) |
857 JNIWrapper("PushLocalFrame"); |
749 JNIWrapper("PushLocalFrame"); |
858 #ifndef USDT2 |
750 |
859 DTRACE_PROBE2(hotspot_jni, PushLocalFrame__entry, env, capacity); |
|
860 #else /* USDT2 */ |
|
861 HOTSPOT_JNI_PUSHLOCALFRAME_ENTRY(env, capacity); |
751 HOTSPOT_JNI_PUSHLOCALFRAME_ENTRY(env, capacity); |
862 #endif /* USDT2 */ |
752 |
863 //%note jni_11 |
753 //%note jni_11 |
864 if (capacity < 0 || capacity > MAX_REASONABLE_LOCAL_CAPACITY) { |
754 if (capacity < 0 || capacity > MAX_REASONABLE_LOCAL_CAPACITY) { |
865 #ifndef USDT2 |
|
866 DTRACE_PROBE1(hotspot_jni, PushLocalFrame__return, JNI_ERR); |
|
867 #else /* USDT2 */ |
|
868 HOTSPOT_JNI_PUSHLOCALFRAME_RETURN((uint32_t)JNI_ERR); |
755 HOTSPOT_JNI_PUSHLOCALFRAME_RETURN((uint32_t)JNI_ERR); |
869 #endif /* USDT2 */ |
|
870 return JNI_ERR; |
756 return JNI_ERR; |
871 } |
757 } |
872 JNIHandleBlock* old_handles = thread->active_handles(); |
758 JNIHandleBlock* old_handles = thread->active_handles(); |
873 JNIHandleBlock* new_handles = JNIHandleBlock::allocate_block(thread); |
759 JNIHandleBlock* new_handles = JNIHandleBlock::allocate_block(thread); |
874 assert(new_handles != NULL, "should not be NULL"); |
760 assert(new_handles != NULL, "should not be NULL"); |
875 new_handles->set_pop_frame_link(old_handles); |
761 new_handles->set_pop_frame_link(old_handles); |
876 thread->set_active_handles(new_handles); |
762 thread->set_active_handles(new_handles); |
877 jint ret = JNI_OK; |
763 jint ret = JNI_OK; |
878 #ifndef USDT2 |
|
879 DTRACE_PROBE1(hotspot_jni, PushLocalFrame__return, ret); |
|
880 #else /* USDT2 */ |
|
881 HOTSPOT_JNI_PUSHLOCALFRAME_RETURN(ret); |
764 HOTSPOT_JNI_PUSHLOCALFRAME_RETURN(ret); |
882 #endif /* USDT2 */ |
|
883 return ret; |
765 return ret; |
884 JNI_END |
766 JNI_END |
885 |
767 |
886 |
768 |
887 JNI_ENTRY(jobject, jni_PopLocalFrame(JNIEnv *env, jobject result)) |
769 JNI_ENTRY(jobject, jni_PopLocalFrame(JNIEnv *env, jobject result)) |
888 JNIWrapper("PopLocalFrame"); |
770 JNIWrapper("PopLocalFrame"); |
889 #ifndef USDT2 |
771 |
890 DTRACE_PROBE2(hotspot_jni, PopLocalFrame__entry, env, result); |
|
891 #else /* USDT2 */ |
|
892 HOTSPOT_JNI_POPLOCALFRAME_ENTRY(env, result); |
772 HOTSPOT_JNI_POPLOCALFRAME_ENTRY(env, result); |
893 #endif /* USDT2 */ |
773 |
894 //%note jni_11 |
774 //%note jni_11 |
895 Handle result_handle(thread, JNIHandles::resolve(result)); |
775 Handle result_handle(thread, JNIHandles::resolve(result)); |
896 JNIHandleBlock* old_handles = thread->active_handles(); |
776 JNIHandleBlock* old_handles = thread->active_handles(); |
897 JNIHandleBlock* new_handles = old_handles->pop_frame_link(); |
777 JNIHandleBlock* new_handles = old_handles->pop_frame_link(); |
898 if (new_handles != NULL) { |
778 if (new_handles != NULL) { |
903 thread->set_active_handles(new_handles); |
783 thread->set_active_handles(new_handles); |
904 old_handles->set_pop_frame_link(NULL); // clear link we won't release new_handles below |
784 old_handles->set_pop_frame_link(NULL); // clear link we won't release new_handles below |
905 JNIHandleBlock::release_block(old_handles, thread); // may block |
785 JNIHandleBlock::release_block(old_handles, thread); // may block |
906 result = JNIHandles::make_local(thread, result_handle()); |
786 result = JNIHandles::make_local(thread, result_handle()); |
907 } |
787 } |
908 #ifndef USDT2 |
|
909 DTRACE_PROBE1(hotspot_jni, PopLocalFrame__return, result); |
|
910 #else /* USDT2 */ |
|
911 HOTSPOT_JNI_POPLOCALFRAME_RETURN(result); |
788 HOTSPOT_JNI_POPLOCALFRAME_RETURN(result); |
912 #endif /* USDT2 */ |
|
913 return result; |
789 return result; |
914 JNI_END |
790 JNI_END |
915 |
791 |
916 |
792 |
917 JNI_ENTRY(jobject, jni_NewGlobalRef(JNIEnv *env, jobject ref)) |
793 JNI_ENTRY(jobject, jni_NewGlobalRef(JNIEnv *env, jobject ref)) |
918 JNIWrapper("NewGlobalRef"); |
794 JNIWrapper("NewGlobalRef"); |
919 #ifndef USDT2 |
795 |
920 DTRACE_PROBE2(hotspot_jni, NewGlobalRef__entry, env, ref); |
|
921 #else /* USDT2 */ |
|
922 HOTSPOT_JNI_NEWGLOBALREF_ENTRY(env, ref); |
796 HOTSPOT_JNI_NEWGLOBALREF_ENTRY(env, ref); |
923 #endif /* USDT2 */ |
797 |
924 Handle ref_handle(thread, JNIHandles::resolve(ref)); |
798 Handle ref_handle(thread, JNIHandles::resolve(ref)); |
925 jobject ret = JNIHandles::make_global(ref_handle); |
799 jobject ret = JNIHandles::make_global(ref_handle); |
926 #ifndef USDT2 |
800 |
927 DTRACE_PROBE1(hotspot_jni, NewGlobalRef__return, ret); |
|
928 #else /* USDT2 */ |
|
929 HOTSPOT_JNI_NEWGLOBALREF_RETURN(ret); |
801 HOTSPOT_JNI_NEWGLOBALREF_RETURN(ret); |
930 #endif /* USDT2 */ |
|
931 return ret; |
802 return ret; |
932 JNI_END |
803 JNI_END |
933 |
804 |
934 // Must be JNI_ENTRY (with HandleMark) |
805 // Must be JNI_ENTRY (with HandleMark) |
935 JNI_ENTRY_NO_PRESERVE(void, jni_DeleteGlobalRef(JNIEnv *env, jobject ref)) |
806 JNI_ENTRY_NO_PRESERVE(void, jni_DeleteGlobalRef(JNIEnv *env, jobject ref)) |
936 JNIWrapper("DeleteGlobalRef"); |
807 JNIWrapper("DeleteGlobalRef"); |
937 #ifndef USDT2 |
808 |
938 DTRACE_PROBE2(hotspot_jni, DeleteGlobalRef__entry, env, ref); |
|
939 #else /* USDT2 */ |
|
940 HOTSPOT_JNI_DELETEGLOBALREF_ENTRY(env, ref); |
809 HOTSPOT_JNI_DELETEGLOBALREF_ENTRY(env, ref); |
941 #endif /* USDT2 */ |
810 |
942 JNIHandles::destroy_global(ref); |
811 JNIHandles::destroy_global(ref); |
943 #ifndef USDT2 |
812 |
944 DTRACE_PROBE(hotspot_jni, DeleteGlobalRef__return); |
|
945 #else /* USDT2 */ |
|
946 HOTSPOT_JNI_DELETEGLOBALREF_RETURN(); |
813 HOTSPOT_JNI_DELETEGLOBALREF_RETURN(); |
947 #endif /* USDT2 */ |
|
948 JNI_END |
814 JNI_END |
949 |
815 |
950 JNI_QUICK_ENTRY(void, jni_DeleteLocalRef(JNIEnv *env, jobject obj)) |
816 JNI_QUICK_ENTRY(void, jni_DeleteLocalRef(JNIEnv *env, jobject obj)) |
951 JNIWrapper("DeleteLocalRef"); |
817 JNIWrapper("DeleteLocalRef"); |
952 #ifndef USDT2 |
818 |
953 DTRACE_PROBE2(hotspot_jni, DeleteLocalRef__entry, env, obj); |
|
954 #else /* USDT2 */ |
|
955 HOTSPOT_JNI_DELETELOCALREF_ENTRY(env, obj); |
819 HOTSPOT_JNI_DELETELOCALREF_ENTRY(env, obj); |
956 #endif /* USDT2 */ |
820 |
957 JNIHandles::destroy_local(obj); |
821 JNIHandles::destroy_local(obj); |
958 #ifndef USDT2 |
822 |
959 DTRACE_PROBE(hotspot_jni, DeleteLocalRef__return); |
|
960 #else /* USDT2 */ |
|
961 HOTSPOT_JNI_DELETELOCALREF_RETURN(); |
823 HOTSPOT_JNI_DELETELOCALREF_RETURN(); |
962 #endif /* USDT2 */ |
|
963 JNI_END |
824 JNI_END |
964 |
825 |
965 JNI_QUICK_ENTRY(jboolean, jni_IsSameObject(JNIEnv *env, jobject r1, jobject r2)) |
826 JNI_QUICK_ENTRY(jboolean, jni_IsSameObject(JNIEnv *env, jobject r1, jobject r2)) |
966 JNIWrapper("IsSameObject"); |
827 JNIWrapper("IsSameObject"); |
967 #ifndef USDT2 |
828 |
968 DTRACE_PROBE3(hotspot_jni, IsSameObject__entry, env, r1, r2); |
|
969 #else /* USDT2 */ |
|
970 HOTSPOT_JNI_ISSAMEOBJECT_ENTRY(env, r1, r2); |
829 HOTSPOT_JNI_ISSAMEOBJECT_ENTRY(env, r1, r2); |
971 #endif /* USDT2 */ |
830 |
972 oop a = JNIHandles::resolve(r1); |
831 oop a = JNIHandles::resolve(r1); |
973 oop b = JNIHandles::resolve(r2); |
832 oop b = JNIHandles::resolve(r2); |
974 jboolean ret = (a == b) ? JNI_TRUE : JNI_FALSE; |
833 jboolean ret = (a == b) ? JNI_TRUE : JNI_FALSE; |
975 #ifndef USDT2 |
834 |
976 DTRACE_PROBE1(hotspot_jni, IsSameObject__return, ret); |
|
977 #else /* USDT2 */ |
|
978 HOTSPOT_JNI_ISSAMEOBJECT_RETURN(ret); |
835 HOTSPOT_JNI_ISSAMEOBJECT_RETURN(ret); |
979 #endif /* USDT2 */ |
|
980 return ret; |
836 return ret; |
981 JNI_END |
837 JNI_END |
982 |
838 |
983 |
839 |
984 JNI_ENTRY(jobject, jni_NewLocalRef(JNIEnv *env, jobject ref)) |
840 JNI_ENTRY(jobject, jni_NewLocalRef(JNIEnv *env, jobject ref)) |
985 JNIWrapper("NewLocalRef"); |
841 JNIWrapper("NewLocalRef"); |
986 #ifndef USDT2 |
842 |
987 DTRACE_PROBE2(hotspot_jni, NewLocalRef__entry, env, ref); |
|
988 #else /* USDT2 */ |
|
989 HOTSPOT_JNI_NEWLOCALREF_ENTRY(env, ref); |
843 HOTSPOT_JNI_NEWLOCALREF_ENTRY(env, ref); |
990 #endif /* USDT2 */ |
844 |
991 jobject ret = JNIHandles::make_local(env, JNIHandles::resolve(ref)); |
845 jobject ret = JNIHandles::make_local(env, JNIHandles::resolve(ref)); |
992 #ifndef USDT2 |
846 |
993 DTRACE_PROBE1(hotspot_jni, NewLocalRef__return, ret); |
|
994 #else /* USDT2 */ |
|
995 HOTSPOT_JNI_NEWLOCALREF_RETURN(ret); |
847 HOTSPOT_JNI_NEWLOCALREF_RETURN(ret); |
996 #endif /* USDT2 */ |
|
997 return ret; |
848 return ret; |
998 JNI_END |
849 JNI_END |
999 |
850 |
1000 JNI_LEAF(jint, jni_EnsureLocalCapacity(JNIEnv *env, jint capacity)) |
851 JNI_LEAF(jint, jni_EnsureLocalCapacity(JNIEnv *env, jint capacity)) |
1001 JNIWrapper("EnsureLocalCapacity"); |
852 JNIWrapper("EnsureLocalCapacity"); |
1002 #ifndef USDT2 |
853 |
1003 DTRACE_PROBE2(hotspot_jni, EnsureLocalCapacity__entry, env, capacity); |
|
1004 #else /* USDT2 */ |
|
1005 HOTSPOT_JNI_ENSURELOCALCAPACITY_ENTRY(env, capacity); |
854 HOTSPOT_JNI_ENSURELOCALCAPACITY_ENTRY(env, capacity); |
1006 #endif /* USDT2 */ |
855 |
1007 jint ret; |
856 jint ret; |
1008 if (capacity >= 0 && capacity <= MAX_REASONABLE_LOCAL_CAPACITY) { |
857 if (capacity >= 0 && capacity <= MAX_REASONABLE_LOCAL_CAPACITY) { |
1009 ret = JNI_OK; |
858 ret = JNI_OK; |
1010 } else { |
859 } else { |
1011 ret = JNI_ERR; |
860 ret = JNI_ERR; |
1012 } |
861 } |
1013 #ifndef USDT2 |
862 |
1014 DTRACE_PROBE1(hotspot_jni, EnsureLocalCapacity__return, ret); |
|
1015 #else /* USDT2 */ |
|
1016 HOTSPOT_JNI_ENSURELOCALCAPACITY_RETURN(ret); |
863 HOTSPOT_JNI_ENSURELOCALCAPACITY_RETURN(ret); |
1017 #endif /* USDT2 */ |
|
1018 return ret; |
864 return ret; |
1019 JNI_END |
865 JNI_END |
1020 |
866 |
1021 // Return the Handle Type |
867 // Return the Handle Type |
1022 JNI_LEAF(jobjectRefType, jni_GetObjectRefType(JNIEnv *env, jobject obj)) |
868 JNI_LEAF(jobjectRefType, jni_GetObjectRefType(JNIEnv *env, jobject obj)) |
1023 JNIWrapper("GetObjectRefType"); |
869 JNIWrapper("GetObjectRefType"); |
1024 #ifndef USDT2 |
870 |
1025 DTRACE_PROBE2(hotspot_jni, GetObjectRefType__entry, env, obj); |
|
1026 #else /* USDT2 */ |
|
1027 HOTSPOT_JNI_GETOBJECTREFTYPE_ENTRY(env, obj); |
871 HOTSPOT_JNI_GETOBJECTREFTYPE_ENTRY(env, obj); |
1028 #endif /* USDT2 */ |
872 |
1029 jobjectRefType ret; |
873 jobjectRefType ret; |
1030 if (JNIHandles::is_local_handle(thread, obj) || |
874 if (JNIHandles::is_local_handle(thread, obj) || |
1031 JNIHandles::is_frame_handle(thread, obj)) |
875 JNIHandles::is_frame_handle(thread, obj)) |
1032 ret = JNILocalRefType; |
876 ret = JNILocalRefType; |
1033 else if (JNIHandles::is_global_handle(obj)) |
877 else if (JNIHandles::is_global_handle(obj)) |
1034 ret = JNIGlobalRefType; |
878 ret = JNIGlobalRefType; |
1035 else if (JNIHandles::is_weak_global_handle(obj)) |
879 else if (JNIHandles::is_weak_global_handle(obj)) |
1036 ret = JNIWeakGlobalRefType; |
880 ret = JNIWeakGlobalRefType; |
1037 else |
881 else |
1038 ret = JNIInvalidRefType; |
882 ret = JNIInvalidRefType; |
1039 #ifndef USDT2 |
883 |
1040 DTRACE_PROBE1(hotspot_jni, GetObjectRefType__return, ret); |
|
1041 #else /* USDT2 */ |
|
1042 HOTSPOT_JNI_GETOBJECTREFTYPE_RETURN((void *) ret); |
884 HOTSPOT_JNI_GETOBJECTREFTYPE_RETURN((void *) ret); |
1043 #endif /* USDT2 */ |
|
1044 return ret; |
885 return ret; |
1045 JNI_END |
886 JNI_END |
1046 |
887 |
1047 |
888 |
1048 class JNI_ArgumentPusher : public SignatureIterator { |
889 class JNI_ArgumentPusher : public SignatureIterator { |
1367 InstanceKlass::cast(k())->initialize(CHECK_NULL); |
1208 InstanceKlass::cast(k())->initialize(CHECK_NULL); |
1368 instanceOop ih = InstanceKlass::cast(k())->allocate_instance(THREAD); |
1209 instanceOop ih = InstanceKlass::cast(k())->allocate_instance(THREAD); |
1369 return ih; |
1210 return ih; |
1370 } |
1211 } |
1371 |
1212 |
1372 #ifndef USDT2 |
|
1373 DT_RETURN_MARK_DECL(AllocObject, jobject); |
|
1374 #else /* USDT2 */ |
|
1375 DT_RETURN_MARK_DECL(AllocObject, jobject |
1213 DT_RETURN_MARK_DECL(AllocObject, jobject |
1376 , HOTSPOT_JNI_ALLOCOBJECT_RETURN(_ret_ref)); |
1214 , HOTSPOT_JNI_ALLOCOBJECT_RETURN(_ret_ref)); |
1377 #endif /* USDT2 */ |
|
1378 |
1215 |
1379 JNI_ENTRY(jobject, jni_AllocObject(JNIEnv *env, jclass clazz)) |
1216 JNI_ENTRY(jobject, jni_AllocObject(JNIEnv *env, jclass clazz)) |
1380 JNIWrapper("AllocObject"); |
1217 JNIWrapper("AllocObject"); |
1381 |
1218 |
1382 #ifndef USDT2 |
|
1383 DTRACE_PROBE2(hotspot_jni, AllocObject__entry, env, clazz); |
|
1384 #else /* USDT2 */ |
|
1385 HOTSPOT_JNI_ALLOCOBJECT_ENTRY(env, clazz); |
1219 HOTSPOT_JNI_ALLOCOBJECT_ENTRY(env, clazz); |
1386 #endif /* USDT2 */ |
1220 |
1387 jobject ret = NULL; |
1221 jobject ret = NULL; |
1388 DT_RETURN_MARK(AllocObject, jobject, (const jobject&)ret); |
1222 DT_RETURN_MARK(AllocObject, jobject, (const jobject&)ret); |
1389 |
1223 |
1390 instanceOop i = alloc_object(clazz, CHECK_NULL); |
1224 instanceOop i = alloc_object(clazz, CHECK_NULL); |
1391 ret = JNIHandles::make_local(env, i); |
1225 ret = JNIHandles::make_local(env, i); |
1392 return ret; |
1226 return ret; |
1393 JNI_END |
1227 JNI_END |
1394 |
1228 |
1395 #ifndef USDT2 |
|
1396 DT_RETURN_MARK_DECL(NewObjectA, jobject); |
|
1397 #else /* USDT2 */ |
|
1398 DT_RETURN_MARK_DECL(NewObjectA, jobject |
1229 DT_RETURN_MARK_DECL(NewObjectA, jobject |
1399 , HOTSPOT_JNI_NEWOBJECTA_RETURN(_ret_ref)); |
1230 , HOTSPOT_JNI_NEWOBJECTA_RETURN(_ret_ref)); |
1400 #endif /* USDT2 */ |
|
1401 |
1231 |
1402 JNI_ENTRY(jobject, jni_NewObjectA(JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args)) |
1232 JNI_ENTRY(jobject, jni_NewObjectA(JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args)) |
1403 JNIWrapper("NewObjectA"); |
1233 JNIWrapper("NewObjectA"); |
1404 #ifndef USDT2 |
1234 |
1405 DTRACE_PROBE3(hotspot_jni, NewObjectA__entry, env, clazz, methodID); |
|
1406 #else /* USDT2 */ |
|
1407 HOTSPOT_JNI_NEWOBJECTA_ENTRY(env, clazz, (uintptr_t) methodID); |
1235 HOTSPOT_JNI_NEWOBJECTA_ENTRY(env, clazz, (uintptr_t) methodID); |
1408 #endif /* USDT2 */ |
1236 |
1409 jobject obj = NULL; |
1237 jobject obj = NULL; |
1410 DT_RETURN_MARK(NewObjectA, jobject, (const jobject)obj); |
1238 DT_RETURN_MARK(NewObjectA, jobject, (const jobject)obj); |
1411 |
1239 |
1412 instanceOop i = alloc_object(clazz, CHECK_NULL); |
1240 instanceOop i = alloc_object(clazz, CHECK_NULL); |
1413 obj = JNIHandles::make_local(env, i); |
1241 obj = JNIHandles::make_local(env, i); |
1415 JNI_ArgumentPusherArray ap(methodID, args); |
1243 JNI_ArgumentPusherArray ap(methodID, args); |
1416 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK_NULL); |
1244 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK_NULL); |
1417 return obj; |
1245 return obj; |
1418 JNI_END |
1246 JNI_END |
1419 |
1247 |
1420 #ifndef USDT2 |
1248 |
1421 DT_RETURN_MARK_DECL(NewObjectV, jobject); |
|
1422 #else /* USDT2 */ |
|
1423 DT_RETURN_MARK_DECL(NewObjectV, jobject |
1249 DT_RETURN_MARK_DECL(NewObjectV, jobject |
1424 , HOTSPOT_JNI_NEWOBJECTV_RETURN(_ret_ref)); |
1250 , HOTSPOT_JNI_NEWOBJECTV_RETURN(_ret_ref)); |
1425 #endif /* USDT2 */ |
|
1426 |
1251 |
1427 JNI_ENTRY(jobject, jni_NewObjectV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)) |
1252 JNI_ENTRY(jobject, jni_NewObjectV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)) |
1428 JNIWrapper("NewObjectV"); |
1253 JNIWrapper("NewObjectV"); |
1429 #ifndef USDT2 |
1254 |
1430 DTRACE_PROBE3(hotspot_jni, NewObjectV__entry, env, clazz, methodID); |
|
1431 #else /* USDT2 */ |
|
1432 HOTSPOT_JNI_NEWOBJECTV_ENTRY(env, clazz, (uintptr_t) methodID); |
1255 HOTSPOT_JNI_NEWOBJECTV_ENTRY(env, clazz, (uintptr_t) methodID); |
1433 #endif /* USDT2 */ |
1256 |
1434 jobject obj = NULL; |
1257 jobject obj = NULL; |
1435 DT_RETURN_MARK(NewObjectV, jobject, (const jobject&)obj); |
1258 DT_RETURN_MARK(NewObjectV, jobject, (const jobject&)obj); |
1436 |
1259 |
1437 instanceOop i = alloc_object(clazz, CHECK_NULL); |
1260 instanceOop i = alloc_object(clazz, CHECK_NULL); |
1438 obj = JNIHandles::make_local(env, i); |
1261 obj = JNIHandles::make_local(env, i); |
1440 JNI_ArgumentPusherVaArg ap(methodID, args); |
1263 JNI_ArgumentPusherVaArg ap(methodID, args); |
1441 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK_NULL); |
1264 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK_NULL); |
1442 return obj; |
1265 return obj; |
1443 JNI_END |
1266 JNI_END |
1444 |
1267 |
1445 #ifndef USDT2 |
1268 |
1446 DT_RETURN_MARK_DECL(NewObject, jobject); |
|
1447 #else /* USDT2 */ |
|
1448 DT_RETURN_MARK_DECL(NewObject, jobject |
1269 DT_RETURN_MARK_DECL(NewObject, jobject |
1449 , HOTSPOT_JNI_NEWOBJECT_RETURN(_ret_ref)); |
1270 , HOTSPOT_JNI_NEWOBJECT_RETURN(_ret_ref)); |
1450 #endif /* USDT2 */ |
|
1451 |
1271 |
1452 JNI_ENTRY(jobject, jni_NewObject(JNIEnv *env, jclass clazz, jmethodID methodID, ...)) |
1272 JNI_ENTRY(jobject, jni_NewObject(JNIEnv *env, jclass clazz, jmethodID methodID, ...)) |
1453 JNIWrapper("NewObject"); |
1273 JNIWrapper("NewObject"); |
1454 #ifndef USDT2 |
1274 |
1455 DTRACE_PROBE3(hotspot_jni, NewObject__entry, env, clazz, methodID); |
|
1456 #else /* USDT2 */ |
|
1457 HOTSPOT_JNI_NEWOBJECT_ENTRY(env, clazz, (uintptr_t) methodID); |
1275 HOTSPOT_JNI_NEWOBJECT_ENTRY(env, clazz, (uintptr_t) methodID); |
1458 #endif /* USDT2 */ |
1276 |
1459 jobject obj = NULL; |
1277 jobject obj = NULL; |
1460 DT_RETURN_MARK(NewObject, jobject, (const jobject&)obj); |
1278 DT_RETURN_MARK(NewObject, jobject, (const jobject&)obj); |
1461 |
1279 |
1462 instanceOop i = alloc_object(clazz, CHECK_NULL); |
1280 instanceOop i = alloc_object(clazz, CHECK_NULL); |
1463 obj = JNIHandles::make_local(env, i); |
1281 obj = JNIHandles::make_local(env, i); |
1471 JNI_END |
1289 JNI_END |
1472 |
1290 |
1473 |
1291 |
1474 JNI_ENTRY(jclass, jni_GetObjectClass(JNIEnv *env, jobject obj)) |
1292 JNI_ENTRY(jclass, jni_GetObjectClass(JNIEnv *env, jobject obj)) |
1475 JNIWrapper("GetObjectClass"); |
1293 JNIWrapper("GetObjectClass"); |
1476 #ifndef USDT2 |
1294 |
1477 DTRACE_PROBE2(hotspot_jni, GetObjectClass__entry, env, obj); |
|
1478 #else /* USDT2 */ |
|
1479 HOTSPOT_JNI_GETOBJECTCLASS_ENTRY(env, obj); |
1295 HOTSPOT_JNI_GETOBJECTCLASS_ENTRY(env, obj); |
1480 #endif /* USDT2 */ |
1296 |
1481 Klass* k = JNIHandles::resolve_non_null(obj)->klass(); |
1297 Klass* k = JNIHandles::resolve_non_null(obj)->klass(); |
1482 jclass ret = |
1298 jclass ret = |
1483 (jclass) JNIHandles::make_local(env, k->java_mirror()); |
1299 (jclass) JNIHandles::make_local(env, k->java_mirror()); |
1484 #ifndef USDT2 |
1300 |
1485 DTRACE_PROBE1(hotspot_jni, GetObjectClass__return, ret); |
|
1486 #else /* USDT2 */ |
|
1487 HOTSPOT_JNI_GETOBJECTCLASS_RETURN(ret); |
1301 HOTSPOT_JNI_GETOBJECTCLASS_RETURN(ret); |
1488 #endif /* USDT2 */ |
|
1489 return ret; |
1302 return ret; |
1490 JNI_END |
1303 JNI_END |
1491 |
1304 |
1492 JNI_QUICK_ENTRY(jboolean, jni_IsInstanceOf(JNIEnv *env, jobject obj, jclass clazz)) |
1305 JNI_QUICK_ENTRY(jboolean, jni_IsInstanceOf(JNIEnv *env, jobject obj, jclass clazz)) |
1493 JNIWrapper("IsInstanceOf"); |
1306 JNIWrapper("IsInstanceOf"); |
1494 #ifndef USDT2 |
1307 |
1495 DTRACE_PROBE3(hotspot_jni, IsInstanceOf__entry, env, obj, clazz); |
|
1496 #else /* USDT2 */ |
|
1497 HOTSPOT_JNI_ISINSTANCEOF_ENTRY(env, obj, clazz); |
1308 HOTSPOT_JNI_ISINSTANCEOF_ENTRY(env, obj, clazz); |
1498 #endif /* USDT2 */ |
1309 |
1499 jboolean ret = JNI_TRUE; |
1310 jboolean ret = JNI_TRUE; |
1500 if (obj != NULL) { |
1311 if (obj != NULL) { |
1501 ret = JNI_FALSE; |
1312 ret = JNI_FALSE; |
1502 Klass* k = java_lang_Class::as_Klass( |
1313 Klass* k = java_lang_Class::as_Klass( |
1503 JNIHandles::resolve_non_null(clazz)); |
1314 JNIHandles::resolve_non_null(clazz)); |
1504 if (k != NULL) { |
1315 if (k != NULL) { |
1505 ret = JNIHandles::resolve_non_null(obj)->is_a(k) ? JNI_TRUE : JNI_FALSE; |
1316 ret = JNIHandles::resolve_non_null(obj)->is_a(k) ? JNI_TRUE : JNI_FALSE; |
1506 } |
1317 } |
1507 } |
1318 } |
1508 #ifndef USDT2 |
1319 |
1509 DTRACE_PROBE1(hotspot_jni, IsInstanceOf__return, ret); |
|
1510 #else /* USDT2 */ |
|
1511 HOTSPOT_JNI_ISINSTANCEOF_RETURN(ret); |
1320 HOTSPOT_JNI_ISINSTANCEOF_RETURN(ret); |
1512 #endif /* USDT2 */ |
|
1513 return ret; |
1321 return ret; |
1514 JNI_END |
1322 JNI_END |
1515 |
1323 |
1516 |
1324 |
1517 static jmethodID get_method_id(JNIEnv *env, jclass clazz, const char *name_str, |
1325 static jmethodID get_method_id(JNIEnv *env, jclass clazz, const char *name_str, |
1567 |
1375 |
1568 |
1376 |
1569 JNI_ENTRY(jmethodID, jni_GetMethodID(JNIEnv *env, jclass clazz, |
1377 JNI_ENTRY(jmethodID, jni_GetMethodID(JNIEnv *env, jclass clazz, |
1570 const char *name, const char *sig)) |
1378 const char *name, const char *sig)) |
1571 JNIWrapper("GetMethodID"); |
1379 JNIWrapper("GetMethodID"); |
1572 #ifndef USDT2 |
|
1573 DTRACE_PROBE4(hotspot_jni, GetMethodID__entry, env, clazz, name, sig); |
|
1574 #else /* USDT2 */ |
|
1575 HOTSPOT_JNI_GETMETHODID_ENTRY(env, clazz, (char *) name, (char *) sig); |
1380 HOTSPOT_JNI_GETMETHODID_ENTRY(env, clazz, (char *) name, (char *) sig); |
1576 #endif /* USDT2 */ |
|
1577 jmethodID ret = get_method_id(env, clazz, name, sig, false, thread); |
1381 jmethodID ret = get_method_id(env, clazz, name, sig, false, thread); |
1578 #ifndef USDT2 |
|
1579 DTRACE_PROBE1(hotspot_jni, GetMethodID__return, ret); |
|
1580 #else /* USDT2 */ |
|
1581 HOTSPOT_JNI_GETMETHODID_RETURN((uintptr_t) ret); |
1382 HOTSPOT_JNI_GETMETHODID_RETURN((uintptr_t) ret); |
1582 #endif /* USDT2 */ |
|
1583 return ret; |
1383 return ret; |
1584 JNI_END |
1384 JNI_END |
1585 |
1385 |
1586 |
1386 |
1587 JNI_ENTRY(jmethodID, jni_GetStaticMethodID(JNIEnv *env, jclass clazz, |
1387 JNI_ENTRY(jmethodID, jni_GetStaticMethodID(JNIEnv *env, jclass clazz, |
1588 const char *name, const char *sig)) |
1388 const char *name, const char *sig)) |
1589 JNIWrapper("GetStaticMethodID"); |
1389 JNIWrapper("GetStaticMethodID"); |
1590 #ifndef USDT2 |
|
1591 DTRACE_PROBE4(hotspot_jni, GetStaticMethodID__entry, env, clazz, name, sig); |
|
1592 #else /* USDT2 */ |
|
1593 HOTSPOT_JNI_GETSTATICMETHODID_ENTRY(env, (char *) clazz, (char *) name, (char *)sig); |
1390 HOTSPOT_JNI_GETSTATICMETHODID_ENTRY(env, (char *) clazz, (char *) name, (char *)sig); |
1594 #endif /* USDT2 */ |
|
1595 jmethodID ret = get_method_id(env, clazz, name, sig, true, thread); |
1391 jmethodID ret = get_method_id(env, clazz, name, sig, true, thread); |
1596 #ifndef USDT2 |
|
1597 DTRACE_PROBE1(hotspot_jni, GetStaticMethodID__return, ret); |
|
1598 #else /* USDT2 */ |
|
1599 HOTSPOT_JNI_GETSTATICMETHODID_RETURN((uintptr_t) ret); |
1392 HOTSPOT_JNI_GETSTATICMETHODID_RETURN((uintptr_t) ret); |
1600 #endif /* USDT2 */ |
|
1601 return ret; |
1393 return ret; |
1602 JNI_END |
1394 JNI_END |
1603 |
1395 |
1604 |
1396 |
1605 |
1397 |
1606 // |
1398 // |
1607 // Calling Methods |
1399 // Calling Methods |
1608 // |
1400 // |
1609 |
1401 |
1610 #ifndef USDT2 |
|
1611 #define DEFINE_CALLMETHOD(ResultType, Result, Tag) \ |
|
1612 \ |
|
1613 DT_RETURN_MARK_DECL_FOR(Result, Call##Result##Method, ResultType);\ |
|
1614 DT_RETURN_MARK_DECL_FOR(Result, Call##Result##MethodV, ResultType);\ |
|
1615 DT_RETURN_MARK_DECL_FOR(Result, Call##Result##MethodA, ResultType);\ |
|
1616 \ |
|
1617 JNI_ENTRY(ResultType, \ |
|
1618 jni_Call##Result##Method(JNIEnv *env, jobject obj, jmethodID methodID, ...)) \ |
|
1619 JNIWrapper("Call" XSTR(Result) "Method"); \ |
|
1620 \ |
|
1621 DTRACE_PROBE3(hotspot_jni, Call##Result##Method__entry, env, obj, methodID); \ |
|
1622 ResultType ret = 0;\ |
|
1623 DT_RETURN_MARK_FOR(Result, Call##Result##Method, ResultType, \ |
|
1624 (const ResultType&)ret);\ |
|
1625 \ |
|
1626 va_list args; \ |
|
1627 va_start(args, methodID); \ |
|
1628 JavaValue jvalue(Tag); \ |
|
1629 JNI_ArgumentPusherVaArg ap(methodID, args); \ |
|
1630 jni_invoke_nonstatic(env, &jvalue, obj, JNI_VIRTUAL, methodID, &ap, CHECK_0); \ |
|
1631 va_end(args); \ |
|
1632 ret = jvalue.get_##ResultType(); \ |
|
1633 return ret;\ |
|
1634 JNI_END \ |
|
1635 \ |
|
1636 \ |
|
1637 JNI_ENTRY(ResultType, \ |
|
1638 jni_Call##Result##MethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)) \ |
|
1639 JNIWrapper("Call" XSTR(Result) "MethodV"); \ |
|
1640 \ |
|
1641 DTRACE_PROBE3(hotspot_jni, Call##Result##MethodV__entry, env, obj, methodID); \ |
|
1642 ResultType ret = 0;\ |
|
1643 DT_RETURN_MARK_FOR(Result, Call##Result##MethodV, ResultType, \ |
|
1644 (const ResultType&)ret);\ |
|
1645 \ |
|
1646 JavaValue jvalue(Tag); \ |
|
1647 JNI_ArgumentPusherVaArg ap(methodID, args); \ |
|
1648 jni_invoke_nonstatic(env, &jvalue, obj, JNI_VIRTUAL, methodID, &ap, CHECK_0); \ |
|
1649 ret = jvalue.get_##ResultType(); \ |
|
1650 return ret;\ |
|
1651 JNI_END \ |
|
1652 \ |
|
1653 \ |
|
1654 JNI_ENTRY(ResultType, \ |
|
1655 jni_Call##Result##MethodA(JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args)) \ |
|
1656 JNIWrapper("Call" XSTR(Result) "MethodA"); \ |
|
1657 DTRACE_PROBE3(hotspot_jni, Call##Result##MethodA__entry, env, obj, methodID); \ |
|
1658 ResultType ret = 0;\ |
|
1659 DT_RETURN_MARK_FOR(Result, Call##Result##MethodA, ResultType, \ |
|
1660 (const ResultType&)ret);\ |
|
1661 \ |
|
1662 JavaValue jvalue(Tag); \ |
|
1663 JNI_ArgumentPusherArray ap(methodID, args); \ |
|
1664 jni_invoke_nonstatic(env, &jvalue, obj, JNI_VIRTUAL, methodID, &ap, CHECK_0); \ |
|
1665 ret = jvalue.get_##ResultType(); \ |
|
1666 return ret;\ |
|
1667 JNI_END |
|
1668 |
|
1669 // the runtime type of subword integral basic types is integer |
|
1670 DEFINE_CALLMETHOD(jboolean, Boolean, T_BOOLEAN) |
|
1671 DEFINE_CALLMETHOD(jbyte, Byte, T_BYTE) |
|
1672 DEFINE_CALLMETHOD(jchar, Char, T_CHAR) |
|
1673 DEFINE_CALLMETHOD(jshort, Short, T_SHORT) |
|
1674 |
|
1675 DEFINE_CALLMETHOD(jobject, Object, T_OBJECT) |
|
1676 DEFINE_CALLMETHOD(jint, Int, T_INT) |
|
1677 DEFINE_CALLMETHOD(jlong, Long, T_LONG) |
|
1678 DEFINE_CALLMETHOD(jfloat, Float, T_FLOAT) |
|
1679 DEFINE_CALLMETHOD(jdouble, Double, T_DOUBLE) |
|
1680 |
|
1681 DT_VOID_RETURN_MARK_DECL(CallVoidMethod); |
|
1682 DT_VOID_RETURN_MARK_DECL(CallVoidMethodV); |
|
1683 DT_VOID_RETURN_MARK_DECL(CallVoidMethodA); |
|
1684 |
|
1685 #else /* USDT2 */ |
|
1686 |
1402 |
1687 #define DEFINE_CALLMETHOD(ResultType, Result, Tag \ |
1403 #define DEFINE_CALLMETHOD(ResultType, Result, Tag \ |
1688 , EntryProbe, ReturnProbe) \ |
1404 , EntryProbe, ReturnProbe) \ |
1689 \ |
1405 \ |
1690 DT_RETURN_MARK_DECL_FOR(Result, Call##Result##Method, ResultType \ |
1406 DT_RETURN_MARK_DECL_FOR(Result, Call##Result##Method, ResultType \ |
1869 JNI_END |
1580 JNI_END |
1870 |
1581 |
1871 |
1582 |
1872 JNI_ENTRY(void, jni_CallVoidMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)) |
1583 JNI_ENTRY(void, jni_CallVoidMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)) |
1873 JNIWrapper("CallVoidMethodV"); |
1584 JNIWrapper("CallVoidMethodV"); |
1874 #ifndef USDT2 |
|
1875 DTRACE_PROBE3(hotspot_jni, CallVoidMethodV__entry, env, obj, methodID); |
|
1876 #else /* USDT2 */ |
|
1877 HOTSPOT_JNI_CALLVOIDMETHODV_ENTRY(env, obj, (uintptr_t) methodID); |
1585 HOTSPOT_JNI_CALLVOIDMETHODV_ENTRY(env, obj, (uintptr_t) methodID); |
1878 #endif /* USDT2 */ |
|
1879 DT_VOID_RETURN_MARK(CallVoidMethodV); |
1586 DT_VOID_RETURN_MARK(CallVoidMethodV); |
1880 |
1587 |
1881 JavaValue jvalue(T_VOID); |
1588 JavaValue jvalue(T_VOID); |
1882 JNI_ArgumentPusherVaArg ap(methodID, args); |
1589 JNI_ArgumentPusherVaArg ap(methodID, args); |
1883 jni_invoke_nonstatic(env, &jvalue, obj, JNI_VIRTUAL, methodID, &ap, CHECK); |
1590 jni_invoke_nonstatic(env, &jvalue, obj, JNI_VIRTUAL, methodID, &ap, CHECK); |
1884 JNI_END |
1591 JNI_END |
1885 |
1592 |
1886 |
1593 |
1887 JNI_ENTRY(void, jni_CallVoidMethodA(JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args)) |
1594 JNI_ENTRY(void, jni_CallVoidMethodA(JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args)) |
1888 JNIWrapper("CallVoidMethodA"); |
1595 JNIWrapper("CallVoidMethodA"); |
1889 #ifndef USDT2 |
|
1890 DTRACE_PROBE3(hotspot_jni, CallVoidMethodA__entry, env, obj, methodID); |
|
1891 #else /* USDT2 */ |
|
1892 HOTSPOT_JNI_CALLVOIDMETHODA_ENTRY(env, obj, (uintptr_t) methodID); |
1596 HOTSPOT_JNI_CALLVOIDMETHODA_ENTRY(env, obj, (uintptr_t) methodID); |
1893 #endif /* USDT2 */ |
|
1894 DT_VOID_RETURN_MARK(CallVoidMethodA); |
1597 DT_VOID_RETURN_MARK(CallVoidMethodA); |
1895 |
1598 |
1896 JavaValue jvalue(T_VOID); |
1599 JavaValue jvalue(T_VOID); |
1897 JNI_ArgumentPusherArray ap(methodID, args); |
1600 JNI_ArgumentPusherArray ap(methodID, args); |
1898 jni_invoke_nonstatic(env, &jvalue, obj, JNI_VIRTUAL, methodID, &ap, CHECK); |
1601 jni_invoke_nonstatic(env, &jvalue, obj, JNI_VIRTUAL, methodID, &ap, CHECK); |
1899 JNI_END |
1602 JNI_END |
1900 |
1603 |
1901 |
1604 |
1902 #ifndef USDT2 |
|
1903 #define DEFINE_CALLNONVIRTUALMETHOD(ResultType, Result, Tag) \ |
|
1904 \ |
|
1905 DT_RETURN_MARK_DECL_FOR(Result, CallNonvirtual##Result##Method, ResultType);\ |
|
1906 DT_RETURN_MARK_DECL_FOR(Result, CallNonvirtual##Result##MethodV, ResultType);\ |
|
1907 DT_RETURN_MARK_DECL_FOR(Result, CallNonvirtual##Result##MethodA, ResultType);\ |
|
1908 \ |
|
1909 JNI_ENTRY(ResultType, \ |
|
1910 jni_CallNonvirtual##Result##Method(JNIEnv *env, jobject obj, jclass cls, jmethodID methodID, ...)) \ |
|
1911 JNIWrapper("CallNonvitual" XSTR(Result) "Method"); \ |
|
1912 \ |
|
1913 DTRACE_PROBE4(hotspot_jni, CallNonvirtual##Result##Method__entry, env, obj, cls, methodID);\ |
|
1914 ResultType ret;\ |
|
1915 DT_RETURN_MARK_FOR(Result, CallNonvirtual##Result##Method, ResultType, \ |
|
1916 (const ResultType&)ret);\ |
|
1917 \ |
|
1918 va_list args; \ |
|
1919 va_start(args, methodID); \ |
|
1920 JavaValue jvalue(Tag); \ |
|
1921 JNI_ArgumentPusherVaArg ap(methodID, args); \ |
|
1922 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK_0); \ |
|
1923 va_end(args); \ |
|
1924 ret = jvalue.get_##ResultType(); \ |
|
1925 return ret;\ |
|
1926 JNI_END \ |
|
1927 \ |
|
1928 JNI_ENTRY(ResultType, \ |
|
1929 jni_CallNonvirtual##Result##MethodV(JNIEnv *env, jobject obj, jclass cls, jmethodID methodID, va_list args)) \ |
|
1930 JNIWrapper("CallNonvitual" XSTR(Result) "#MethodV"); \ |
|
1931 DTRACE_PROBE4(hotspot_jni, CallNonvirtual##Result##MethodV__entry, env, obj, cls, methodID);\ |
|
1932 ResultType ret;\ |
|
1933 DT_RETURN_MARK_FOR(Result, CallNonvirtual##Result##MethodV, ResultType, \ |
|
1934 (const ResultType&)ret);\ |
|
1935 \ |
|
1936 JavaValue jvalue(Tag); \ |
|
1937 JNI_ArgumentPusherVaArg ap(methodID, args); \ |
|
1938 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK_0); \ |
|
1939 ret = jvalue.get_##ResultType(); \ |
|
1940 return ret;\ |
|
1941 JNI_END \ |
|
1942 \ |
|
1943 JNI_ENTRY(ResultType, \ |
|
1944 jni_CallNonvirtual##Result##MethodA(JNIEnv *env, jobject obj, jclass cls, jmethodID methodID, const jvalue *args)) \ |
|
1945 JNIWrapper("CallNonvitual" XSTR(Result) "MethodA"); \ |
|
1946 DTRACE_PROBE4(hotspot_jni, CallNonvirtual##Result##MethodA__entry, env, obj, cls, methodID);\ |
|
1947 ResultType ret;\ |
|
1948 DT_RETURN_MARK_FOR(Result, CallNonvirtual##Result##MethodA, ResultType, \ |
|
1949 (const ResultType&)ret);\ |
|
1950 \ |
|
1951 JavaValue jvalue(Tag); \ |
|
1952 JNI_ArgumentPusherArray ap(methodID, args); \ |
|
1953 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK_0); \ |
|
1954 ret = jvalue.get_##ResultType(); \ |
|
1955 return ret;\ |
|
1956 JNI_END |
|
1957 |
|
1958 // the runtime type of subword integral basic types is integer |
|
1959 DEFINE_CALLNONVIRTUALMETHOD(jboolean, Boolean, T_BOOLEAN) |
|
1960 DEFINE_CALLNONVIRTUALMETHOD(jbyte, Byte, T_BYTE) |
|
1961 DEFINE_CALLNONVIRTUALMETHOD(jchar, Char, T_CHAR) |
|
1962 DEFINE_CALLNONVIRTUALMETHOD(jshort, Short, T_SHORT) |
|
1963 |
|
1964 DEFINE_CALLNONVIRTUALMETHOD(jobject, Object, T_OBJECT) |
|
1965 DEFINE_CALLNONVIRTUALMETHOD(jint, Int, T_INT) |
|
1966 DEFINE_CALLNONVIRTUALMETHOD(jlong, Long, T_LONG) |
|
1967 DEFINE_CALLNONVIRTUALMETHOD(jfloat, Float, T_FLOAT) |
|
1968 DEFINE_CALLNONVIRTUALMETHOD(jdouble, Double, T_DOUBLE) |
|
1969 |
|
1970 |
|
1971 DT_VOID_RETURN_MARK_DECL(CallNonvirtualVoidMethod); |
|
1972 DT_VOID_RETURN_MARK_DECL(CallNonvirtualVoidMethodV); |
|
1973 DT_VOID_RETURN_MARK_DECL(CallNonvirtualVoidMethodA); |
|
1974 |
|
1975 #else /* USDT2 */ |
|
1976 |
1605 |
1977 #define DEFINE_CALLNONVIRTUALMETHOD(ResultType, Result, Tag \ |
1606 #define DEFINE_CALLNONVIRTUALMETHOD(ResultType, Result, Tag \ |
1978 , EntryProbe, ReturnProbe) \ |
1607 , EntryProbe, ReturnProbe) \ |
1979 \ |
1608 \ |
1980 DT_RETURN_MARK_DECL_FOR(Result, CallNonvirtual##Result##Method, ResultType \ |
1609 DT_RETURN_MARK_DECL_FOR(Result, CallNonvirtual##Result##Method, ResultType \ |
2140 , HOTSPOT_JNI_CALLNONVIRTUALVOIDMETHOD_RETURN()); |
1769 , HOTSPOT_JNI_CALLNONVIRTUALVOIDMETHOD_RETURN()); |
2141 DT_VOID_RETURN_MARK_DECL(CallNonvirtualVoidMethodV |
1770 DT_VOID_RETURN_MARK_DECL(CallNonvirtualVoidMethodV |
2142 , HOTSPOT_JNI_CALLNONVIRTUALVOIDMETHODV_RETURN()); |
1771 , HOTSPOT_JNI_CALLNONVIRTUALVOIDMETHODV_RETURN()); |
2143 DT_VOID_RETURN_MARK_DECL(CallNonvirtualVoidMethodA |
1772 DT_VOID_RETURN_MARK_DECL(CallNonvirtualVoidMethodA |
2144 , HOTSPOT_JNI_CALLNONVIRTUALVOIDMETHODA_RETURN()); |
1773 , HOTSPOT_JNI_CALLNONVIRTUALVOIDMETHODA_RETURN()); |
2145 #endif /* USDT2 */ |
|
2146 |
1774 |
2147 JNI_ENTRY(void, jni_CallNonvirtualVoidMethod(JNIEnv *env, jobject obj, jclass cls, jmethodID methodID, ...)) |
1775 JNI_ENTRY(void, jni_CallNonvirtualVoidMethod(JNIEnv *env, jobject obj, jclass cls, jmethodID methodID, ...)) |
2148 JNIWrapper("CallNonvirtualVoidMethod"); |
1776 JNIWrapper("CallNonvirtualVoidMethod"); |
2149 |
1777 |
2150 #ifndef USDT2 |
|
2151 DTRACE_PROBE4(hotspot_jni, CallNonvirtualVoidMethod__entry, |
|
2152 env, obj, cls, methodID); |
|
2153 #else /* USDT2 */ |
|
2154 HOTSPOT_JNI_CALLNONVIRTUALVOIDMETHOD_ENTRY(env, obj, cls, (uintptr_t) methodID); |
1778 HOTSPOT_JNI_CALLNONVIRTUALVOIDMETHOD_ENTRY(env, obj, cls, (uintptr_t) methodID); |
2155 #endif /* USDT2 */ |
|
2156 DT_VOID_RETURN_MARK(CallNonvirtualVoidMethod); |
1779 DT_VOID_RETURN_MARK(CallNonvirtualVoidMethod); |
2157 |
1780 |
2158 va_list args; |
1781 va_list args; |
2159 va_start(args, methodID); |
1782 va_start(args, methodID); |
2160 JavaValue jvalue(T_VOID); |
1783 JavaValue jvalue(T_VOID); |
2165 |
1788 |
2166 |
1789 |
2167 JNI_ENTRY(void, jni_CallNonvirtualVoidMethodV(JNIEnv *env, jobject obj, jclass cls, jmethodID methodID, va_list args)) |
1790 JNI_ENTRY(void, jni_CallNonvirtualVoidMethodV(JNIEnv *env, jobject obj, jclass cls, jmethodID methodID, va_list args)) |
2168 JNIWrapper("CallNonvirtualVoidMethodV"); |
1791 JNIWrapper("CallNonvirtualVoidMethodV"); |
2169 |
1792 |
2170 #ifndef USDT2 |
|
2171 DTRACE_PROBE4(hotspot_jni, CallNonvirtualVoidMethodV__entry, |
|
2172 env, obj, cls, methodID); |
|
2173 #else /* USDT2 */ |
|
2174 HOTSPOT_JNI_CALLNONVIRTUALVOIDMETHODV_ENTRY( |
1793 HOTSPOT_JNI_CALLNONVIRTUALVOIDMETHODV_ENTRY( |
2175 env, obj, cls, (uintptr_t) methodID); |
1794 env, obj, cls, (uintptr_t) methodID); |
2176 #endif /* USDT2 */ |
|
2177 DT_VOID_RETURN_MARK(CallNonvirtualVoidMethodV); |
1795 DT_VOID_RETURN_MARK(CallNonvirtualVoidMethodV); |
2178 |
1796 |
2179 JavaValue jvalue(T_VOID); |
1797 JavaValue jvalue(T_VOID); |
2180 JNI_ArgumentPusherVaArg ap(methodID, args); |
1798 JNI_ArgumentPusherVaArg ap(methodID, args); |
2181 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK); |
1799 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK); |
2182 JNI_END |
1800 JNI_END |
2183 |
1801 |
2184 |
1802 |
2185 JNI_ENTRY(void, jni_CallNonvirtualVoidMethodA(JNIEnv *env, jobject obj, jclass cls, jmethodID methodID, const jvalue *args)) |
1803 JNI_ENTRY(void, jni_CallNonvirtualVoidMethodA(JNIEnv *env, jobject obj, jclass cls, jmethodID methodID, const jvalue *args)) |
2186 JNIWrapper("CallNonvirtualVoidMethodA"); |
1804 JNIWrapper("CallNonvirtualVoidMethodA"); |
2187 #ifndef USDT2 |
|
2188 DTRACE_PROBE4(hotspot_jni, CallNonvirtualVoidMethodA__entry, |
|
2189 env, obj, cls, methodID); |
|
2190 #else /* USDT2 */ |
|
2191 HOTSPOT_JNI_CALLNONVIRTUALVOIDMETHODA_ENTRY( |
1805 HOTSPOT_JNI_CALLNONVIRTUALVOIDMETHODA_ENTRY( |
2192 env, obj, cls, (uintptr_t) methodID); |
1806 env, obj, cls, (uintptr_t) methodID); |
2193 #endif /* USDT2 */ |
|
2194 DT_VOID_RETURN_MARK(CallNonvirtualVoidMethodA); |
1807 DT_VOID_RETURN_MARK(CallNonvirtualVoidMethodA); |
2195 JavaValue jvalue(T_VOID); |
1808 JavaValue jvalue(T_VOID); |
2196 JNI_ArgumentPusherArray ap(methodID, args); |
1809 JNI_ArgumentPusherArray ap(methodID, args); |
2197 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK); |
1810 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK); |
2198 JNI_END |
1811 JNI_END |
2199 |
1812 |
2200 |
1813 |
2201 #ifndef USDT2 |
|
2202 #define DEFINE_CALLSTATICMETHOD(ResultType, Result, Tag) \ |
|
2203 \ |
|
2204 DT_RETURN_MARK_DECL_FOR(Result, CallStatic##Result##Method, ResultType);\ |
|
2205 DT_RETURN_MARK_DECL_FOR(Result, CallStatic##Result##MethodV, ResultType);\ |
|
2206 DT_RETURN_MARK_DECL_FOR(Result, CallStatic##Result##MethodA, ResultType);\ |
|
2207 \ |
|
2208 JNI_ENTRY(ResultType, \ |
|
2209 jni_CallStatic##Result##Method(JNIEnv *env, jclass cls, jmethodID methodID, ...)) \ |
|
2210 JNIWrapper("CallStatic" XSTR(Result) "Method"); \ |
|
2211 \ |
|
2212 DTRACE_PROBE3(hotspot_jni, CallStatic##Result##Method__entry, env, cls, methodID);\ |
|
2213 ResultType ret = 0;\ |
|
2214 DT_RETURN_MARK_FOR(Result, CallStatic##Result##Method, ResultType, \ |
|
2215 (const ResultType&)ret);\ |
|
2216 \ |
|
2217 va_list args; \ |
|
2218 va_start(args, methodID); \ |
|
2219 JavaValue jvalue(Tag); \ |
|
2220 JNI_ArgumentPusherVaArg ap(methodID, args); \ |
|
2221 jni_invoke_static(env, &jvalue, NULL, JNI_STATIC, methodID, &ap, CHECK_0); \ |
|
2222 va_end(args); \ |
|
2223 ret = jvalue.get_##ResultType(); \ |
|
2224 return ret;\ |
|
2225 JNI_END \ |
|
2226 \ |
|
2227 JNI_ENTRY(ResultType, \ |
|
2228 jni_CallStatic##Result##MethodV(JNIEnv *env, jclass cls, jmethodID methodID, va_list args)) \ |
|
2229 JNIWrapper("CallStatic" XSTR(Result) "MethodV"); \ |
|
2230 DTRACE_PROBE3(hotspot_jni, CallStatic##Result##MethodV__entry, env, cls, methodID);\ |
|
2231 ResultType ret = 0;\ |
|
2232 DT_RETURN_MARK_FOR(Result, CallStatic##Result##MethodV, ResultType, \ |
|
2233 (const ResultType&)ret);\ |
|
2234 \ |
|
2235 JavaValue jvalue(Tag); \ |
|
2236 JNI_ArgumentPusherVaArg ap(methodID, args); \ |
|
2237 jni_invoke_static(env, &jvalue, NULL, JNI_STATIC, methodID, &ap, CHECK_0); \ |
|
2238 ret = jvalue.get_##ResultType(); \ |
|
2239 return ret;\ |
|
2240 JNI_END \ |
|
2241 \ |
|
2242 JNI_ENTRY(ResultType, \ |
|
2243 jni_CallStatic##Result##MethodA(JNIEnv *env, jclass cls, jmethodID methodID, const jvalue *args)) \ |
|
2244 JNIWrapper("CallStatic" XSTR(Result) "MethodA"); \ |
|
2245 DTRACE_PROBE3(hotspot_jni, CallStatic##Result##MethodA__entry, env, cls, methodID);\ |
|
2246 ResultType ret = 0;\ |
|
2247 DT_RETURN_MARK_FOR(Result, CallStatic##Result##MethodA, ResultType, \ |
|
2248 (const ResultType&)ret);\ |
|
2249 \ |
|
2250 JavaValue jvalue(Tag); \ |
|
2251 JNI_ArgumentPusherArray ap(methodID, args); \ |
|
2252 jni_invoke_static(env, &jvalue, NULL, JNI_STATIC, methodID, &ap, CHECK_0); \ |
|
2253 ret = jvalue.get_##ResultType(); \ |
|
2254 return ret;\ |
|
2255 JNI_END |
|
2256 |
|
2257 // the runtime type of subword integral basic types is integer |
|
2258 DEFINE_CALLSTATICMETHOD(jboolean, Boolean, T_BOOLEAN) |
|
2259 DEFINE_CALLSTATICMETHOD(jbyte, Byte, T_BYTE) |
|
2260 DEFINE_CALLSTATICMETHOD(jchar, Char, T_CHAR) |
|
2261 DEFINE_CALLSTATICMETHOD(jshort, Short, T_SHORT) |
|
2262 |
|
2263 DEFINE_CALLSTATICMETHOD(jobject, Object, T_OBJECT) |
|
2264 DEFINE_CALLSTATICMETHOD(jint, Int, T_INT) |
|
2265 DEFINE_CALLSTATICMETHOD(jlong, Long, T_LONG) |
|
2266 DEFINE_CALLSTATICMETHOD(jfloat, Float, T_FLOAT) |
|
2267 DEFINE_CALLSTATICMETHOD(jdouble, Double, T_DOUBLE) |
|
2268 |
|
2269 |
|
2270 DT_VOID_RETURN_MARK_DECL(CallStaticVoidMethod); |
|
2271 DT_VOID_RETURN_MARK_DECL(CallStaticVoidMethodV); |
|
2272 DT_VOID_RETURN_MARK_DECL(CallStaticVoidMethodA); |
|
2273 |
|
2274 #else /* USDT2 */ |
|
2275 |
1814 |
2276 #define DEFINE_CALLSTATICMETHOD(ResultType, Result, Tag \ |
1815 #define DEFINE_CALLSTATICMETHOD(ResultType, Result, Tag \ |
2277 , EntryProbe, ResultProbe) \ |
1816 , EntryProbe, ResultProbe) \ |
2278 \ |
1817 \ |
2279 DT_RETURN_MARK_DECL_FOR(Result, CallStatic##Result##Method, ResultType \ |
1818 DT_RETURN_MARK_DECL_FOR(Result, CallStatic##Result##Method, ResultType \ |
2443 , HOTSPOT_JNI_CALLSTATICVOIDMETHOD_RETURN()); |
1982 , HOTSPOT_JNI_CALLSTATICVOIDMETHOD_RETURN()); |
2444 DT_VOID_RETURN_MARK_DECL(CallStaticVoidMethodV |
1983 DT_VOID_RETURN_MARK_DECL(CallStaticVoidMethodV |
2445 , HOTSPOT_JNI_CALLSTATICVOIDMETHODV_RETURN()); |
1984 , HOTSPOT_JNI_CALLSTATICVOIDMETHODV_RETURN()); |
2446 DT_VOID_RETURN_MARK_DECL(CallStaticVoidMethodA |
1985 DT_VOID_RETURN_MARK_DECL(CallStaticVoidMethodA |
2447 , HOTSPOT_JNI_CALLSTATICVOIDMETHODA_RETURN()); |
1986 , HOTSPOT_JNI_CALLSTATICVOIDMETHODA_RETURN()); |
2448 #endif /* USDT2 */ |
|
2449 |
1987 |
2450 JNI_ENTRY(void, jni_CallStaticVoidMethod(JNIEnv *env, jclass cls, jmethodID methodID, ...)) |
1988 JNI_ENTRY(void, jni_CallStaticVoidMethod(JNIEnv *env, jclass cls, jmethodID methodID, ...)) |
2451 JNIWrapper("CallStaticVoidMethod"); |
1989 JNIWrapper("CallStaticVoidMethod"); |
2452 #ifndef USDT2 |
|
2453 DTRACE_PROBE3(hotspot_jni, CallStaticVoidMethod__entry, env, cls, methodID); |
|
2454 #else /* USDT2 */ |
|
2455 HOTSPOT_JNI_CALLSTATICVOIDMETHOD_ENTRY(env, cls, (uintptr_t) methodID); |
1990 HOTSPOT_JNI_CALLSTATICVOIDMETHOD_ENTRY(env, cls, (uintptr_t) methodID); |
2456 #endif /* USDT2 */ |
|
2457 DT_VOID_RETURN_MARK(CallStaticVoidMethod); |
1991 DT_VOID_RETURN_MARK(CallStaticVoidMethod); |
2458 |
1992 |
2459 va_list args; |
1993 va_list args; |
2460 va_start(args, methodID); |
1994 va_start(args, methodID); |
2461 JavaValue jvalue(T_VOID); |
1995 JavaValue jvalue(T_VOID); |
2465 JNI_END |
1999 JNI_END |
2466 |
2000 |
2467 |
2001 |
2468 JNI_ENTRY(void, jni_CallStaticVoidMethodV(JNIEnv *env, jclass cls, jmethodID methodID, va_list args)) |
2002 JNI_ENTRY(void, jni_CallStaticVoidMethodV(JNIEnv *env, jclass cls, jmethodID methodID, va_list args)) |
2469 JNIWrapper("CallStaticVoidMethodV"); |
2003 JNIWrapper("CallStaticVoidMethodV"); |
2470 #ifndef USDT2 |
|
2471 DTRACE_PROBE3(hotspot_jni, CallStaticVoidMethodV__entry, env, cls, methodID); |
|
2472 #else /* USDT2 */ |
|
2473 HOTSPOT_JNI_CALLSTATICVOIDMETHODV_ENTRY(env, cls, (uintptr_t) methodID); |
2004 HOTSPOT_JNI_CALLSTATICVOIDMETHODV_ENTRY(env, cls, (uintptr_t) methodID); |
2474 #endif /* USDT2 */ |
|
2475 DT_VOID_RETURN_MARK(CallStaticVoidMethodV); |
2005 DT_VOID_RETURN_MARK(CallStaticVoidMethodV); |
2476 |
2006 |
2477 JavaValue jvalue(T_VOID); |
2007 JavaValue jvalue(T_VOID); |
2478 JNI_ArgumentPusherVaArg ap(methodID, args); |
2008 JNI_ArgumentPusherVaArg ap(methodID, args); |
2479 jni_invoke_static(env, &jvalue, NULL, JNI_STATIC, methodID, &ap, CHECK); |
2009 jni_invoke_static(env, &jvalue, NULL, JNI_STATIC, methodID, &ap, CHECK); |
2480 JNI_END |
2010 JNI_END |
2481 |
2011 |
2482 |
2012 |
2483 JNI_ENTRY(void, jni_CallStaticVoidMethodA(JNIEnv *env, jclass cls, jmethodID methodID, const jvalue *args)) |
2013 JNI_ENTRY(void, jni_CallStaticVoidMethodA(JNIEnv *env, jclass cls, jmethodID methodID, const jvalue *args)) |
2484 JNIWrapper("CallStaticVoidMethodA"); |
2014 JNIWrapper("CallStaticVoidMethodA"); |
2485 #ifndef USDT2 |
|
2486 DTRACE_PROBE3(hotspot_jni, CallStaticVoidMethodA__entry, env, cls, methodID); |
|
2487 #else /* USDT2 */ |
|
2488 HOTSPOT_JNI_CALLSTATICVOIDMETHODA_ENTRY(env, cls, (uintptr_t) methodID); |
2015 HOTSPOT_JNI_CALLSTATICVOIDMETHODA_ENTRY(env, cls, (uintptr_t) methodID); |
2489 #endif /* USDT2 */ |
|
2490 DT_VOID_RETURN_MARK(CallStaticVoidMethodA); |
2016 DT_VOID_RETURN_MARK(CallStaticVoidMethodA); |
2491 |
2017 |
2492 JavaValue jvalue(T_VOID); |
2018 JavaValue jvalue(T_VOID); |
2493 JNI_ArgumentPusherArray ap(methodID, args); |
2019 JNI_ArgumentPusherArray ap(methodID, args); |
2494 jni_invoke_static(env, &jvalue, NULL, JNI_STATIC, methodID, &ap, CHECK); |
2020 jni_invoke_static(env, &jvalue, NULL, JNI_STATIC, methodID, &ap, CHECK); |
2578 oop referent = JNIHandles::resolve(ret); |
2092 oop referent = JNIHandles::resolve(ret); |
2579 G1SATBCardTableModRefBS::enqueue(referent); |
2093 G1SATBCardTableModRefBS::enqueue(referent); |
2580 } |
2094 } |
2581 } |
2095 } |
2582 #endif // INCLUDE_ALL_GCS |
2096 #endif // INCLUDE_ALL_GCS |
2583 #ifndef USDT2 |
|
2584 DTRACE_PROBE1(hotspot_jni, GetObjectField__return, ret); |
|
2585 #else /* USDT2 */ |
|
2586 HOTSPOT_JNI_GETOBJECTFIELD_RETURN(ret); |
2097 HOTSPOT_JNI_GETOBJECTFIELD_RETURN(ret); |
2587 #endif /* USDT2 */ |
|
2588 return ret; |
2098 return ret; |
2589 JNI_END |
2099 JNI_END |
2590 |
2100 |
2591 |
2101 |
2592 #ifndef USDT2 |
|
2593 #define DEFINE_GETFIELD(Return,Fieldname,Result) \ |
|
2594 \ |
|
2595 DT_RETURN_MARK_DECL_FOR(Result, Get##Result##Field, Return);\ |
|
2596 \ |
|
2597 JNI_QUICK_ENTRY(Return, jni_Get##Result##Field(JNIEnv *env, jobject obj, jfieldID fieldID)) \ |
|
2598 JNIWrapper("Get" XSTR(Result) "Field"); \ |
|
2599 \ |
|
2600 DTRACE_PROBE3(hotspot_jni, Get##Result##Field__entry, env, obj, fieldID);\ |
|
2601 Return ret = 0;\ |
|
2602 DT_RETURN_MARK_FOR(Result, Get##Result##Field, Return, (const Return&)ret);\ |
|
2603 \ |
|
2604 oop o = JNIHandles::resolve_non_null(obj); \ |
|
2605 Klass* k = o->klass(); \ |
|
2606 int offset = jfieldIDWorkaround::from_instance_jfieldID(k, fieldID); \ |
|
2607 /* Keep JVMTI addition small and only check enabled flag here. */ \ |
|
2608 /* jni_GetField_probe_nh() assumes that is not okay to create handles */ \ |
|
2609 /* and creates a ResetNoHandleMark. */ \ |
|
2610 if (JvmtiExport::should_post_field_access()) { \ |
|
2611 o = JvmtiExport::jni_GetField_probe_nh(thread, obj, o, k, fieldID, false); \ |
|
2612 } \ |
|
2613 ret = o->Fieldname##_field(offset); \ |
|
2614 return ret; \ |
|
2615 JNI_END |
|
2616 |
|
2617 DEFINE_GETFIELD(jboolean, bool, Boolean) |
|
2618 DEFINE_GETFIELD(jbyte, byte, Byte) |
|
2619 DEFINE_GETFIELD(jchar, char, Char) |
|
2620 DEFINE_GETFIELD(jshort, short, Short) |
|
2621 DEFINE_GETFIELD(jint, int, Int) |
|
2622 DEFINE_GETFIELD(jlong, long, Long) |
|
2623 DEFINE_GETFIELD(jfloat, float, Float) |
|
2624 DEFINE_GETFIELD(jdouble, double, Double) |
|
2625 |
|
2626 #else /* USDT2 */ |
|
2627 |
2102 |
2628 #define DEFINE_GETFIELD(Return,Fieldname,Result \ |
2103 #define DEFINE_GETFIELD(Return,Fieldname,Result \ |
2629 , EntryProbe, ReturnProbe) \ |
2104 , EntryProbe, ReturnProbe) \ |
2630 \ |
2105 \ |
2631 DT_RETURN_MARK_DECL_FOR(Result, Get##Result##Field, Return \ |
2106 DT_RETURN_MARK_DECL_FOR(Result, Get##Result##Field, Return \ |
2720 jvalue field_value; |
2190 jvalue field_value; |
2721 field_value.l = value; |
2191 field_value.l = value; |
2722 o = JvmtiExport::jni_SetField_probe_nh(thread, obj, o, k, fieldID, false, 'L', (jvalue *)&field_value); |
2192 o = JvmtiExport::jni_SetField_probe_nh(thread, obj, o, k, fieldID, false, 'L', (jvalue *)&field_value); |
2723 } |
2193 } |
2724 o->obj_field_put(offset, JNIHandles::resolve(value)); |
2194 o->obj_field_put(offset, JNIHandles::resolve(value)); |
2725 #ifndef USDT2 |
|
2726 DTRACE_PROBE(hotspot_jni, SetObjectField__return); |
|
2727 #else /* USDT2 */ |
|
2728 HOTSPOT_JNI_SETOBJECTFIELD_RETURN(); |
2195 HOTSPOT_JNI_SETOBJECTFIELD_RETURN(); |
2729 #endif /* USDT2 */ |
2196 JNI_END |
2730 JNI_END |
2197 |
2731 |
|
2732 #ifndef USDT2 |
|
2733 #define DEFINE_SETFIELD(Argument,Fieldname,Result,SigType,unionType) \ |
|
2734 \ |
|
2735 JNI_QUICK_ENTRY(void, jni_Set##Result##Field(JNIEnv *env, jobject obj, jfieldID fieldID, Argument value)) \ |
|
2736 JNIWrapper("Set" XSTR(Result) "Field"); \ |
|
2737 \ |
|
2738 FP_SELECT_##Result( \ |
|
2739 DTRACE_PROBE4(hotspot_jni, Set##Result##Field__entry, env, obj, fieldID, value), \ |
|
2740 DTRACE_PROBE3(hotspot_jni, Set##Result##Field__entry, env, obj, fieldID)); \ |
|
2741 \ |
|
2742 oop o = JNIHandles::resolve_non_null(obj); \ |
|
2743 Klass* k = o->klass(); \ |
|
2744 int offset = jfieldIDWorkaround::from_instance_jfieldID(k, fieldID); \ |
|
2745 /* Keep JVMTI addition small and only check enabled flag here. */ \ |
|
2746 /* jni_SetField_probe_nh() assumes that is not okay to create handles */ \ |
|
2747 /* and creates a ResetNoHandleMark. */ \ |
|
2748 if (JvmtiExport::should_post_field_modification()) { \ |
|
2749 jvalue field_value; \ |
|
2750 field_value.unionType = value; \ |
|
2751 o = JvmtiExport::jni_SetField_probe_nh(thread, obj, o, k, fieldID, false, SigType, (jvalue *)&field_value); \ |
|
2752 } \ |
|
2753 o->Fieldname##_field_put(offset, value); \ |
|
2754 DTRACE_PROBE(hotspot_jni, Set##Result##Field__return);\ |
|
2755 JNI_END |
|
2756 |
|
2757 DEFINE_SETFIELD(jboolean, bool, Boolean, 'Z', z) |
|
2758 DEFINE_SETFIELD(jbyte, byte, Byte, 'B', b) |
|
2759 DEFINE_SETFIELD(jchar, char, Char, 'C', c) |
|
2760 DEFINE_SETFIELD(jshort, short, Short, 'S', s) |
|
2761 DEFINE_SETFIELD(jint, int, Int, 'I', i) |
|
2762 DEFINE_SETFIELD(jlong, long, Long, 'J', j) |
|
2763 DEFINE_SETFIELD(jfloat, float, Float, 'F', f) |
|
2764 DEFINE_SETFIELD(jdouble, double, Double, 'D', d) |
|
2765 |
|
2766 #else /* USDT2 */ |
|
2767 |
2198 |
2768 #define DEFINE_SETFIELD(Argument,Fieldname,Result,SigType,unionType \ |
2199 #define DEFINE_SETFIELD(Argument,Fieldname,Result,SigType,unionType \ |
2769 , EntryProbe, ReturnProbe) \ |
2200 , EntryProbe, ReturnProbe) \ |
2770 \ |
2201 \ |
2771 JNI_QUICK_ENTRY(void, jni_Set##Result##Field(JNIEnv *env, jobject obj, jfieldID fieldID, Argument value)) \ |
2202 JNI_QUICK_ENTRY(void, jni_Set##Result##Field(JNIEnv *env, jobject obj, jfieldID fieldID, Argument value)) \ |
2811 , HOTSPOT_JNI_SETFLOATFIELD_ENTRY(env, obj, (uintptr_t)fieldID), |
2242 , HOTSPOT_JNI_SETFLOATFIELD_ENTRY(env, obj, (uintptr_t)fieldID), |
2812 HOTSPOT_JNI_SETFLOATFIELD_RETURN()) |
2243 HOTSPOT_JNI_SETFLOATFIELD_RETURN()) |
2813 DEFINE_SETFIELD(jdouble, double, Double, 'D', d |
2244 DEFINE_SETFIELD(jdouble, double, Double, 'D', d |
2814 , HOTSPOT_JNI_SETDOUBLEFIELD_ENTRY(env, obj, (uintptr_t)fieldID), |
2245 , HOTSPOT_JNI_SETDOUBLEFIELD_ENTRY(env, obj, (uintptr_t)fieldID), |
2815 HOTSPOT_JNI_SETDOUBLEFIELD_RETURN()) |
2246 HOTSPOT_JNI_SETDOUBLEFIELD_RETURN()) |
2816 #endif /* USDT2 */ |
2247 |
2817 |
|
2818 #ifndef USDT2 |
|
2819 DT_RETURN_MARK_DECL(ToReflectedField, jobject); |
|
2820 #else /* USDT2 */ |
|
2821 DT_RETURN_MARK_DECL(ToReflectedField, jobject |
2248 DT_RETURN_MARK_DECL(ToReflectedField, jobject |
2822 , HOTSPOT_JNI_TOREFLECTEDFIELD_RETURN(_ret_ref)); |
2249 , HOTSPOT_JNI_TOREFLECTEDFIELD_RETURN(_ret_ref)); |
2823 #endif /* USDT2 */ |
|
2824 |
2250 |
2825 JNI_ENTRY(jobject, jni_ToReflectedField(JNIEnv *env, jclass cls, jfieldID fieldID, jboolean isStatic)) |
2251 JNI_ENTRY(jobject, jni_ToReflectedField(JNIEnv *env, jclass cls, jfieldID fieldID, jboolean isStatic)) |
2826 JNIWrapper("ToReflectedField"); |
2252 JNIWrapper("ToReflectedField"); |
2827 #ifndef USDT2 |
|
2828 DTRACE_PROBE4(hotspot_jni, ToReflectedField__entry, |
|
2829 env, cls, fieldID, isStatic); |
|
2830 #else /* USDT2 */ |
|
2831 HOTSPOT_JNI_TOREFLECTEDFIELD_ENTRY(env, cls, (uintptr_t) fieldID, isStatic); |
2253 HOTSPOT_JNI_TOREFLECTEDFIELD_ENTRY(env, cls, (uintptr_t) fieldID, isStatic); |
2832 #endif /* USDT2 */ |
|
2833 jobject ret = NULL; |
2254 jobject ret = NULL; |
2834 DT_RETURN_MARK(ToReflectedField, jobject, (const jobject&)ret); |
2255 DT_RETURN_MARK(ToReflectedField, jobject, (const jobject&)ret); |
2835 |
2256 |
2836 fieldDescriptor fd; |
2257 fieldDescriptor fd; |
2837 bool found = false; |
2258 bool found = false; |
2857 |
2278 |
2858 |
2279 |
2859 // |
2280 // |
2860 // Accessing Static Fields |
2281 // Accessing Static Fields |
2861 // |
2282 // |
2862 #ifndef USDT2 |
|
2863 DT_RETURN_MARK_DECL(GetStaticFieldID, jfieldID); |
|
2864 #else /* USDT2 */ |
|
2865 DT_RETURN_MARK_DECL(GetStaticFieldID, jfieldID |
2283 DT_RETURN_MARK_DECL(GetStaticFieldID, jfieldID |
2866 , HOTSPOT_JNI_GETSTATICFIELDID_RETURN((uintptr_t)_ret_ref)); |
2284 , HOTSPOT_JNI_GETSTATICFIELDID_RETURN((uintptr_t)_ret_ref)); |
2867 #endif /* USDT2 */ |
|
2868 |
2285 |
2869 JNI_ENTRY(jfieldID, jni_GetStaticFieldID(JNIEnv *env, jclass clazz, |
2286 JNI_ENTRY(jfieldID, jni_GetStaticFieldID(JNIEnv *env, jclass clazz, |
2870 const char *name, const char *sig)) |
2287 const char *name, const char *sig)) |
2871 JNIWrapper("GetStaticFieldID"); |
2288 JNIWrapper("GetStaticFieldID"); |
2872 #ifndef USDT2 |
|
2873 DTRACE_PROBE4(hotspot_jni, GetStaticFieldID__entry, env, clazz, name, sig); |
|
2874 #else /* USDT2 */ |
|
2875 HOTSPOT_JNI_GETSTATICFIELDID_ENTRY(env, clazz, (char *) name, (char *) sig); |
2289 HOTSPOT_JNI_GETSTATICFIELDID_ENTRY(env, clazz, (char *) name, (char *) sig); |
2876 #endif /* USDT2 */ |
|
2877 jfieldID ret = NULL; |
2290 jfieldID ret = NULL; |
2878 DT_RETURN_MARK(GetStaticFieldID, jfieldID, (const jfieldID&)ret); |
2291 DT_RETURN_MARK(GetStaticFieldID, jfieldID, (const jfieldID&)ret); |
2879 |
2292 |
2880 // The class should have been loaded (we have an instance of the class |
2293 // The class should have been loaded (we have an instance of the class |
2881 // passed in) so the field and signature should already be in the symbol |
2294 // passed in) so the field and signature should already be in the symbol |
2923 // jni_GetField_probe() assumes that is okay to create handles. |
2332 // jni_GetField_probe() assumes that is okay to create handles. |
2924 if (JvmtiExport::should_post_field_access()) { |
2333 if (JvmtiExport::should_post_field_access()) { |
2925 JvmtiExport::jni_GetField_probe(thread, NULL, NULL, id->holder(), fieldID, true); |
2334 JvmtiExport::jni_GetField_probe(thread, NULL, NULL, id->holder(), fieldID, true); |
2926 } |
2335 } |
2927 jobject ret = JNIHandles::make_local(id->holder()->java_mirror()->obj_field(id->offset())); |
2336 jobject ret = JNIHandles::make_local(id->holder()->java_mirror()->obj_field(id->offset())); |
2928 #ifndef USDT2 |
|
2929 DTRACE_PROBE1(hotspot_jni, GetStaticObjectField__return, ret); |
|
2930 #else /* USDT2 */ |
|
2931 HOTSPOT_JNI_GETSTATICOBJECTFIELD_RETURN(ret); |
2337 HOTSPOT_JNI_GETSTATICOBJECTFIELD_RETURN(ret); |
2932 #endif /* USDT2 */ |
|
2933 return ret; |
2338 return ret; |
2934 JNI_END |
2339 JNI_END |
2935 |
2340 |
2936 #ifndef USDT2 |
|
2937 #define DEFINE_GETSTATICFIELD(Return,Fieldname,Result) \ |
|
2938 \ |
|
2939 DT_RETURN_MARK_DECL_FOR(Result, GetStatic##Result##Field, Return);\ |
|
2940 \ |
|
2941 JNI_ENTRY(Return, jni_GetStatic##Result##Field(JNIEnv *env, jclass clazz, jfieldID fieldID)) \ |
|
2942 JNIWrapper("GetStatic" XSTR(Result) "Field"); \ |
|
2943 DTRACE_PROBE3(hotspot_jni, GetStatic##Result##Field__entry, env, clazz, fieldID);\ |
|
2944 Return ret = 0;\ |
|
2945 DT_RETURN_MARK_FOR(Result, GetStatic##Result##Field, Return, \ |
|
2946 (const Return&)ret);\ |
|
2947 JNIid* id = jfieldIDWorkaround::from_static_jfieldID(fieldID); \ |
|
2948 assert(id->is_static_field_id(), "invalid static field id"); \ |
|
2949 /* Keep JVMTI addition small and only check enabled flag here. */ \ |
|
2950 /* jni_GetField_probe() assumes that is okay to create handles. */ \ |
|
2951 if (JvmtiExport::should_post_field_access()) { \ |
|
2952 JvmtiExport::jni_GetField_probe(thread, NULL, NULL, id->holder(), fieldID, true); \ |
|
2953 } \ |
|
2954 ret = id->holder()->java_mirror()-> Fieldname##_field (id->offset()); \ |
|
2955 return ret;\ |
|
2956 JNI_END |
|
2957 |
|
2958 DEFINE_GETSTATICFIELD(jboolean, bool, Boolean) |
|
2959 DEFINE_GETSTATICFIELD(jbyte, byte, Byte) |
|
2960 DEFINE_GETSTATICFIELD(jchar, char, Char) |
|
2961 DEFINE_GETSTATICFIELD(jshort, short, Short) |
|
2962 DEFINE_GETSTATICFIELD(jint, int, Int) |
|
2963 DEFINE_GETSTATICFIELD(jlong, long, Long) |
|
2964 DEFINE_GETSTATICFIELD(jfloat, float, Float) |
|
2965 DEFINE_GETSTATICFIELD(jdouble, double, Double) |
|
2966 |
|
2967 #else /* USDT2 */ |
|
2968 |
2341 |
2969 #define DEFINE_GETSTATICFIELD(Return,Fieldname,Result \ |
2342 #define DEFINE_GETSTATICFIELD(Return,Fieldname,Result \ |
2970 , EntryProbe, ReturnProbe) \ |
2343 , EntryProbe, ReturnProbe) \ |
2971 \ |
2344 \ |
2972 DT_RETURN_MARK_DECL_FOR(Result, GetStatic##Result##Field, Return \ |
2345 DT_RETURN_MARK_DECL_FOR(Result, GetStatic##Result##Field, Return \ |
3004 // Float and double probes don't return value because dtrace doesn't currently support it |
2377 // Float and double probes don't return value because dtrace doesn't currently support it |
3005 DEFINE_GETSTATICFIELD(jfloat, float, Float |
2378 DEFINE_GETSTATICFIELD(jfloat, float, Float |
3006 , HOTSPOT_JNI_GETSTATICFLOATFIELD_ENTRY(env, clazz, (uintptr_t) fieldID), HOTSPOT_JNI_GETSTATICFLOATFIELD_RETURN() ) |
2379 , HOTSPOT_JNI_GETSTATICFLOATFIELD_ENTRY(env, clazz, (uintptr_t) fieldID), HOTSPOT_JNI_GETSTATICFLOATFIELD_RETURN() ) |
3007 DEFINE_GETSTATICFIELD(jdouble, double, Double |
2380 DEFINE_GETSTATICFIELD(jdouble, double, Double |
3008 , HOTSPOT_JNI_GETSTATICDOUBLEFIELD_ENTRY(env, clazz, (uintptr_t) fieldID), HOTSPOT_JNI_GETSTATICDOUBLEFIELD_RETURN() ) |
2381 , HOTSPOT_JNI_GETSTATICDOUBLEFIELD_ENTRY(env, clazz, (uintptr_t) fieldID), HOTSPOT_JNI_GETSTATICDOUBLEFIELD_RETURN() ) |
3009 #endif /* USDT2 */ |
|
3010 |
2382 |
3011 JNI_ENTRY(void, jni_SetStaticObjectField(JNIEnv *env, jclass clazz, jfieldID fieldID, jobject value)) |
2383 JNI_ENTRY(void, jni_SetStaticObjectField(JNIEnv *env, jclass clazz, jfieldID fieldID, jobject value)) |
3012 JNIWrapper("SetStaticObjectField"); |
2384 JNIWrapper("SetStaticObjectField"); |
3013 #ifndef USDT2 |
|
3014 DTRACE_PROBE4(hotspot_jni, SetStaticObjectField__entry, env, clazz, fieldID, value); |
|
3015 #else /* USDT2 */ |
|
3016 HOTSPOT_JNI_SETSTATICOBJECTFIELD_ENTRY(env, clazz, (uintptr_t) fieldID, value); |
2385 HOTSPOT_JNI_SETSTATICOBJECTFIELD_ENTRY(env, clazz, (uintptr_t) fieldID, value); |
3017 #endif /* USDT2 */ |
|
3018 JNIid* id = jfieldIDWorkaround::from_static_jfieldID(fieldID); |
2386 JNIid* id = jfieldIDWorkaround::from_static_jfieldID(fieldID); |
3019 assert(id->is_static_field_id(), "invalid static field id"); |
2387 assert(id->is_static_field_id(), "invalid static field id"); |
3020 // Keep JVMTI addition small and only check enabled flag here. |
2388 // Keep JVMTI addition small and only check enabled flag here. |
3021 // jni_SetField_probe() assumes that is okay to create handles. |
2389 // jni_SetField_probe() assumes that is okay to create handles. |
3022 if (JvmtiExport::should_post_field_modification()) { |
2390 if (JvmtiExport::should_post_field_modification()) { |
3023 jvalue field_value; |
2391 jvalue field_value; |
3024 field_value.l = value; |
2392 field_value.l = value; |
3025 JvmtiExport::jni_SetField_probe(thread, NULL, NULL, id->holder(), fieldID, true, 'L', (jvalue *)&field_value); |
2393 JvmtiExport::jni_SetField_probe(thread, NULL, NULL, id->holder(), fieldID, true, 'L', (jvalue *)&field_value); |
3026 } |
2394 } |
3027 id->holder()->java_mirror()->obj_field_put(id->offset(), JNIHandles::resolve(value)); |
2395 id->holder()->java_mirror()->obj_field_put(id->offset(), JNIHandles::resolve(value)); |
3028 #ifndef USDT2 |
|
3029 DTRACE_PROBE(hotspot_jni, SetStaticObjectField__return); |
|
3030 #else /* USDT2 */ |
|
3031 HOTSPOT_JNI_SETSTATICOBJECTFIELD_RETURN(); |
2396 HOTSPOT_JNI_SETSTATICOBJECTFIELD_RETURN(); |
3032 #endif /* USDT2 */ |
2397 JNI_END |
3033 JNI_END |
2398 |
3034 |
2399 |
3035 |
|
3036 #ifndef USDT2 |
|
3037 #define DEFINE_SETSTATICFIELD(Argument,Fieldname,Result,SigType,unionType) \ |
|
3038 \ |
|
3039 JNI_ENTRY(void, jni_SetStatic##Result##Field(JNIEnv *env, jclass clazz, jfieldID fieldID, Argument value)) \ |
|
3040 JNIWrapper("SetStatic" XSTR(Result) "Field"); \ |
|
3041 FP_SELECT_##Result( \ |
|
3042 DTRACE_PROBE4(hotspot_jni, SetStatic##Result##Field__entry, env, clazz, fieldID, value), \ |
|
3043 DTRACE_PROBE3(hotspot_jni, SetStatic##Result##Field__entry, env, clazz, fieldID)); \ |
|
3044 \ |
|
3045 JNIid* id = jfieldIDWorkaround::from_static_jfieldID(fieldID); \ |
|
3046 assert(id->is_static_field_id(), "invalid static field id"); \ |
|
3047 /* Keep JVMTI addition small and only check enabled flag here. */ \ |
|
3048 /* jni_SetField_probe() assumes that is okay to create handles. */ \ |
|
3049 if (JvmtiExport::should_post_field_modification()) { \ |
|
3050 jvalue field_value; \ |
|
3051 field_value.unionType = value; \ |
|
3052 JvmtiExport::jni_SetField_probe(thread, NULL, NULL, id->holder(), fieldID, true, SigType, (jvalue *)&field_value); \ |
|
3053 } \ |
|
3054 id->holder()->java_mirror()-> Fieldname##_field_put (id->offset(), value); \ |
|
3055 DTRACE_PROBE(hotspot_jni, SetStatic##Result##Field__return);\ |
|
3056 JNI_END |
|
3057 |
|
3058 DEFINE_SETSTATICFIELD(jboolean, bool, Boolean, 'Z', z) |
|
3059 DEFINE_SETSTATICFIELD(jbyte, byte, Byte, 'B', b) |
|
3060 DEFINE_SETSTATICFIELD(jchar, char, Char, 'C', c) |
|
3061 DEFINE_SETSTATICFIELD(jshort, short, Short, 'S', s) |
|
3062 DEFINE_SETSTATICFIELD(jint, int, Int, 'I', i) |
|
3063 DEFINE_SETSTATICFIELD(jlong, long, Long, 'J', j) |
|
3064 DEFINE_SETSTATICFIELD(jfloat, float, Float, 'F', f) |
|
3065 DEFINE_SETSTATICFIELD(jdouble, double, Double, 'D', d) |
|
3066 |
|
3067 #else /* USDT2 */ |
|
3068 |
2400 |
3069 #define DEFINE_SETSTATICFIELD(Argument,Fieldname,Result,SigType,unionType \ |
2401 #define DEFINE_SETSTATICFIELD(Argument,Fieldname,Result,SigType,unionType \ |
3070 , EntryProbe, ReturnProbe) \ |
2402 , EntryProbe, ReturnProbe) \ |
3071 \ |
2403 \ |
3072 JNI_ENTRY(void, jni_SetStatic##Result##Field(JNIEnv *env, jclass clazz, jfieldID fieldID, Argument value)) \ |
2404 JNI_ENTRY(void, jni_SetStatic##Result##Field(JNIEnv *env, jclass clazz, jfieldID fieldID, Argument value)) \ |
3109 , HOTSPOT_JNI_SETSTATICFLOATFIELD_ENTRY(env, clazz, (uintptr_t) fieldID), |
2441 , HOTSPOT_JNI_SETSTATICFLOATFIELD_ENTRY(env, clazz, (uintptr_t) fieldID), |
3110 HOTSPOT_JNI_SETSTATICFLOATFIELD_RETURN()) |
2442 HOTSPOT_JNI_SETSTATICFLOATFIELD_RETURN()) |
3111 DEFINE_SETSTATICFIELD(jdouble, double, Double, 'D', d |
2443 DEFINE_SETSTATICFIELD(jdouble, double, Double, 'D', d |
3112 , HOTSPOT_JNI_SETSTATICDOUBLEFIELD_ENTRY(env, clazz, (uintptr_t) fieldID), |
2444 , HOTSPOT_JNI_SETSTATICDOUBLEFIELD_ENTRY(env, clazz, (uintptr_t) fieldID), |
3113 HOTSPOT_JNI_SETSTATICDOUBLEFIELD_RETURN()) |
2445 HOTSPOT_JNI_SETSTATICDOUBLEFIELD_RETURN()) |
3114 #endif /* USDT2 */ |
|
3115 |
2446 |
3116 // |
2447 // |
3117 // String Operations |
2448 // String Operations |
3118 // |
2449 // |
3119 |
2450 |
3120 // Unicode Interface |
2451 // Unicode Interface |
3121 |
2452 |
3122 #ifndef USDT2 |
|
3123 DT_RETURN_MARK_DECL(NewString, jstring); |
|
3124 #else /* USDT2 */ |
|
3125 DT_RETURN_MARK_DECL(NewString, jstring |
2453 DT_RETURN_MARK_DECL(NewString, jstring |
3126 , HOTSPOT_JNI_NEWSTRING_RETURN(_ret_ref)); |
2454 , HOTSPOT_JNI_NEWSTRING_RETURN(_ret_ref)); |
3127 #endif /* USDT2 */ |
|
3128 |
2455 |
3129 JNI_ENTRY(jstring, jni_NewString(JNIEnv *env, const jchar *unicodeChars, jsize len)) |
2456 JNI_ENTRY(jstring, jni_NewString(JNIEnv *env, const jchar *unicodeChars, jsize len)) |
3130 JNIWrapper("NewString"); |
2457 JNIWrapper("NewString"); |
3131 #ifndef USDT2 |
|
3132 DTRACE_PROBE3(hotspot_jni, NewString__entry, env, unicodeChars, len); |
|
3133 #else /* USDT2 */ |
|
3134 HOTSPOT_JNI_NEWSTRING_ENTRY(env, (uint16_t *) unicodeChars, len); |
2458 HOTSPOT_JNI_NEWSTRING_ENTRY(env, (uint16_t *) unicodeChars, len); |
3135 #endif /* USDT2 */ |
|
3136 jstring ret = NULL; |
2459 jstring ret = NULL; |
3137 DT_RETURN_MARK(NewString, jstring, (const jstring&)ret); |
2460 DT_RETURN_MARK(NewString, jstring, (const jstring&)ret); |
3138 oop string=java_lang_String::create_oop_from_unicode((jchar*) unicodeChars, len, CHECK_NULL); |
2461 oop string=java_lang_String::create_oop_from_unicode((jchar*) unicodeChars, len, CHECK_NULL); |
3139 ret = (jstring) JNIHandles::make_local(env, string); |
2462 ret = (jstring) JNIHandles::make_local(env, string); |
3140 return ret; |
2463 return ret; |
3141 JNI_END |
2464 JNI_END |
3142 |
2465 |
3143 |
2466 |
3144 JNI_QUICK_ENTRY(jsize, jni_GetStringLength(JNIEnv *env, jstring string)) |
2467 JNI_QUICK_ENTRY(jsize, jni_GetStringLength(JNIEnv *env, jstring string)) |
3145 JNIWrapper("GetStringLength"); |
2468 JNIWrapper("GetStringLength"); |
3146 #ifndef USDT2 |
|
3147 DTRACE_PROBE2(hotspot_jni, GetStringLength__entry, env, string); |
|
3148 #else /* USDT2 */ |
|
3149 HOTSPOT_JNI_GETSTRINGLENGTH_ENTRY(env, string); |
2469 HOTSPOT_JNI_GETSTRINGLENGTH_ENTRY(env, string); |
3150 #endif /* USDT2 */ |
|
3151 jsize ret = 0; |
2470 jsize ret = 0; |
3152 oop s = JNIHandles::resolve_non_null(string); |
2471 oop s = JNIHandles::resolve_non_null(string); |
3153 if (java_lang_String::value(s) != NULL) { |
2472 if (java_lang_String::value(s) != NULL) { |
3154 ret = java_lang_String::length(s); |
2473 ret = java_lang_String::length(s); |
3155 } |
2474 } |
3156 #ifndef USDT2 |
|
3157 DTRACE_PROBE1(hotspot_jni, GetStringLength__return, ret); |
|
3158 #else /* USDT2 */ |
|
3159 HOTSPOT_JNI_GETSTRINGLENGTH_RETURN(ret); |
2475 HOTSPOT_JNI_GETSTRINGLENGTH_RETURN(ret); |
3160 #endif /* USDT2 */ |
|
3161 return ret; |
2476 return ret; |
3162 JNI_END |
2477 JNI_END |
3163 |
2478 |
3164 |
2479 |
3165 JNI_QUICK_ENTRY(const jchar*, jni_GetStringChars( |
2480 JNI_QUICK_ENTRY(const jchar*, jni_GetStringChars( |
3166 JNIEnv *env, jstring string, jboolean *isCopy)) |
2481 JNIEnv *env, jstring string, jboolean *isCopy)) |
3167 JNIWrapper("GetStringChars"); |
2482 JNIWrapper("GetStringChars"); |
3168 #ifndef USDT2 |
|
3169 DTRACE_PROBE3(hotspot_jni, GetStringChars__entry, env, string, isCopy); |
|
3170 #else /* USDT2 */ |
|
3171 HOTSPOT_JNI_GETSTRINGCHARS_ENTRY(env, string, (uintptr_t *) isCopy); |
2483 HOTSPOT_JNI_GETSTRINGCHARS_ENTRY(env, string, (uintptr_t *) isCopy); |
3172 #endif /* USDT2 */ |
|
3173 jchar* buf = NULL; |
2484 jchar* buf = NULL; |
3174 oop s = JNIHandles::resolve_non_null(string); |
2485 oop s = JNIHandles::resolve_non_null(string); |
3175 typeArrayOop s_value = java_lang_String::value(s); |
2486 typeArrayOop s_value = java_lang_String::value(s); |
3176 if (s_value != NULL) { |
2487 if (s_value != NULL) { |
3177 int s_len = java_lang_String::length(s); |
2488 int s_len = java_lang_String::length(s); |
3187 if (isCopy != NULL) { |
2498 if (isCopy != NULL) { |
3188 *isCopy = JNI_TRUE; |
2499 *isCopy = JNI_TRUE; |
3189 } |
2500 } |
3190 } |
2501 } |
3191 } |
2502 } |
3192 #ifndef USDT2 |
|
3193 DTRACE_PROBE1(hotspot_jni, GetStringChars__return, buf); |
|
3194 #else /* USDT2 */ |
|
3195 HOTSPOT_JNI_GETSTRINGCHARS_RETURN(buf); |
2503 HOTSPOT_JNI_GETSTRINGCHARS_RETURN(buf); |
3196 #endif /* USDT2 */ |
|
3197 return buf; |
2504 return buf; |
3198 JNI_END |
2505 JNI_END |
3199 |
2506 |
3200 |
2507 |
3201 JNI_QUICK_ENTRY(void, jni_ReleaseStringChars(JNIEnv *env, jstring str, const jchar *chars)) |
2508 JNI_QUICK_ENTRY(void, jni_ReleaseStringChars(JNIEnv *env, jstring str, const jchar *chars)) |
3202 JNIWrapper("ReleaseStringChars"); |
2509 JNIWrapper("ReleaseStringChars"); |
3203 #ifndef USDT2 |
|
3204 DTRACE_PROBE3(hotspot_jni, ReleaseStringChars__entry, env, str, chars); |
|
3205 #else /* USDT2 */ |
|
3206 HOTSPOT_JNI_RELEASESTRINGCHARS_ENTRY(env, str, (uint16_t *) chars); |
2510 HOTSPOT_JNI_RELEASESTRINGCHARS_ENTRY(env, str, (uint16_t *) chars); |
3207 #endif /* USDT2 */ |
|
3208 //%note jni_6 |
2511 //%note jni_6 |
3209 if (chars != NULL) { |
2512 if (chars != NULL) { |
3210 // Since String objects are supposed to be immutable, don't copy any |
2513 // Since String objects are supposed to be immutable, don't copy any |
3211 // new data back. A bad user will have to go after the char array. |
2514 // new data back. A bad user will have to go after the char array. |
3212 FreeHeap((void*) chars); |
2515 FreeHeap((void*) chars); |
3213 } |
2516 } |
3214 #ifndef USDT2 |
|
3215 DTRACE_PROBE(hotspot_jni, ReleaseStringChars__return); |
|
3216 #else /* USDT2 */ |
|
3217 HOTSPOT_JNI_RELEASESTRINGCHARS_RETURN(); |
2517 HOTSPOT_JNI_RELEASESTRINGCHARS_RETURN(); |
3218 #endif /* USDT2 */ |
|
3219 JNI_END |
2518 JNI_END |
3220 |
2519 |
3221 |
2520 |
3222 // UTF Interface |
2521 // UTF Interface |
3223 |
2522 |
3224 #ifndef USDT2 |
|
3225 DT_RETURN_MARK_DECL(NewStringUTF, jstring); |
|
3226 #else /* USDT2 */ |
|
3227 DT_RETURN_MARK_DECL(NewStringUTF, jstring |
2523 DT_RETURN_MARK_DECL(NewStringUTF, jstring |
3228 , HOTSPOT_JNI_NEWSTRINGUTF_RETURN(_ret_ref)); |
2524 , HOTSPOT_JNI_NEWSTRINGUTF_RETURN(_ret_ref)); |
3229 #endif /* USDT2 */ |
|
3230 |
2525 |
3231 JNI_ENTRY(jstring, jni_NewStringUTF(JNIEnv *env, const char *bytes)) |
2526 JNI_ENTRY(jstring, jni_NewStringUTF(JNIEnv *env, const char *bytes)) |
3232 JNIWrapper("NewStringUTF"); |
2527 JNIWrapper("NewStringUTF"); |
3233 #ifndef USDT2 |
|
3234 DTRACE_PROBE2(hotspot_jni, NewStringUTF__entry, env, bytes); |
|
3235 #else /* USDT2 */ |
|
3236 HOTSPOT_JNI_NEWSTRINGUTF_ENTRY(env, (char *) bytes); |
2528 HOTSPOT_JNI_NEWSTRINGUTF_ENTRY(env, (char *) bytes); |
3237 #endif /* USDT2 */ |
|
3238 jstring ret; |
2529 jstring ret; |
3239 DT_RETURN_MARK(NewStringUTF, jstring, (const jstring&)ret); |
2530 DT_RETURN_MARK(NewStringUTF, jstring, (const jstring&)ret); |
3240 |
2531 |
3241 oop result = java_lang_String::create_oop_from_str((char*) bytes, CHECK_NULL); |
2532 oop result = java_lang_String::create_oop_from_str((char*) bytes, CHECK_NULL); |
3242 ret = (jstring) JNIHandles::make_local(env, result); |
2533 ret = (jstring) JNIHandles::make_local(env, result); |
3244 JNI_END |
2535 JNI_END |
3245 |
2536 |
3246 |
2537 |
3247 JNI_ENTRY(jsize, jni_GetStringUTFLength(JNIEnv *env, jstring string)) |
2538 JNI_ENTRY(jsize, jni_GetStringUTFLength(JNIEnv *env, jstring string)) |
3248 JNIWrapper("GetStringUTFLength"); |
2539 JNIWrapper("GetStringUTFLength"); |
3249 #ifndef USDT2 |
|
3250 DTRACE_PROBE2(hotspot_jni, GetStringUTFLength__entry, env, string); |
|
3251 #else /* USDT2 */ |
|
3252 HOTSPOT_JNI_GETSTRINGUTFLENGTH_ENTRY(env, string); |
2540 HOTSPOT_JNI_GETSTRINGUTFLENGTH_ENTRY(env, string); |
3253 #endif /* USDT2 */ |
|
3254 jsize ret = 0; |
2541 jsize ret = 0; |
3255 oop java_string = JNIHandles::resolve_non_null(string); |
2542 oop java_string = JNIHandles::resolve_non_null(string); |
3256 if (java_lang_String::value(java_string) != NULL) { |
2543 if (java_lang_String::value(java_string) != NULL) { |
3257 ret = java_lang_String::utf8_length(java_string); |
2544 ret = java_lang_String::utf8_length(java_string); |
3258 } |
2545 } |
3259 #ifndef USDT2 |
|
3260 DTRACE_PROBE1(hotspot_jni, GetStringUTFLength__return, ret); |
|
3261 #else /* USDT2 */ |
|
3262 HOTSPOT_JNI_GETSTRINGUTFLENGTH_RETURN(ret); |
2546 HOTSPOT_JNI_GETSTRINGUTFLENGTH_RETURN(ret); |
3263 #endif /* USDT2 */ |
|
3264 return ret; |
2547 return ret; |
3265 JNI_END |
2548 JNI_END |
3266 |
2549 |
3267 |
2550 |
3268 JNI_ENTRY(const char*, jni_GetStringUTFChars(JNIEnv *env, jstring string, jboolean *isCopy)) |
2551 JNI_ENTRY(const char*, jni_GetStringUTFChars(JNIEnv *env, jstring string, jboolean *isCopy)) |
3269 JNIWrapper("GetStringUTFChars"); |
2552 JNIWrapper("GetStringUTFChars"); |
3270 #ifndef USDT2 |
|
3271 DTRACE_PROBE3(hotspot_jni, GetStringUTFChars__entry, env, string, isCopy); |
|
3272 #else /* USDT2 */ |
|
3273 HOTSPOT_JNI_GETSTRINGUTFCHARS_ENTRY(env, string, (uintptr_t *) isCopy); |
2553 HOTSPOT_JNI_GETSTRINGUTFCHARS_ENTRY(env, string, (uintptr_t *) isCopy); |
3274 #endif /* USDT2 */ |
|
3275 char* result = NULL; |
2554 char* result = NULL; |
3276 oop java_string = JNIHandles::resolve_non_null(string); |
2555 oop java_string = JNIHandles::resolve_non_null(string); |
3277 if (java_lang_String::value(java_string) != NULL) { |
2556 if (java_lang_String::value(java_string) != NULL) { |
3278 size_t length = java_lang_String::utf8_length(java_string); |
2557 size_t length = java_lang_String::utf8_length(java_string); |
3279 /* JNI Specification states return NULL on OOM */ |
2558 /* JNI Specification states return NULL on OOM */ |
3283 if (isCopy != NULL) { |
2562 if (isCopy != NULL) { |
3284 *isCopy = JNI_TRUE; |
2563 *isCopy = JNI_TRUE; |
3285 } |
2564 } |
3286 } |
2565 } |
3287 } |
2566 } |
3288 #ifndef USDT2 |
|
3289 DTRACE_PROBE1(hotspot_jni, GetStringUTFChars__return, result); |
|
3290 #else /* USDT2 */ |
|
3291 HOTSPOT_JNI_GETSTRINGUTFCHARS_RETURN(result); |
2567 HOTSPOT_JNI_GETSTRINGUTFCHARS_RETURN(result); |
3292 #endif /* USDT2 */ |
|
3293 return result; |
2568 return result; |
3294 JNI_END |
2569 JNI_END |
3295 |
2570 |
3296 |
2571 |
3297 JNI_LEAF(void, jni_ReleaseStringUTFChars(JNIEnv *env, jstring str, const char *chars)) |
2572 JNI_LEAF(void, jni_ReleaseStringUTFChars(JNIEnv *env, jstring str, const char *chars)) |
3298 JNIWrapper("ReleaseStringUTFChars"); |
2573 JNIWrapper("ReleaseStringUTFChars"); |
3299 #ifndef USDT2 |
|
3300 DTRACE_PROBE3(hotspot_jni, ReleaseStringUTFChars__entry, env, str, chars); |
|
3301 #else /* USDT2 */ |
|
3302 HOTSPOT_JNI_RELEASESTRINGUTFCHARS_ENTRY(env, str, (char *) chars); |
2574 HOTSPOT_JNI_RELEASESTRINGUTFCHARS_ENTRY(env, str, (char *) chars); |
3303 #endif /* USDT2 */ |
|
3304 if (chars != NULL) { |
2575 if (chars != NULL) { |
3305 FreeHeap((char*) chars); |
2576 FreeHeap((char*) chars); |
3306 } |
2577 } |
3307 #ifndef USDT2 |
|
3308 DTRACE_PROBE(hotspot_jni, ReleaseStringUTFChars__return); |
|
3309 #else /* USDT2 */ |
|
3310 HOTSPOT_JNI_RELEASESTRINGUTFCHARS_RETURN(); |
2578 HOTSPOT_JNI_RELEASESTRINGUTFCHARS_RETURN(); |
3311 #endif /* USDT2 */ |
|
3312 JNI_END |
2579 JNI_END |
3313 |
2580 |
3314 |
2581 |
3315 JNI_QUICK_ENTRY(jsize, jni_GetArrayLength(JNIEnv *env, jarray array)) |
2582 JNI_QUICK_ENTRY(jsize, jni_GetArrayLength(JNIEnv *env, jarray array)) |
3316 JNIWrapper("GetArrayLength"); |
2583 JNIWrapper("GetArrayLength"); |
3317 #ifndef USDT2 |
|
3318 DTRACE_PROBE2(hotspot_jni, GetArrayLength__entry, env, array); |
|
3319 #else /* USDT2 */ |
|
3320 HOTSPOT_JNI_GETARRAYLENGTH_ENTRY(env, array); |
2584 HOTSPOT_JNI_GETARRAYLENGTH_ENTRY(env, array); |
3321 #endif /* USDT2 */ |
|
3322 arrayOop a = arrayOop(JNIHandles::resolve_non_null(array)); |
2585 arrayOop a = arrayOop(JNIHandles::resolve_non_null(array)); |
3323 assert(a->is_array(), "must be array"); |
2586 assert(a->is_array(), "must be array"); |
3324 jsize ret = a->length(); |
2587 jsize ret = a->length(); |
3325 #ifndef USDT2 |
|
3326 DTRACE_PROBE1(hotspot_jni, GetArrayLength__return, ret); |
|
3327 #else /* USDT2 */ |
|
3328 HOTSPOT_JNI_GETARRAYLENGTH_RETURN(ret); |
2588 HOTSPOT_JNI_GETARRAYLENGTH_RETURN(ret); |
3329 #endif /* USDT2 */ |
|
3330 return ret; |
2589 return ret; |
3331 JNI_END |
2590 JNI_END |
3332 |
2591 |
3333 |
2592 |
3334 // |
2593 // |
3335 // Object Array Operations |
2594 // Object Array Operations |
3336 // |
2595 // |
3337 |
2596 |
3338 #ifndef USDT2 |
|
3339 DT_RETURN_MARK_DECL(NewObjectArray, jobjectArray); |
|
3340 #else /* USDT2 */ |
|
3341 DT_RETURN_MARK_DECL(NewObjectArray, jobjectArray |
2597 DT_RETURN_MARK_DECL(NewObjectArray, jobjectArray |
3342 , HOTSPOT_JNI_NEWOBJECTARRAY_RETURN(_ret_ref)); |
2598 , HOTSPOT_JNI_NEWOBJECTARRAY_RETURN(_ret_ref)); |
3343 #endif /* USDT2 */ |
|
3344 |
2599 |
3345 JNI_ENTRY(jobjectArray, jni_NewObjectArray(JNIEnv *env, jsize length, jclass elementClass, jobject initialElement)) |
2600 JNI_ENTRY(jobjectArray, jni_NewObjectArray(JNIEnv *env, jsize length, jclass elementClass, jobject initialElement)) |
3346 JNIWrapper("NewObjectArray"); |
2601 JNIWrapper("NewObjectArray"); |
3347 #ifndef USDT2 |
|
3348 DTRACE_PROBE4(hotspot_jni, NewObjectArray__entry, env, length, elementClass, initialElement); |
|
3349 #else /* USDT2 */ |
|
3350 HOTSPOT_JNI_NEWOBJECTARRAY_ENTRY(env, length, elementClass, initialElement); |
2602 HOTSPOT_JNI_NEWOBJECTARRAY_ENTRY(env, length, elementClass, initialElement); |
3351 #endif /* USDT2 */ |
|
3352 jobjectArray ret = NULL; |
2603 jobjectArray ret = NULL; |
3353 DT_RETURN_MARK(NewObjectArray, jobjectArray, (const jobjectArray&)ret); |
2604 DT_RETURN_MARK(NewObjectArray, jobjectArray, (const jobjectArray&)ret); |
3354 KlassHandle ek(THREAD, java_lang_Class::as_Klass(JNIHandles::resolve_non_null(elementClass))); |
2605 KlassHandle ek(THREAD, java_lang_Class::as_Klass(JNIHandles::resolve_non_null(elementClass))); |
3355 Klass* ako = ek()->array_klass(CHECK_NULL); |
2606 Klass* ako = ek()->array_klass(CHECK_NULL); |
3356 KlassHandle ak = KlassHandle(THREAD, ako); |
2607 KlassHandle ak = KlassHandle(THREAD, ako); |
3364 } |
2615 } |
3365 ret = (jobjectArray) JNIHandles::make_local(env, result); |
2616 ret = (jobjectArray) JNIHandles::make_local(env, result); |
3366 return ret; |
2617 return ret; |
3367 JNI_END |
2618 JNI_END |
3368 |
2619 |
3369 #ifndef USDT2 |
|
3370 DT_RETURN_MARK_DECL(GetObjectArrayElement, jobject); |
|
3371 #else /* USDT2 */ |
|
3372 DT_RETURN_MARK_DECL(GetObjectArrayElement, jobject |
2620 DT_RETURN_MARK_DECL(GetObjectArrayElement, jobject |
3373 , HOTSPOT_JNI_GETOBJECTARRAYELEMENT_RETURN(_ret_ref)); |
2621 , HOTSPOT_JNI_GETOBJECTARRAYELEMENT_RETURN(_ret_ref)); |
3374 #endif /* USDT2 */ |
|
3375 |
2622 |
3376 JNI_ENTRY(jobject, jni_GetObjectArrayElement(JNIEnv *env, jobjectArray array, jsize index)) |
2623 JNI_ENTRY(jobject, jni_GetObjectArrayElement(JNIEnv *env, jobjectArray array, jsize index)) |
3377 JNIWrapper("GetObjectArrayElement"); |
2624 JNIWrapper("GetObjectArrayElement"); |
3378 #ifndef USDT2 |
|
3379 DTRACE_PROBE3(hotspot_jni, GetObjectArrayElement__entry, env, array, index); |
|
3380 #else /* USDT2 */ |
|
3381 HOTSPOT_JNI_GETOBJECTARRAYELEMENT_ENTRY(env, array, index); |
2625 HOTSPOT_JNI_GETOBJECTARRAYELEMENT_ENTRY(env, array, index); |
3382 #endif /* USDT2 */ |
|
3383 jobject ret = NULL; |
2626 jobject ret = NULL; |
3384 DT_RETURN_MARK(GetObjectArrayElement, jobject, (const jobject&)ret); |
2627 DT_RETURN_MARK(GetObjectArrayElement, jobject, (const jobject&)ret); |
3385 objArrayOop a = objArrayOop(JNIHandles::resolve_non_null(array)); |
2628 objArrayOop a = objArrayOop(JNIHandles::resolve_non_null(array)); |
3386 if (a->is_within_bounds(index)) { |
2629 if (a->is_within_bounds(index)) { |
3387 ret = JNIHandles::make_local(env, a->obj_at(index)); |
2630 ret = JNIHandles::make_local(env, a->obj_at(index)); |
3391 sprintf(buf, "%d", index); |
2634 sprintf(buf, "%d", index); |
3392 THROW_MSG_0(vmSymbols::java_lang_ArrayIndexOutOfBoundsException(), buf); |
2635 THROW_MSG_0(vmSymbols::java_lang_ArrayIndexOutOfBoundsException(), buf); |
3393 } |
2636 } |
3394 JNI_END |
2637 JNI_END |
3395 |
2638 |
3396 #ifndef USDT2 |
|
3397 DT_VOID_RETURN_MARK_DECL(SetObjectArrayElement); |
|
3398 #else /* USDT2 */ |
|
3399 DT_VOID_RETURN_MARK_DECL(SetObjectArrayElement |
2639 DT_VOID_RETURN_MARK_DECL(SetObjectArrayElement |
3400 , HOTSPOT_JNI_SETOBJECTARRAYELEMENT_RETURN()); |
2640 , HOTSPOT_JNI_SETOBJECTARRAYELEMENT_RETURN()); |
3401 #endif /* USDT2 */ |
|
3402 |
2641 |
3403 JNI_ENTRY(void, jni_SetObjectArrayElement(JNIEnv *env, jobjectArray array, jsize index, jobject value)) |
2642 JNI_ENTRY(void, jni_SetObjectArrayElement(JNIEnv *env, jobjectArray array, jsize index, jobject value)) |
3404 JNIWrapper("SetObjectArrayElement"); |
2643 JNIWrapper("SetObjectArrayElement"); |
3405 #ifndef USDT2 |
|
3406 DTRACE_PROBE4(hotspot_jni, SetObjectArrayElement__entry, env, array, index, value); |
|
3407 #else /* USDT2 */ |
|
3408 HOTSPOT_JNI_SETOBJECTARRAYELEMENT_ENTRY(env, array, index, value); |
2644 HOTSPOT_JNI_SETOBJECTARRAYELEMENT_ENTRY(env, array, index, value); |
3409 #endif /* USDT2 */ |
|
3410 DT_VOID_RETURN_MARK(SetObjectArrayElement); |
2645 DT_VOID_RETURN_MARK(SetObjectArrayElement); |
3411 |
2646 |
3412 objArrayOop a = objArrayOop(JNIHandles::resolve_non_null(array)); |
2647 objArrayOop a = objArrayOop(JNIHandles::resolve_non_null(array)); |
3413 oop v = JNIHandles::resolve(value); |
2648 oop v = JNIHandles::resolve(value); |
3414 if (a->is_within_bounds(index)) { |
2649 if (a->is_within_bounds(index)) { |
3423 THROW_MSG(vmSymbols::java_lang_ArrayIndexOutOfBoundsException(), buf); |
2658 THROW_MSG(vmSymbols::java_lang_ArrayIndexOutOfBoundsException(), buf); |
3424 } |
2659 } |
3425 JNI_END |
2660 JNI_END |
3426 |
2661 |
3427 |
2662 |
3428 #ifndef USDT2 |
|
3429 #define DEFINE_NEWSCALARARRAY(Return,Allocator,Result) \ |
|
3430 \ |
|
3431 DT_RETURN_MARK_DECL(New##Result##Array, Return); \ |
|
3432 \ |
|
3433 JNI_ENTRY(Return, \ |
|
3434 jni_New##Result##Array(JNIEnv *env, jsize len)) \ |
|
3435 JNIWrapper("New" XSTR(Result) "Array"); \ |
|
3436 DTRACE_PROBE2(hotspot_jni, New##Result##Array__entry, env, len);\ |
|
3437 Return ret = NULL;\ |
|
3438 DT_RETURN_MARK(New##Result##Array, Return, (const Return&)ret);\ |
|
3439 \ |
|
3440 oop obj= oopFactory::Allocator(len, CHECK_0); \ |
|
3441 ret = (Return) JNIHandles::make_local(env, obj); \ |
|
3442 return ret;\ |
|
3443 JNI_END |
|
3444 |
|
3445 DEFINE_NEWSCALARARRAY(jbooleanArray, new_boolArray, Boolean) |
|
3446 DEFINE_NEWSCALARARRAY(jbyteArray, new_byteArray, Byte) |
|
3447 DEFINE_NEWSCALARARRAY(jshortArray, new_shortArray, Short) |
|
3448 DEFINE_NEWSCALARARRAY(jcharArray, new_charArray, Char) |
|
3449 DEFINE_NEWSCALARARRAY(jintArray, new_intArray, Int) |
|
3450 DEFINE_NEWSCALARARRAY(jlongArray, new_longArray, Long) |
|
3451 DEFINE_NEWSCALARARRAY(jfloatArray, new_singleArray, Float) |
|
3452 DEFINE_NEWSCALARARRAY(jdoubleArray, new_doubleArray, Double) |
|
3453 |
|
3454 #else /* USDT2 */ |
|
3455 |
2663 |
3456 #define DEFINE_NEWSCALARARRAY(Return,Allocator,Result \ |
2664 #define DEFINE_NEWSCALARARRAY(Return,Allocator,Result \ |
3457 ,EntryProbe,ReturnProbe) \ |
2665 ,EntryProbe,ReturnProbe) \ |
3458 \ |
2666 \ |
3459 DT_RETURN_MARK_DECL(New##Result##Array, Return \ |
2667 DT_RETURN_MARK_DECL(New##Result##Array, Return \ |
3511 } |
2718 } |
3512 return bad_address; |
2719 return bad_address; |
3513 } |
2720 } |
3514 |
2721 |
3515 |
2722 |
3516 #ifndef USDT2 |
|
3517 #define DEFINE_GETSCALARARRAYELEMENTS(ElementTag,ElementType,Result, Tag) \ |
|
3518 \ |
|
3519 JNI_QUICK_ENTRY(ElementType*, \ |
|
3520 jni_Get##Result##ArrayElements(JNIEnv *env, ElementType##Array array, jboolean *isCopy)) \ |
|
3521 JNIWrapper("Get" XSTR(Result) "ArrayElements"); \ |
|
3522 DTRACE_PROBE3(hotspot_jni, Get##Result##ArrayElements__entry, env, array, isCopy);\ |
|
3523 /* allocate an chunk of memory in c land */ \ |
|
3524 typeArrayOop a = typeArrayOop(JNIHandles::resolve_non_null(array)); \ |
|
3525 ElementType* result; \ |
|
3526 int len = a->length(); \ |
|
3527 if (len == 0) { \ |
|
3528 /* Empty array: legal but useless, can't return NULL. \ |
|
3529 * Return a pointer to something useless. \ |
|
3530 * Avoid asserts in typeArrayOop. */ \ |
|
3531 result = (ElementType*)get_bad_address(); \ |
|
3532 } else { \ |
|
3533 /* JNI Specification states return NULL on OOM */ \ |
|
3534 result = NEW_C_HEAP_ARRAY_RETURN_NULL(ElementType, len, mtInternal); \ |
|
3535 if (result != NULL) { \ |
|
3536 /* copy the array to the c chunk */ \ |
|
3537 memcpy(result, a->Tag##_at_addr(0), sizeof(ElementType)*len); \ |
|
3538 if (isCopy) { \ |
|
3539 *isCopy = JNI_TRUE; \ |
|
3540 } \ |
|
3541 } \ |
|
3542 } \ |
|
3543 DTRACE_PROBE1(hotspot_jni, Get##Result##ArrayElements__return, result);\ |
|
3544 return result; \ |
|
3545 JNI_END |
|
3546 |
|
3547 DEFINE_GETSCALARARRAYELEMENTS(T_BOOLEAN, jboolean, Boolean, bool) |
|
3548 DEFINE_GETSCALARARRAYELEMENTS(T_BYTE, jbyte, Byte, byte) |
|
3549 DEFINE_GETSCALARARRAYELEMENTS(T_SHORT, jshort, Short, short) |
|
3550 DEFINE_GETSCALARARRAYELEMENTS(T_CHAR, jchar, Char, char) |
|
3551 DEFINE_GETSCALARARRAYELEMENTS(T_INT, jint, Int, int) |
|
3552 DEFINE_GETSCALARARRAYELEMENTS(T_LONG, jlong, Long, long) |
|
3553 DEFINE_GETSCALARARRAYELEMENTS(T_FLOAT, jfloat, Float, float) |
|
3554 DEFINE_GETSCALARARRAYELEMENTS(T_DOUBLE, jdouble, Double, double) |
|
3555 |
|
3556 #else /* USDT2 */ |
|
3557 |
2723 |
3558 #define DEFINE_GETSCALARARRAYELEMENTS(ElementTag,ElementType,Result, Tag \ |
2724 #define DEFINE_GETSCALARARRAYELEMENTS(ElementTag,ElementType,Result, Tag \ |
3559 , EntryProbe, ReturnProbe) \ |
2725 , EntryProbe, ReturnProbe) \ |
3560 \ |
2726 \ |
3561 JNI_QUICK_ENTRY(ElementType*, \ |
2727 JNI_QUICK_ENTRY(ElementType*, \ |
3609 , HOTSPOT_JNI_GETFLOATARRAYELEMENTS_ENTRY(env, array, (uintptr_t *) isCopy), |
2775 , HOTSPOT_JNI_GETFLOATARRAYELEMENTS_ENTRY(env, array, (uintptr_t *) isCopy), |
3610 HOTSPOT_JNI_GETFLOATARRAYELEMENTS_RETURN(result)) |
2776 HOTSPOT_JNI_GETFLOATARRAYELEMENTS_RETURN(result)) |
3611 DEFINE_GETSCALARARRAYELEMENTS(T_DOUBLE, jdouble, Double, double |
2777 DEFINE_GETSCALARARRAYELEMENTS(T_DOUBLE, jdouble, Double, double |
3612 , HOTSPOT_JNI_GETDOUBLEARRAYELEMENTS_ENTRY(env, array, (uintptr_t *) isCopy), |
2778 , HOTSPOT_JNI_GETDOUBLEARRAYELEMENTS_ENTRY(env, array, (uintptr_t *) isCopy), |
3613 HOTSPOT_JNI_GETDOUBLEARRAYELEMENTS_RETURN(result)) |
2779 HOTSPOT_JNI_GETDOUBLEARRAYELEMENTS_RETURN(result)) |
3614 #endif /* USDT2 */ |
2780 |
3615 |
|
3616 #ifndef USDT2 |
|
3617 #define DEFINE_RELEASESCALARARRAYELEMENTS(ElementTag,ElementType,Result,Tag) \ |
|
3618 \ |
|
3619 JNI_QUICK_ENTRY(void, \ |
|
3620 jni_Release##Result##ArrayElements(JNIEnv *env, ElementType##Array array, \ |
|
3621 ElementType *buf, jint mode)) \ |
|
3622 JNIWrapper("Release" XSTR(Result) "ArrayElements"); \ |
|
3623 DTRACE_PROBE4(hotspot_jni, Release##Result##ArrayElements__entry, env, array, buf, mode);\ |
|
3624 typeArrayOop a = typeArrayOop(JNIHandles::resolve_non_null(array)); \ |
|
3625 int len = a->length(); \ |
|
3626 if (len != 0) { /* Empty array: nothing to free or copy. */ \ |
|
3627 if ((mode == 0) || (mode == JNI_COMMIT)) { \ |
|
3628 memcpy(a->Tag##_at_addr(0), buf, sizeof(ElementType)*len); \ |
|
3629 } \ |
|
3630 if ((mode == 0) || (mode == JNI_ABORT)) { \ |
|
3631 FreeHeap(buf); \ |
|
3632 } \ |
|
3633 } \ |
|
3634 DTRACE_PROBE(hotspot_jni, Release##Result##ArrayElements__return);\ |
|
3635 JNI_END |
|
3636 |
|
3637 DEFINE_RELEASESCALARARRAYELEMENTS(T_BOOLEAN, jboolean, Boolean, bool) |
|
3638 DEFINE_RELEASESCALARARRAYELEMENTS(T_BYTE, jbyte, Byte, byte) |
|
3639 DEFINE_RELEASESCALARARRAYELEMENTS(T_SHORT, jshort, Short, short) |
|
3640 DEFINE_RELEASESCALARARRAYELEMENTS(T_CHAR, jchar, Char, char) |
|
3641 DEFINE_RELEASESCALARARRAYELEMENTS(T_INT, jint, Int, int) |
|
3642 DEFINE_RELEASESCALARARRAYELEMENTS(T_LONG, jlong, Long, long) |
|
3643 DEFINE_RELEASESCALARARRAYELEMENTS(T_FLOAT, jfloat, Float, float) |
|
3644 DEFINE_RELEASESCALARARRAYELEMENTS(T_DOUBLE, jdouble, Double, double) |
|
3645 |
|
3646 #else /* USDT2 */ |
|
3647 |
2781 |
3648 #define DEFINE_RELEASESCALARARRAYELEMENTS(ElementTag,ElementType,Result,Tag \ |
2782 #define DEFINE_RELEASESCALARARRAYELEMENTS(ElementTag,ElementType,Result,Tag \ |
3649 , EntryProbe, ReturnProbe);\ |
2783 , EntryProbe, ReturnProbe);\ |
3650 \ |
2784 \ |
3651 JNI_QUICK_ENTRY(void, \ |
2785 JNI_QUICK_ENTRY(void, \ |
3688 , HOTSPOT_JNI_RELEASEFLOATARRAYELEMENTS_ENTRY(env, array, (float *) buf, mode), |
2822 , HOTSPOT_JNI_RELEASEFLOATARRAYELEMENTS_ENTRY(env, array, (float *) buf, mode), |
3689 HOTSPOT_JNI_RELEASEFLOATARRAYELEMENTS_RETURN()) |
2823 HOTSPOT_JNI_RELEASEFLOATARRAYELEMENTS_RETURN()) |
3690 DEFINE_RELEASESCALARARRAYELEMENTS(T_DOUBLE, jdouble, Double, double |
2824 DEFINE_RELEASESCALARARRAYELEMENTS(T_DOUBLE, jdouble, Double, double |
3691 , HOTSPOT_JNI_RELEASEDOUBLEARRAYELEMENTS_ENTRY(env, array, (double *) buf, mode), |
2825 , HOTSPOT_JNI_RELEASEDOUBLEARRAYELEMENTS_ENTRY(env, array, (double *) buf, mode), |
3692 HOTSPOT_JNI_RELEASEDOUBLEARRAYELEMENTS_RETURN()) |
2826 HOTSPOT_JNI_RELEASEDOUBLEARRAYELEMENTS_RETURN()) |
3693 #endif /* USDT2 */ |
2827 |
3694 |
|
3695 #ifndef USDT2 |
|
3696 #define DEFINE_GETSCALARARRAYREGION(ElementTag,ElementType,Result, Tag) \ |
|
3697 DT_VOID_RETURN_MARK_DECL(Get##Result##ArrayRegion);\ |
|
3698 \ |
|
3699 JNI_ENTRY(void, \ |
|
3700 jni_Get##Result##ArrayRegion(JNIEnv *env, ElementType##Array array, jsize start, \ |
|
3701 jsize len, ElementType *buf)) \ |
|
3702 JNIWrapper("Get" XSTR(Result) "ArrayRegion"); \ |
|
3703 DTRACE_PROBE5(hotspot_jni, Get##Result##ArrayRegion__entry, env, array, start, len, buf);\ |
|
3704 DT_VOID_RETURN_MARK(Get##Result##ArrayRegion); \ |
|
3705 typeArrayOop src = typeArrayOop(JNIHandles::resolve_non_null(array)); \ |
|
3706 if (start < 0 || len < 0 || ((unsigned int)start + (unsigned int)len > (unsigned int)src->length())) { \ |
|
3707 THROW(vmSymbols::java_lang_ArrayIndexOutOfBoundsException()); \ |
|
3708 } else { \ |
|
3709 if (len > 0) { \ |
|
3710 int sc = TypeArrayKlass::cast(src->klass())->log2_element_size(); \ |
|
3711 memcpy((u_char*) buf, \ |
|
3712 (u_char*) src->Tag##_at_addr(start), \ |
|
3713 len << sc); \ |
|
3714 } \ |
|
3715 } \ |
|
3716 JNI_END |
|
3717 |
|
3718 DEFINE_GETSCALARARRAYREGION(T_BOOLEAN, jboolean,Boolean, bool) |
|
3719 DEFINE_GETSCALARARRAYREGION(T_BYTE, jbyte, Byte, byte) |
|
3720 DEFINE_GETSCALARARRAYREGION(T_SHORT, jshort, Short, short) |
|
3721 DEFINE_GETSCALARARRAYREGION(T_CHAR, jchar, Char, char) |
|
3722 DEFINE_GETSCALARARRAYREGION(T_INT, jint, Int, int) |
|
3723 DEFINE_GETSCALARARRAYREGION(T_LONG, jlong, Long, long) |
|
3724 DEFINE_GETSCALARARRAYREGION(T_FLOAT, jfloat, Float, float) |
|
3725 DEFINE_GETSCALARARRAYREGION(T_DOUBLE, jdouble, Double, double) |
|
3726 |
|
3727 #else /* USDT2 */ |
|
3728 |
2828 |
3729 #define DEFINE_GETSCALARARRAYREGION(ElementTag,ElementType,Result, Tag \ |
2829 #define DEFINE_GETSCALARARRAYREGION(ElementTag,ElementType,Result, Tag \ |
3730 , EntryProbe, ReturnProbe); \ |
2830 , EntryProbe, ReturnProbe); \ |
3731 DT_VOID_RETURN_MARK_DECL(Get##Result##ArrayRegion \ |
2831 DT_VOID_RETURN_MARK_DECL(Get##Result##ArrayRegion \ |
3732 , ReturnProbe); \ |
2832 , ReturnProbe); \ |
3772 , HOTSPOT_JNI_GETFLOATARRAYREGION_ENTRY(env, array, start, len, (float *) buf), |
2872 , HOTSPOT_JNI_GETFLOATARRAYREGION_ENTRY(env, array, start, len, (float *) buf), |
3773 HOTSPOT_JNI_GETFLOATARRAYREGION_RETURN()); |
2873 HOTSPOT_JNI_GETFLOATARRAYREGION_RETURN()); |
3774 DEFINE_GETSCALARARRAYREGION(T_DOUBLE, jdouble, Double, double |
2874 DEFINE_GETSCALARARRAYREGION(T_DOUBLE, jdouble, Double, double |
3775 , HOTSPOT_JNI_GETDOUBLEARRAYREGION_ENTRY(env, array, start, len, (double *) buf), |
2875 , HOTSPOT_JNI_GETDOUBLEARRAYREGION_ENTRY(env, array, start, len, (double *) buf), |
3776 HOTSPOT_JNI_GETDOUBLEARRAYREGION_RETURN()); |
2876 HOTSPOT_JNI_GETDOUBLEARRAYREGION_RETURN()); |
3777 #endif /* USDT2 */ |
2877 |
3778 |
|
3779 #ifndef USDT2 |
|
3780 #define DEFINE_SETSCALARARRAYREGION(ElementTag,ElementType,Result, Tag) \ |
|
3781 DT_VOID_RETURN_MARK_DECL(Set##Result##ArrayRegion);\ |
|
3782 \ |
|
3783 JNI_ENTRY(void, \ |
|
3784 jni_Set##Result##ArrayRegion(JNIEnv *env, ElementType##Array array, jsize start, \ |
|
3785 jsize len, const ElementType *buf)) \ |
|
3786 JNIWrapper("Set" XSTR(Result) "ArrayRegion"); \ |
|
3787 DTRACE_PROBE5(hotspot_jni, Set##Result##ArrayRegion__entry, env, array, start, len, buf);\ |
|
3788 DT_VOID_RETURN_MARK(Set##Result##ArrayRegion); \ |
|
3789 typeArrayOop dst = typeArrayOop(JNIHandles::resolve_non_null(array)); \ |
|
3790 if (start < 0 || len < 0 || ((unsigned int)start + (unsigned int)len > (unsigned int)dst->length())) { \ |
|
3791 THROW(vmSymbols::java_lang_ArrayIndexOutOfBoundsException()); \ |
|
3792 } else { \ |
|
3793 if (len > 0) { \ |
|
3794 int sc = TypeArrayKlass::cast(dst->klass())->log2_element_size(); \ |
|
3795 memcpy((u_char*) dst->Tag##_at_addr(start), \ |
|
3796 (u_char*) buf, \ |
|
3797 len << sc); \ |
|
3798 } \ |
|
3799 } \ |
|
3800 JNI_END |
|
3801 |
|
3802 DEFINE_SETSCALARARRAYREGION(T_BOOLEAN, jboolean, Boolean, bool) |
|
3803 DEFINE_SETSCALARARRAYREGION(T_BYTE, jbyte, Byte, byte) |
|
3804 DEFINE_SETSCALARARRAYREGION(T_SHORT, jshort, Short, short) |
|
3805 DEFINE_SETSCALARARRAYREGION(T_CHAR, jchar, Char, char) |
|
3806 DEFINE_SETSCALARARRAYREGION(T_INT, jint, Int, int) |
|
3807 DEFINE_SETSCALARARRAYREGION(T_LONG, jlong, Long, long) |
|
3808 DEFINE_SETSCALARARRAYREGION(T_FLOAT, jfloat, Float, float) |
|
3809 DEFINE_SETSCALARARRAYREGION(T_DOUBLE, jdouble, Double, double) |
|
3810 |
|
3811 #else /* USDT2 */ |
|
3812 |
2878 |
3813 #define DEFINE_SETSCALARARRAYREGION(ElementTag,ElementType,Result, Tag \ |
2879 #define DEFINE_SETSCALARARRAYREGION(ElementTag,ElementType,Result, Tag \ |
3814 , EntryProbe, ReturnProbe); \ |
2880 , EntryProbe, ReturnProbe); \ |
3815 DT_VOID_RETURN_MARK_DECL(Set##Result##ArrayRegion \ |
2881 DT_VOID_RETURN_MARK_DECL(Set##Result##ArrayRegion \ |
3816 ,ReturnProbe); \ |
2882 ,ReturnProbe); \ |
4081 |
3114 |
4082 // |
3115 // |
4083 // Extensions |
3116 // Extensions |
4084 // |
3117 // |
4085 |
3118 |
4086 #ifndef USDT2 |
|
4087 DT_VOID_RETURN_MARK_DECL(GetStringRegion); |
|
4088 #else /* USDT2 */ |
|
4089 DT_VOID_RETURN_MARK_DECL(GetStringRegion |
3119 DT_VOID_RETURN_MARK_DECL(GetStringRegion |
4090 , HOTSPOT_JNI_GETSTRINGREGION_RETURN()); |
3120 , HOTSPOT_JNI_GETSTRINGREGION_RETURN()); |
4091 #endif /* USDT2 */ |
|
4092 |
3121 |
4093 JNI_ENTRY(void, jni_GetStringRegion(JNIEnv *env, jstring string, jsize start, jsize len, jchar *buf)) |
3122 JNI_ENTRY(void, jni_GetStringRegion(JNIEnv *env, jstring string, jsize start, jsize len, jchar *buf)) |
4094 JNIWrapper("GetStringRegion"); |
3123 JNIWrapper("GetStringRegion"); |
4095 #ifndef USDT2 |
|
4096 DTRACE_PROBE5(hotspot_jni, GetStringRegion__entry, env, string, start, len, buf); |
|
4097 #else /* USDT2 */ |
|
4098 HOTSPOT_JNI_GETSTRINGREGION_ENTRY(env, string, start, len, buf); |
3124 HOTSPOT_JNI_GETSTRINGREGION_ENTRY(env, string, start, len, buf); |
4099 #endif /* USDT2 */ |
|
4100 DT_VOID_RETURN_MARK(GetStringRegion); |
3125 DT_VOID_RETURN_MARK(GetStringRegion); |
4101 oop s = JNIHandles::resolve_non_null(string); |
3126 oop s = JNIHandles::resolve_non_null(string); |
4102 int s_len = java_lang_String::length(s); |
3127 int s_len = java_lang_String::length(s); |
4103 if (start < 0 || len < 0 || start + len > s_len) { |
3128 if (start < 0 || len < 0 || start + len > s_len) { |
4104 THROW(vmSymbols::java_lang_StringIndexOutOfBoundsException()); |
3129 THROW(vmSymbols::java_lang_StringIndexOutOfBoundsException()); |
4109 memcpy(buf, s_value->char_at_addr(s_offset+start), sizeof(jchar)*len); |
3134 memcpy(buf, s_value->char_at_addr(s_offset+start), sizeof(jchar)*len); |
4110 } |
3135 } |
4111 } |
3136 } |
4112 JNI_END |
3137 JNI_END |
4113 |
3138 |
4114 #ifndef USDT2 |
|
4115 DT_VOID_RETURN_MARK_DECL(GetStringUTFRegion); |
|
4116 #else /* USDT2 */ |
|
4117 DT_VOID_RETURN_MARK_DECL(GetStringUTFRegion |
3139 DT_VOID_RETURN_MARK_DECL(GetStringUTFRegion |
4118 , HOTSPOT_JNI_GETSTRINGUTFREGION_RETURN()); |
3140 , HOTSPOT_JNI_GETSTRINGUTFREGION_RETURN()); |
4119 #endif /* USDT2 */ |
|
4120 |
3141 |
4121 JNI_ENTRY(void, jni_GetStringUTFRegion(JNIEnv *env, jstring string, jsize start, jsize len, char *buf)) |
3142 JNI_ENTRY(void, jni_GetStringUTFRegion(JNIEnv *env, jstring string, jsize start, jsize len, char *buf)) |
4122 JNIWrapper("GetStringUTFRegion"); |
3143 JNIWrapper("GetStringUTFRegion"); |
4123 #ifndef USDT2 |
|
4124 DTRACE_PROBE5(hotspot_jni, GetStringUTFRegion__entry, env, string, start, len, buf); |
|
4125 #else /* USDT2 */ |
|
4126 HOTSPOT_JNI_GETSTRINGUTFREGION_ENTRY(env, string, start, len, buf); |
3144 HOTSPOT_JNI_GETSTRINGUTFREGION_ENTRY(env, string, start, len, buf); |
4127 #endif /* USDT2 */ |
|
4128 DT_VOID_RETURN_MARK(GetStringUTFRegion); |
3145 DT_VOID_RETURN_MARK(GetStringUTFRegion); |
4129 oop s = JNIHandles::resolve_non_null(string); |
3146 oop s = JNIHandles::resolve_non_null(string); |
4130 int s_len = java_lang_String::length(s); |
3147 int s_len = java_lang_String::length(s); |
4131 if (start < 0 || len < 0 || start + len > s_len) { |
3148 if (start < 0 || len < 0 || start + len > s_len) { |
4132 THROW(vmSymbols::java_lang_StringIndexOutOfBoundsException()); |
3149 THROW(vmSymbols::java_lang_StringIndexOutOfBoundsException()); |
4166 type = T_OBJECT; |
3179 type = T_OBJECT; |
4167 } else { |
3180 } else { |
4168 type = TypeArrayKlass::cast(a->klass())->element_type(); |
3181 type = TypeArrayKlass::cast(a->klass())->element_type(); |
4169 } |
3182 } |
4170 void* ret = arrayOop(a)->base(type); |
3183 void* ret = arrayOop(a)->base(type); |
4171 #ifndef USDT2 |
|
4172 DTRACE_PROBE1(hotspot_jni, GetPrimitiveArrayCritical__return, ret); |
|
4173 #else /* USDT2 */ |
|
4174 HOTSPOT_JNI_GETPRIMITIVEARRAYCRITICAL_RETURN(ret); |
3184 HOTSPOT_JNI_GETPRIMITIVEARRAYCRITICAL_RETURN(ret); |
4175 #endif /* USDT2 */ |
|
4176 return ret; |
3185 return ret; |
4177 JNI_END |
3186 JNI_END |
4178 |
3187 |
4179 |
3188 |
4180 JNI_ENTRY(void, jni_ReleasePrimitiveArrayCritical(JNIEnv *env, jarray array, void *carray, jint mode)) |
3189 JNI_ENTRY(void, jni_ReleasePrimitiveArrayCritical(JNIEnv *env, jarray array, void *carray, jint mode)) |
4181 JNIWrapper("ReleasePrimitiveArrayCritical"); |
3190 JNIWrapper("ReleasePrimitiveArrayCritical"); |
4182 #ifndef USDT2 |
|
4183 DTRACE_PROBE4(hotspot_jni, ReleasePrimitiveArrayCritical__entry, env, array, carray, mode); |
|
4184 #else /* USDT2 */ |
|
4185 HOTSPOT_JNI_RELEASEPRIMITIVEARRAYCRITICAL_ENTRY(env, array, carray, mode); |
3191 HOTSPOT_JNI_RELEASEPRIMITIVEARRAYCRITICAL_ENTRY(env, array, carray, mode); |
4186 #endif /* USDT2 */ |
|
4187 // The array, carray and mode arguments are ignored |
3192 // The array, carray and mode arguments are ignored |
4188 GC_locker::unlock_critical(thread); |
3193 GC_locker::unlock_critical(thread); |
4189 #ifndef USDT2 |
|
4190 DTRACE_PROBE(hotspot_jni, ReleasePrimitiveArrayCritical__return); |
|
4191 #else /* USDT2 */ |
|
4192 HOTSPOT_JNI_RELEASEPRIMITIVEARRAYCRITICAL_RETURN(); |
3194 HOTSPOT_JNI_RELEASEPRIMITIVEARRAYCRITICAL_RETURN(); |
4193 #endif /* USDT2 */ |
|
4194 JNI_END |
3195 JNI_END |
4195 |
3196 |
4196 |
3197 |
4197 JNI_ENTRY(const jchar*, jni_GetStringCritical(JNIEnv *env, jstring string, jboolean *isCopy)) |
3198 JNI_ENTRY(const jchar*, jni_GetStringCritical(JNIEnv *env, jstring string, jboolean *isCopy)) |
4198 JNIWrapper("GetStringCritical"); |
3199 JNIWrapper("GetStringCritical"); |
4199 #ifndef USDT2 |
|
4200 DTRACE_PROBE3(hotspot_jni, GetStringCritical__entry, env, string, isCopy); |
|
4201 #else /* USDT2 */ |
|
4202 HOTSPOT_JNI_GETSTRINGCRITICAL_ENTRY(env, string, (uintptr_t *) isCopy); |
3200 HOTSPOT_JNI_GETSTRINGCRITICAL_ENTRY(env, string, (uintptr_t *) isCopy); |
4203 #endif /* USDT2 */ |
|
4204 GC_locker::lock_critical(thread); |
3201 GC_locker::lock_critical(thread); |
4205 if (isCopy != NULL) { |
3202 if (isCopy != NULL) { |
4206 *isCopy = JNI_FALSE; |
3203 *isCopy = JNI_FALSE; |
4207 } |
3204 } |
4208 oop s = JNIHandles::resolve_non_null(string); |
3205 oop s = JNIHandles::resolve_non_null(string); |
4213 if (s_len > 0) { |
3210 if (s_len > 0) { |
4214 ret = s_value->char_at_addr(s_offset); |
3211 ret = s_value->char_at_addr(s_offset); |
4215 } else { |
3212 } else { |
4216 ret = (jchar*) s_value->base(T_CHAR); |
3213 ret = (jchar*) s_value->base(T_CHAR); |
4217 } |
3214 } |
4218 #ifndef USDT2 |
|
4219 DTRACE_PROBE1(hotspot_jni, GetStringCritical__return, ret); |
|
4220 #else /* USDT2 */ |
|
4221 HOTSPOT_JNI_GETSTRINGCRITICAL_RETURN((uint16_t *) ret); |
3215 HOTSPOT_JNI_GETSTRINGCRITICAL_RETURN((uint16_t *) ret); |
4222 #endif /* USDT2 */ |
|
4223 return ret; |
3216 return ret; |
4224 JNI_END |
3217 JNI_END |
4225 |
3218 |
4226 |
3219 |
4227 JNI_ENTRY(void, jni_ReleaseStringCritical(JNIEnv *env, jstring str, const jchar *chars)) |
3220 JNI_ENTRY(void, jni_ReleaseStringCritical(JNIEnv *env, jstring str, const jchar *chars)) |
4228 JNIWrapper("ReleaseStringCritical"); |
3221 JNIWrapper("ReleaseStringCritical"); |
4229 #ifndef USDT2 |
|
4230 DTRACE_PROBE3(hotspot_jni, ReleaseStringCritical__entry, env, str, chars); |
|
4231 #else /* USDT2 */ |
|
4232 HOTSPOT_JNI_RELEASESTRINGCRITICAL_ENTRY(env, str, (uint16_t *) chars); |
3222 HOTSPOT_JNI_RELEASESTRINGCRITICAL_ENTRY(env, str, (uint16_t *) chars); |
4233 #endif /* USDT2 */ |
|
4234 // The str and chars arguments are ignored |
3223 // The str and chars arguments are ignored |
4235 GC_locker::unlock_critical(thread); |
3224 GC_locker::unlock_critical(thread); |
4236 #ifndef USDT2 |
|
4237 DTRACE_PROBE(hotspot_jni, ReleaseStringCritical__return); |
|
4238 #else /* USDT2 */ |
|
4239 HOTSPOT_JNI_RELEASESTRINGCRITICAL_RETURN(); |
3225 HOTSPOT_JNI_RELEASESTRINGCRITICAL_RETURN(); |
4240 #endif /* USDT2 */ |
|
4241 JNI_END |
3226 JNI_END |
4242 |
3227 |
4243 |
3228 |
4244 JNI_ENTRY(jweak, jni_NewWeakGlobalRef(JNIEnv *env, jobject ref)) |
3229 JNI_ENTRY(jweak, jni_NewWeakGlobalRef(JNIEnv *env, jobject ref)) |
4245 JNIWrapper("jni_NewWeakGlobalRef"); |
3230 JNIWrapper("jni_NewWeakGlobalRef"); |
4246 #ifndef USDT2 |
|
4247 DTRACE_PROBE2(hotspot_jni, NewWeakGlobalRef__entry, env, ref); |
|
4248 #else /* USDT2 */ |
|
4249 HOTSPOT_JNI_NEWWEAKGLOBALREF_ENTRY(env, ref); |
3231 HOTSPOT_JNI_NEWWEAKGLOBALREF_ENTRY(env, ref); |
4250 #endif /* USDT2 */ |
|
4251 Handle ref_handle(thread, JNIHandles::resolve(ref)); |
3232 Handle ref_handle(thread, JNIHandles::resolve(ref)); |
4252 jweak ret = JNIHandles::make_weak_global(ref_handle); |
3233 jweak ret = JNIHandles::make_weak_global(ref_handle); |
4253 #ifndef USDT2 |
|
4254 DTRACE_PROBE1(hotspot_jni, NewWeakGlobalRef__return, ret); |
|
4255 #else /* USDT2 */ |
|
4256 HOTSPOT_JNI_NEWWEAKGLOBALREF_RETURN(ret); |
3234 HOTSPOT_JNI_NEWWEAKGLOBALREF_RETURN(ret); |
4257 #endif /* USDT2 */ |
|
4258 return ret; |
3235 return ret; |
4259 JNI_END |
3236 JNI_END |
4260 |
3237 |
4261 // Must be JNI_ENTRY (with HandleMark) |
3238 // Must be JNI_ENTRY (with HandleMark) |
4262 JNI_ENTRY(void, jni_DeleteWeakGlobalRef(JNIEnv *env, jweak ref)) |
3239 JNI_ENTRY(void, jni_DeleteWeakGlobalRef(JNIEnv *env, jweak ref)) |
4263 JNIWrapper("jni_DeleteWeakGlobalRef"); |
3240 JNIWrapper("jni_DeleteWeakGlobalRef"); |
4264 #ifndef USDT2 |
|
4265 DTRACE_PROBE2(hotspot_jni, DeleteWeakGlobalRef__entry, env, ref); |
|
4266 #else /* USDT2 */ |
|
4267 HOTSPOT_JNI_DELETEWEAKGLOBALREF_ENTRY(env, ref); |
3241 HOTSPOT_JNI_DELETEWEAKGLOBALREF_ENTRY(env, ref); |
4268 #endif /* USDT2 */ |
|
4269 JNIHandles::destroy_weak_global(ref); |
3242 JNIHandles::destroy_weak_global(ref); |
4270 #ifndef USDT2 |
|
4271 DTRACE_PROBE(hotspot_jni, DeleteWeakGlobalRef__return); |
|
4272 #else /* USDT2 */ |
|
4273 HOTSPOT_JNI_DELETEWEAKGLOBALREF_RETURN(); |
3243 HOTSPOT_JNI_DELETEWEAKGLOBALREF_RETURN(); |
4274 #endif /* USDT2 */ |
|
4275 JNI_END |
3244 JNI_END |
4276 |
3245 |
4277 |
3246 |
4278 JNI_QUICK_ENTRY(jboolean, jni_ExceptionCheck(JNIEnv *env)) |
3247 JNI_QUICK_ENTRY(jboolean, jni_ExceptionCheck(JNIEnv *env)) |
4279 JNIWrapper("jni_ExceptionCheck"); |
3248 JNIWrapper("jni_ExceptionCheck"); |
4280 #ifndef USDT2 |
|
4281 DTRACE_PROBE1(hotspot_jni, ExceptionCheck__entry, env); |
|
4282 #else /* USDT2 */ |
|
4283 HOTSPOT_JNI_EXCEPTIONCHECK_ENTRY(env); |
3249 HOTSPOT_JNI_EXCEPTIONCHECK_ENTRY(env); |
4284 #endif /* USDT2 */ |
|
4285 jni_check_async_exceptions(thread); |
3250 jni_check_async_exceptions(thread); |
4286 jboolean ret = (thread->has_pending_exception()) ? JNI_TRUE : JNI_FALSE; |
3251 jboolean ret = (thread->has_pending_exception()) ? JNI_TRUE : JNI_FALSE; |
4287 #ifndef USDT2 |
|
4288 DTRACE_PROBE1(hotspot_jni, ExceptionCheck__return, ret); |
|
4289 #else /* USDT2 */ |
|
4290 HOTSPOT_JNI_EXCEPTIONCHECK_RETURN(ret); |
3252 HOTSPOT_JNI_EXCEPTIONCHECK_RETURN(ret); |
4291 #endif /* USDT2 */ |
|
4292 return ret; |
3253 return ret; |
4293 JNI_END |
3254 JNI_END |
4294 |
3255 |
4295 |
3256 |
4296 // Initialization state for three routines below relating to |
3257 // Initialization state for three routines below relating to |
4393 { |
3354 { |
4394 // thread_from_jni_environment() will block if VM is gone. |
3355 // thread_from_jni_environment() will block if VM is gone. |
4395 JavaThread* thread = JavaThread::thread_from_jni_environment(env); |
3356 JavaThread* thread = JavaThread::thread_from_jni_environment(env); |
4396 |
3357 |
4397 JNIWrapper("jni_NewDirectByteBuffer"); |
3358 JNIWrapper("jni_NewDirectByteBuffer"); |
4398 #ifndef USDT2 |
|
4399 DTRACE_PROBE3(hotspot_jni, NewDirectByteBuffer__entry, env, address, capacity); |
|
4400 #else /* USDT2 */ |
|
4401 HOTSPOT_JNI_NEWDIRECTBYTEBUFFER_ENTRY(env, address, capacity); |
3359 HOTSPOT_JNI_NEWDIRECTBYTEBUFFER_ENTRY(env, address, capacity); |
4402 #endif /* USDT2 */ |
|
4403 |
3360 |
4404 if (!directBufferSupportInitializeEnded) { |
3361 if (!directBufferSupportInitializeEnded) { |
4405 if (!initializeDirectBufferSupport(env, thread)) { |
3362 if (!initializeDirectBufferSupport(env, thread)) { |
4406 #ifndef USDT2 |
|
4407 DTRACE_PROBE1(hotspot_jni, NewDirectByteBuffer__return, NULL); |
|
4408 #else /* USDT2 */ |
|
4409 HOTSPOT_JNI_NEWDIRECTBYTEBUFFER_RETURN(NULL); |
3363 HOTSPOT_JNI_NEWDIRECTBYTEBUFFER_RETURN(NULL); |
4410 #endif /* USDT2 */ |
|
4411 return NULL; |
3364 return NULL; |
4412 } |
3365 } |
4413 } |
3366 } |
4414 |
3367 |
4415 // Being paranoid about accidental sign extension on address |
3368 // Being paranoid about accidental sign extension on address |
4416 jlong addr = (jlong) ((uintptr_t) address); |
3369 jlong addr = (jlong) ((uintptr_t) address); |
4417 // NOTE that package-private DirectByteBuffer constructor currently |
3370 // NOTE that package-private DirectByteBuffer constructor currently |
4418 // takes int capacity |
3371 // takes int capacity |
4419 jint cap = (jint) capacity; |
3372 jint cap = (jint) capacity; |
4420 jobject ret = env->NewObject(directByteBufferClass, directByteBufferConstructor, addr, cap); |
3373 jobject ret = env->NewObject(directByteBufferClass, directByteBufferConstructor, addr, cap); |
4421 #ifndef USDT2 |
|
4422 DTRACE_PROBE1(hotspot_jni, NewDirectByteBuffer__return, ret); |
|
4423 #else /* USDT2 */ |
|
4424 HOTSPOT_JNI_NEWDIRECTBYTEBUFFER_RETURN(ret); |
3374 HOTSPOT_JNI_NEWDIRECTBYTEBUFFER_RETURN(ret); |
4425 #endif /* USDT2 */ |
|
4426 return ret; |
3375 return ret; |
4427 } |
3376 } |
4428 |
3377 |
4429 #ifndef USDT2 |
|
4430 DT_RETURN_MARK_DECL(GetDirectBufferAddress, void*); |
|
4431 #else /* USDT2 */ |
|
4432 DT_RETURN_MARK_DECL(GetDirectBufferAddress, void* |
3378 DT_RETURN_MARK_DECL(GetDirectBufferAddress, void* |
4433 , HOTSPOT_JNI_GETDIRECTBUFFERADDRESS_RETURN((void*) _ret_ref)); |
3379 , HOTSPOT_JNI_GETDIRECTBUFFERADDRESS_RETURN((void*) _ret_ref)); |
4434 #endif /* USDT2 */ |
|
4435 |
3380 |
4436 extern "C" void* JNICALL jni_GetDirectBufferAddress(JNIEnv *env, jobject buf) |
3381 extern "C" void* JNICALL jni_GetDirectBufferAddress(JNIEnv *env, jobject buf) |
4437 { |
3382 { |
4438 // thread_from_jni_environment() will block if VM is gone. |
3383 // thread_from_jni_environment() will block if VM is gone. |
4439 JavaThread* thread = JavaThread::thread_from_jni_environment(env); |
3384 JavaThread* thread = JavaThread::thread_from_jni_environment(env); |
4440 |
3385 |
4441 JNIWrapper("jni_GetDirectBufferAddress"); |
3386 JNIWrapper("jni_GetDirectBufferAddress"); |
4442 #ifndef USDT2 |
|
4443 DTRACE_PROBE2(hotspot_jni, GetDirectBufferAddress__entry, env, buf); |
|
4444 #else /* USDT2 */ |
|
4445 HOTSPOT_JNI_GETDIRECTBUFFERADDRESS_ENTRY(env, buf); |
3387 HOTSPOT_JNI_GETDIRECTBUFFERADDRESS_ENTRY(env, buf); |
4446 #endif /* USDT2 */ |
|
4447 void* ret = NULL; |
3388 void* ret = NULL; |
4448 DT_RETURN_MARK(GetDirectBufferAddress, void*, (const void*&)ret); |
3389 DT_RETURN_MARK(GetDirectBufferAddress, void*, (const void*&)ret); |
4449 |
3390 |
4450 if (!directBufferSupportInitializeEnded) { |
3391 if (!directBufferSupportInitializeEnded) { |
4451 if (!initializeDirectBufferSupport(env, thread)) { |
3392 if (!initializeDirectBufferSupport(env, thread)) { |
4459 |
3400 |
4460 ret = (void*)(intptr_t)env->GetLongField(buf, directBufferAddressField); |
3401 ret = (void*)(intptr_t)env->GetLongField(buf, directBufferAddressField); |
4461 return ret; |
3402 return ret; |
4462 } |
3403 } |
4463 |
3404 |
4464 #ifndef USDT2 |
|
4465 DT_RETURN_MARK_DECL(GetDirectBufferCapacity, jlong); |
|
4466 #else /* USDT2 */ |
|
4467 DT_RETURN_MARK_DECL(GetDirectBufferCapacity, jlong |
3405 DT_RETURN_MARK_DECL(GetDirectBufferCapacity, jlong |
4468 , HOTSPOT_JNI_GETDIRECTBUFFERCAPACITY_RETURN(_ret_ref)); |
3406 , HOTSPOT_JNI_GETDIRECTBUFFERCAPACITY_RETURN(_ret_ref)); |
4469 #endif /* USDT2 */ |
|
4470 |
3407 |
4471 extern "C" jlong JNICALL jni_GetDirectBufferCapacity(JNIEnv *env, jobject buf) |
3408 extern "C" jlong JNICALL jni_GetDirectBufferCapacity(JNIEnv *env, jobject buf) |
4472 { |
3409 { |
4473 // thread_from_jni_environment() will block if VM is gone. |
3410 // thread_from_jni_environment() will block if VM is gone. |
4474 JavaThread* thread = JavaThread::thread_from_jni_environment(env); |
3411 JavaThread* thread = JavaThread::thread_from_jni_environment(env); |
4475 |
3412 |
4476 JNIWrapper("jni_GetDirectBufferCapacity"); |
3413 JNIWrapper("jni_GetDirectBufferCapacity"); |
4477 #ifndef USDT2 |
|
4478 DTRACE_PROBE2(hotspot_jni, GetDirectBufferCapacity__entry, env, buf); |
|
4479 #else /* USDT2 */ |
|
4480 HOTSPOT_JNI_GETDIRECTBUFFERCAPACITY_ENTRY(env, buf); |
3414 HOTSPOT_JNI_GETDIRECTBUFFERCAPACITY_ENTRY(env, buf); |
4481 #endif /* USDT2 */ |
|
4482 jlong ret = -1; |
3415 jlong ret = -1; |
4483 DT_RETURN_MARK(GetDirectBufferCapacity, jlong, (const jlong&)ret); |
3416 DT_RETURN_MARK(GetDirectBufferCapacity, jlong, (const jlong&)ret); |
4484 |
3417 |
4485 if (!directBufferSupportInitializeEnded) { |
3418 if (!directBufferSupportInitializeEnded) { |
4486 if (!initializeDirectBufferSupport(env, thread)) { |
3419 if (!initializeDirectBufferSupport(env, thread)) { |
4503 } |
3436 } |
4504 |
3437 |
4505 |
3438 |
4506 JNI_LEAF(jint, jni_GetVersion(JNIEnv *env)) |
3439 JNI_LEAF(jint, jni_GetVersion(JNIEnv *env)) |
4507 JNIWrapper("GetVersion"); |
3440 JNIWrapper("GetVersion"); |
4508 #ifndef USDT2 |
|
4509 DTRACE_PROBE1(hotspot_jni, GetVersion__entry, env); |
|
4510 #else /* USDT2 */ |
|
4511 HOTSPOT_JNI_GETVERSION_ENTRY(env); |
3441 HOTSPOT_JNI_GETVERSION_ENTRY(env); |
4512 #endif /* USDT2 */ |
|
4513 #ifndef USDT2 |
|
4514 DTRACE_PROBE1(hotspot_jni, GetVersion__return, CurrentVersion); |
|
4515 #else /* USDT2 */ |
|
4516 HOTSPOT_JNI_GETVERSION_RETURN(CurrentVersion); |
3442 HOTSPOT_JNI_GETVERSION_RETURN(CurrentVersion); |
4517 #endif /* USDT2 */ |
|
4518 return CurrentVersion; |
3443 return CurrentVersion; |
4519 JNI_END |
3444 JNI_END |
4520 |
3445 |
4521 extern struct JavaVM_ main_vm; |
3446 extern struct JavaVM_ main_vm; |
4522 |
3447 |
4523 JNI_LEAF(jint, jni_GetJavaVM(JNIEnv *env, JavaVM **vm)) |
3448 JNI_LEAF(jint, jni_GetJavaVM(JNIEnv *env, JavaVM **vm)) |
4524 JNIWrapper("jni_GetJavaVM"); |
3449 JNIWrapper("jni_GetJavaVM"); |
4525 #ifndef USDT2 |
|
4526 DTRACE_PROBE2(hotspot_jni, GetJavaVM__entry, env, vm); |
|
4527 #else /* USDT2 */ |
|
4528 HOTSPOT_JNI_GETJAVAVM_ENTRY(env, (void **) vm); |
3450 HOTSPOT_JNI_GETJAVAVM_ENTRY(env, (void **) vm); |
4529 #endif /* USDT2 */ |
|
4530 *vm = (JavaVM *)(&main_vm); |
3451 *vm = (JavaVM *)(&main_vm); |
4531 #ifndef USDT2 |
|
4532 DTRACE_PROBE1(hotspot_jni, GetJavaVM__return, JNI_OK); |
|
4533 #else /* USDT2 */ |
|
4534 HOTSPOT_JNI_GETJAVAVM_RETURN(JNI_OK); |
3452 HOTSPOT_JNI_GETJAVAVM_RETURN(JNI_OK); |
4535 #endif /* USDT2 */ |
|
4536 return JNI_OK; |
3453 return JNI_OK; |
4537 JNI_END |
3454 JNI_END |
4538 |
3455 |
4539 // Structure containing all jni functions |
3456 // Structure containing all jni functions |
4540 struct JNINativeInterface_ jni_NativeInterface = { |
3457 struct JNINativeInterface_ jni_NativeInterface = { |
5142 } |
4041 } |
5143 |
4042 |
5144 return result; |
4043 return result; |
5145 } |
4044 } |
5146 |
4045 |
5147 #ifndef USDT2 |
|
5148 HS_DTRACE_PROBE_DECL3(hotspot_jni, GetCreatedJavaVMs__entry, \ |
|
5149 JavaVM**, jsize, jsize*); |
|
5150 HS_DTRACE_PROBE_DECL1(hotspot_jni, GetCreatedJavaVMs__return, jint); |
|
5151 #endif /* !USDT2 */ |
|
5152 |
4046 |
5153 _JNI_IMPORT_OR_EXPORT_ jint JNICALL JNI_GetCreatedJavaVMs(JavaVM **vm_buf, jsize bufLen, jsize *numVMs) { |
4047 _JNI_IMPORT_OR_EXPORT_ jint JNICALL JNI_GetCreatedJavaVMs(JavaVM **vm_buf, jsize bufLen, jsize *numVMs) { |
5154 // See bug 4367188, the wrapper can sometimes cause VM crashes |
4048 // See bug 4367188, the wrapper can sometimes cause VM crashes |
5155 // JNIWrapper("GetCreatedJavaVMs"); |
4049 // JNIWrapper("GetCreatedJavaVMs"); |
5156 #ifndef USDT2 |
4050 |
5157 HS_DTRACE_PROBE3(hotspot_jni, GetCreatedJavaVMs__entry, \ |
|
5158 vm_buf, bufLen, numVMs); |
|
5159 #else /* USDT2 */ |
|
5160 HOTSPOT_JNI_GETCREATEDJAVAVMS_ENTRY((void **) vm_buf, bufLen, (uintptr_t *) numVMs); |
4051 HOTSPOT_JNI_GETCREATEDJAVAVMS_ENTRY((void **) vm_buf, bufLen, (uintptr_t *) numVMs); |
5161 #endif /* USDT2 */ |
4052 |
5162 if (vm_created) { |
4053 if (vm_created) { |
5163 if (numVMs != NULL) *numVMs = 1; |
4054 if (numVMs != NULL) *numVMs = 1; |
5164 if (bufLen > 0) *vm_buf = (JavaVM *)(&main_vm); |
4055 if (bufLen > 0) *vm_buf = (JavaVM *)(&main_vm); |
5165 } else { |
4056 } else { |
5166 if (numVMs != NULL) *numVMs = 0; |
4057 if (numVMs != NULL) *numVMs = 0; |
5167 } |
4058 } |
5168 #ifndef USDT2 |
|
5169 HS_DTRACE_PROBE1(hotspot_jni, GetCreatedJavaVMs__return, JNI_OK); |
|
5170 #else /* USDT2 */ |
|
5171 HOTSPOT_JNI_GETCREATEDJAVAVMS_RETURN(JNI_OK); |
4059 HOTSPOT_JNI_GETCREATEDJAVAVMS_RETURN(JNI_OK); |
5172 #endif /* USDT2 */ |
|
5173 return JNI_OK; |
4060 return JNI_OK; |
5174 } |
4061 } |
5175 |
4062 |
5176 extern "C" { |
4063 extern "C" { |
5177 |
4064 |
5178 #ifndef USDT2 |
|
5179 DT_RETURN_MARK_DECL(DestroyJavaVM, jint); |
|
5180 #else /* USDT2 */ |
|
5181 DT_RETURN_MARK_DECL(DestroyJavaVM, jint |
4065 DT_RETURN_MARK_DECL(DestroyJavaVM, jint |
5182 , HOTSPOT_JNI_DESTROYJAVAVM_RETURN(_ret_ref)); |
4066 , HOTSPOT_JNI_DESTROYJAVAVM_RETURN(_ret_ref)); |
5183 #endif /* USDT2 */ |
|
5184 |
4067 |
5185 jint JNICALL jni_DestroyJavaVM(JavaVM *vm) { |
4068 jint JNICALL jni_DestroyJavaVM(JavaVM *vm) { |
5186 #ifndef USDT2 |
|
5187 DTRACE_PROBE1(hotspot_jni, DestroyJavaVM__entry, vm); |
|
5188 #else /* USDT2 */ |
|
5189 HOTSPOT_JNI_DESTROYJAVAVM_ENTRY(vm); |
4069 HOTSPOT_JNI_DESTROYJAVAVM_ENTRY(vm); |
5190 #endif /* USDT2 */ |
|
5191 jint res = JNI_ERR; |
4070 jint res = JNI_ERR; |
5192 DT_RETURN_MARK(DestroyJavaVM, jint, (const jint&)res); |
4071 DT_RETURN_MARK(DestroyJavaVM, jint, (const jint&)res); |
5193 |
4072 |
5194 if (!vm_created) { |
4073 if (!vm_created) { |
5195 res = JNI_ERR; |
4074 res = JNI_ERR; |
5337 return JNI_OK; |
4216 return JNI_OK; |
5338 } |
4217 } |
5339 |
4218 |
5340 |
4219 |
5341 jint JNICALL jni_AttachCurrentThread(JavaVM *vm, void **penv, void *_args) { |
4220 jint JNICALL jni_AttachCurrentThread(JavaVM *vm, void **penv, void *_args) { |
5342 #ifndef USDT2 |
|
5343 DTRACE_PROBE3(hotspot_jni, AttachCurrentThread__entry, vm, penv, _args); |
|
5344 #else /* USDT2 */ |
|
5345 HOTSPOT_JNI_ATTACHCURRENTTHREAD_ENTRY(vm, penv, _args); |
4221 HOTSPOT_JNI_ATTACHCURRENTTHREAD_ENTRY(vm, penv, _args); |
5346 #endif /* USDT2 */ |
|
5347 if (!vm_created) { |
4222 if (!vm_created) { |
5348 #ifndef USDT2 |
|
5349 DTRACE_PROBE1(hotspot_jni, AttachCurrentThread__return, JNI_ERR); |
|
5350 #else /* USDT2 */ |
|
5351 HOTSPOT_JNI_ATTACHCURRENTTHREAD_RETURN((uint32_t) JNI_ERR); |
4223 HOTSPOT_JNI_ATTACHCURRENTTHREAD_RETURN((uint32_t) JNI_ERR); |
5352 #endif /* USDT2 */ |
|
5353 return JNI_ERR; |
4224 return JNI_ERR; |
5354 } |
4225 } |
5355 |
4226 |
5356 JNIWrapper("AttachCurrentThread"); |
4227 JNIWrapper("AttachCurrentThread"); |
5357 jint ret = attach_current_thread(vm, penv, _args, false); |
4228 jint ret = attach_current_thread(vm, penv, _args, false); |
5358 #ifndef USDT2 |
|
5359 DTRACE_PROBE1(hotspot_jni, AttachCurrentThread__return, ret); |
|
5360 #else /* USDT2 */ |
|
5361 HOTSPOT_JNI_ATTACHCURRENTTHREAD_RETURN(ret); |
4229 HOTSPOT_JNI_ATTACHCURRENTTHREAD_RETURN(ret); |
5362 #endif /* USDT2 */ |
|
5363 return ret; |
4230 return ret; |
5364 } |
4231 } |
5365 |
4232 |
5366 |
4233 |
5367 jint JNICALL jni_DetachCurrentThread(JavaVM *vm) { |
4234 jint JNICALL jni_DetachCurrentThread(JavaVM *vm) { |
5368 #ifndef USDT2 |
|
5369 DTRACE_PROBE1(hotspot_jni, DetachCurrentThread__entry, vm); |
|
5370 #else /* USDT2 */ |
|
5371 HOTSPOT_JNI_DETACHCURRENTTHREAD_ENTRY(vm); |
4235 HOTSPOT_JNI_DETACHCURRENTTHREAD_ENTRY(vm); |
5372 #endif /* USDT2 */ |
|
5373 VM_Exit::block_if_vm_exited(); |
4236 VM_Exit::block_if_vm_exited(); |
5374 |
4237 |
5375 JNIWrapper("DetachCurrentThread"); |
4238 JNIWrapper("DetachCurrentThread"); |
5376 |
4239 |
5377 // If the thread has been deattacted the operations is a no-op |
4240 // If the thread has been deattacted the operations is a no-op |
5378 if (ThreadLocalStorage::thread() == NULL) { |
4241 if (ThreadLocalStorage::thread() == NULL) { |
5379 #ifndef USDT2 |
|
5380 DTRACE_PROBE1(hotspot_jni, DetachCurrentThread__return, JNI_OK); |
|
5381 #else /* USDT2 */ |
|
5382 HOTSPOT_JNI_DETACHCURRENTTHREAD_RETURN(JNI_OK); |
4242 HOTSPOT_JNI_DETACHCURRENTTHREAD_RETURN(JNI_OK); |
5383 #endif /* USDT2 */ |
|
5384 return JNI_OK; |
4243 return JNI_OK; |
5385 } |
4244 } |
5386 |
4245 |
5387 JavaThread* thread = JavaThread::current(); |
4246 JavaThread* thread = JavaThread::current(); |
5388 if (thread->has_last_Java_frame()) { |
4247 if (thread->has_last_Java_frame()) { |
5389 #ifndef USDT2 |
|
5390 DTRACE_PROBE1(hotspot_jni, DetachCurrentThread__return, JNI_ERR); |
|
5391 #else /* USDT2 */ |
|
5392 HOTSPOT_JNI_DETACHCURRENTTHREAD_RETURN((uint32_t) JNI_ERR); |
4248 HOTSPOT_JNI_DETACHCURRENTTHREAD_RETURN((uint32_t) JNI_ERR); |
5393 #endif /* USDT2 */ |
|
5394 // Can't detach a thread that's running java, that can't work. |
4249 // Can't detach a thread that's running java, that can't work. |
5395 return JNI_ERR; |
4250 return JNI_ERR; |
5396 } |
4251 } |
5397 |
4252 |
5398 // Safepoint support. Have to do call-back to safepoint code, if in the |
4253 // Safepoint support. Have to do call-back to safepoint code, if in the |