168
169 /*
170 * SUPPORT FUNCTIONS
171 */
172
173 /**
174 * Check whether or not a programmer has actually checked for exceptions. According
175 * to the JNI Specification ("jni/spec/design.html#java_exceptions"):
176 *
177 * There are two cases where the programmer needs to check for exceptions without
178 * being able to first check an error code:
179 *
180 * - The JNI functions that invoke a Java method return the result of the Java method.
181 * The programmer must call ExceptionOccurred() to check for possible exceptions
182 * that occurred during the execution of the Java method.
183 *
184 * - Some of the JNI array access functions do not return an error code, but may
185 * throw an ArrayIndexOutOfBoundsException or ArrayStoreException.
186 *
187 * In all other cases, a non-error return value guarantees that no exceptions have been thrown.
188 */
189 static inline void
190 check_pending_exception(JavaThread* thr) {
191 if (thr->has_pending_exception()) {
192 NativeReportJNIWarning(thr, "JNI call made with exception pending");
193 }
194 if (thr->is_pending_jni_exception_check()) {
195 IN_VM(
196 tty->print_cr("WARNING in native method: JNI call made without checking exceptions when required to from %s",
197 thr->get_pending_jni_exception_check());
198 thr->print_stack();
199 )
200 thr->clear_pending_jni_exception_check(); // Just complain once
201 }
202 }
203
204
205 static inline void
206 functionEnterCritical(JavaThread* thr)
207 {
208 check_pending_exception(thr);
209 }
210
211 static inline void
212 functionEnterCriticalExceptionAllowed(JavaThread* thr)
213 {
214 }
215
216 static inline void
217 functionEnter(JavaThread* thr)
218 {
219 if (thr->in_critical()) {
220 tty->print_cr("%s", warn_other_function_in_critical);
221 }
222 check_pending_exception(thr);
223 }
226 functionEnterExceptionAllowed(JavaThread* thr)
227 {
228 if (thr->in_critical()) {
229 tty->print_cr("%s", warn_other_function_in_critical);
230 }
231 }
232
233 static inline void
234 functionExit(JavaThread* thr)
235 {
236 JNIHandleBlock* handles = thr->active_handles();
237 size_t planned_capacity = handles->get_planned_capacity();
238 size_t live_handles = handles->get_number_of_live_handles();
239 if (live_handles > planned_capacity) {
240 IN_VM(
241 tty->print_cr("WARNING: JNI local refs: %zu, exceeds capacity: %zu",
242 live_handles, planned_capacity);
243 thr->print_stack();
244 )
245 // Complain just the once, reset to current + warn threshold
246 handles->set_planned_capacity(live_handles + CHECK_JNI_LOCAL_REF_CAP_WARN_THRESHOLD);
247 }
248 }
249
250 static inline void
251 checkStaticFieldID(JavaThread* thr, jfieldID fid, jclass cls, int ftype)
252 {
253 fieldDescriptor fd;
254
255 /* make sure it is a static field */
256 if (!jfieldIDWorkaround::is_static_jfieldID(fid))
257 ReportJNIFatalError(thr, fatal_should_be_static);
258
259 /* validate the class being passed */
260 ASSERT_OOPS_ALLOWED;
261 Klass* k_oop = jniCheck::validate_class(thr, cls, false);
262
263 /* check for proper subclass hierarchy */
264 JNIid* id = jfieldIDWorkaround::from_static_jfieldID(fid);
265 Klass* f_oop = id->holder();
266 if (!InstanceKlass::cast(k_oop)->is_subtype_of(f_oop))
703 functionExit(thr);
704 JNI_END
705
706 JNI_ENTRY_CHECKED(void,
707 checked_jni_FatalError(JNIEnv *env,
708 const char *msg))
709 thr->clear_pending_jni_exception_check();
710 functionEnter(thr);
711 UNCHECKED()->FatalError(env, msg);
712 functionExit(thr);
713 JNI_END
714
715 JNI_ENTRY_CHECKED(jint,
716 checked_jni_PushLocalFrame(JNIEnv *env,
717 jint capacity))
718 functionEnterExceptionAllowed(thr);
719 if (capacity < 0)
720 NativeReportJNIFatalError(thr, "negative capacity");
721 jint result = UNCHECKED()->PushLocalFrame(env, capacity);
722 if (result == JNI_OK) {
723 thr->active_handles()->set_planned_capacity(capacity + CHECK_JNI_LOCAL_REF_CAP_WARN_THRESHOLD);
724 }
725 functionExit(thr);
726 return result;
727 JNI_END
728
729 JNI_ENTRY_CHECKED(jobject,
730 checked_jni_PopLocalFrame(JNIEnv *env,
731 jobject result))
732 functionEnterExceptionAllowed(thr);
733 jobject res = UNCHECKED()->PopLocalFrame(env, result);
734 functionExit(thr);
735 return res;
736 JNI_END
737
738 JNI_ENTRY_CHECKED(jobject,
739 checked_jni_NewGlobalRef(JNIEnv *env,
740 jobject lobj))
741 functionEnter(thr);
742 IN_VM(
743 if (lobj != NULL) {
807 functionEnter(thr);
808 IN_VM(
809 if (ref != NULL) {
810 jniCheck::validate_handle(thr, ref);
811 }
812 )
813 jobject result = UNCHECKED()->NewLocalRef(env, ref);
814 functionExit(thr);
815 return result;
816 JNI_END
817
818 JNI_ENTRY_CHECKED(jint,
819 checked_jni_EnsureLocalCapacity(JNIEnv *env,
820 jint capacity))
821 functionEnter(thr);
822 if (capacity < 0) {
823 NativeReportJNIFatalError(thr, "negative capacity");
824 }
825 jint result = UNCHECKED()->EnsureLocalCapacity(env, capacity);
826 if (result == JNI_OK) {
827 thr->active_handles()->set_planned_capacity(capacity + CHECK_JNI_LOCAL_REF_CAP_WARN_THRESHOLD);
828 }
829 functionExit(thr);
830 return result;
831 JNI_END
832
833 JNI_ENTRY_CHECKED(jobject,
834 checked_jni_AllocObject(JNIEnv *env,
835 jclass clazz))
836 functionEnter(thr);
837 IN_VM(
838 jniCheck::validate_class(thr, clazz, false);
839 )
840 jobject result = UNCHECKED()->AllocObject(env,clazz);
841 functionExit(thr);
842 return result;
843 JNI_END
844
845 JNI_ENTRY_CHECKED(jobject,
846 checked_jni_NewObject(JNIEnv *env,
847 jclass clazz,
1611 JNI_ENTRY_CHECKED(jobjectArray,
1612 checked_jni_NewObjectArray(JNIEnv *env,
1613 jsize len,
1614 jclass clazz,
1615 jobject init))
1616 functionEnter(thr);
1617 jobjectArray result = UNCHECKED()->NewObjectArray(env,len,clazz,init);
1618 functionExit(thr);
1619 return result;
1620 JNI_END
1621
1622 JNI_ENTRY_CHECKED(jobject,
1623 checked_jni_GetObjectArrayElement(JNIEnv *env,
1624 jobjectArray array,
1625 jsize index))
1626 functionEnter(thr);
1627 IN_VM(
1628 check_is_obj_array(thr, array);
1629 )
1630 jobject result = UNCHECKED()->GetObjectArrayElement(env,array,index);
1631 thr->set_pending_jni_exception_check("GetObjectArrayElement");
1632 functionExit(thr);
1633 return result;
1634 JNI_END
1635
1636 JNI_ENTRY_CHECKED(void,
1637 checked_jni_SetObjectArrayElement(JNIEnv *env,
1638 jobjectArray array,
1639 jsize index,
1640 jobject val))
1641 functionEnter(thr);
1642 IN_VM(
1643 check_is_obj_array(thr, array);
1644 )
1645 UNCHECKED()->SetObjectArrayElement(env,array,index,val);
1646 thr->set_pending_jni_exception_check("SetObjectArrayElement");
1647 functionExit(thr);
1648 JNI_END
1649
1650 #define WRAPPER_NewScalarArray(Return, Result) \
1651 JNI_ENTRY_CHECKED(Return, \
1652 checked_jni_New##Result##Array(JNIEnv *env, \
1653 jsize len)) \
1654 functionEnter(thr); \
1655 Return result = UNCHECKED()->New##Result##Array(env,len); \
1656 functionExit(thr); \
1657 return (Return) result; \
1658 JNI_END
1659
1660 WRAPPER_NewScalarArray(jbooleanArray, Boolean)
1661 WRAPPER_NewScalarArray(jbyteArray, Byte)
1662 WRAPPER_NewScalarArray(jshortArray, Short)
1663 WRAPPER_NewScalarArray(jcharArray, Char)
1664 WRAPPER_NewScalarArray(jintArray, Int)
1665 WRAPPER_NewScalarArray(jlongArray, Long)
1666 WRAPPER_NewScalarArray(jfloatArray, Float)
1716 WRAPPER_ReleaseScalarArrayElements(T_BYTE, jbyte, Byte, byte)
1717 WRAPPER_ReleaseScalarArrayElements(T_SHORT, jshort, Short, short)
1718 WRAPPER_ReleaseScalarArrayElements(T_CHAR, jchar, Char, char)
1719 WRAPPER_ReleaseScalarArrayElements(T_INT, jint, Int, int)
1720 WRAPPER_ReleaseScalarArrayElements(T_LONG, jlong, Long, long)
1721 WRAPPER_ReleaseScalarArrayElements(T_FLOAT, jfloat, Float, float)
1722 WRAPPER_ReleaseScalarArrayElements(T_DOUBLE, jdouble, Double, double)
1723
1724 #define WRAPPER_GetScalarArrayRegion(ElementTag,ElementType,Result) \
1725 JNI_ENTRY_CHECKED(void, \
1726 checked_jni_Get##Result##ArrayRegion(JNIEnv *env, \
1727 ElementType##Array array, \
1728 jsize start, \
1729 jsize len, \
1730 ElementType *buf)) \
1731 functionEnter(thr); \
1732 IN_VM( \
1733 check_primitive_array_type(thr, array, ElementTag); \
1734 ) \
1735 UNCHECKED()->Get##Result##ArrayRegion(env,array,start,len,buf); \
1736 thr->set_pending_jni_exception_check("Get"#Result"ArrayRegion"); \
1737 functionExit(thr); \
1738 JNI_END
1739
1740 WRAPPER_GetScalarArrayRegion(T_BOOLEAN, jboolean, Boolean)
1741 WRAPPER_GetScalarArrayRegion(T_BYTE, jbyte, Byte)
1742 WRAPPER_GetScalarArrayRegion(T_SHORT, jshort, Short)
1743 WRAPPER_GetScalarArrayRegion(T_CHAR, jchar, Char)
1744 WRAPPER_GetScalarArrayRegion(T_INT, jint, Int)
1745 WRAPPER_GetScalarArrayRegion(T_LONG, jlong, Long)
1746 WRAPPER_GetScalarArrayRegion(T_FLOAT, jfloat, Float)
1747 WRAPPER_GetScalarArrayRegion(T_DOUBLE, jdouble, Double)
1748
1749 #define WRAPPER_SetScalarArrayRegion(ElementTag,ElementType,Result) \
1750 JNI_ENTRY_CHECKED(void, \
1751 checked_jni_Set##Result##ArrayRegion(JNIEnv *env, \
1752 ElementType##Array array, \
1753 jsize start, \
1754 jsize len, \
1755 const ElementType *buf)) \
1756 functionEnter(thr); \
1757 IN_VM( \
1758 check_primitive_array_type(thr, array, ElementTag); \
1759 ) \
1760 UNCHECKED()->Set##Result##ArrayRegion(env,array,start,len,buf); \
1761 thr->set_pending_jni_exception_check("Set"#Result"ArrayRegion"); \
1762 functionExit(thr); \
1763 JNI_END
1764
1765 WRAPPER_SetScalarArrayRegion(T_BOOLEAN, jboolean, Boolean)
1766 WRAPPER_SetScalarArrayRegion(T_BYTE, jbyte, Byte)
1767 WRAPPER_SetScalarArrayRegion(T_SHORT, jshort, Short)
1768 WRAPPER_SetScalarArrayRegion(T_CHAR, jchar, Char)
1769 WRAPPER_SetScalarArrayRegion(T_INT, jint, Int)
1770 WRAPPER_SetScalarArrayRegion(T_LONG, jlong, Long)
1771 WRAPPER_SetScalarArrayRegion(T_FLOAT, jfloat, Float)
1772 WRAPPER_SetScalarArrayRegion(T_DOUBLE, jdouble, Double)
1773
1774 JNI_ENTRY_CHECKED(jint,
1775 checked_jni_RegisterNatives(JNIEnv *env,
1776 jclass clazz,
1777 const JNINativeMethod *methods,
1778 jint nMethods))
1779 functionEnter(thr);
1780 jint result = UNCHECKED()->RegisterNatives(env,clazz,methods,nMethods);
1781 functionExit(thr);
1818 JNI_ENTRY_CHECKED(jint,
1819 checked_jni_GetJavaVM(JNIEnv *env,
1820 JavaVM **vm))
1821 functionEnter(thr);
1822 jint result = UNCHECKED()->GetJavaVM(env,vm);
1823 functionExit(thr);
1824 return result;
1825 JNI_END
1826
1827 JNI_ENTRY_CHECKED(void,
1828 checked_jni_GetStringRegion(JNIEnv *env,
1829 jstring str,
1830 jsize start,
1831 jsize len,
1832 jchar *buf))
1833 functionEnter(thr);
1834 IN_VM(
1835 checkString(thr, str);
1836 )
1837 UNCHECKED()->GetStringRegion(env, str, start, len, buf);
1838 thr->set_pending_jni_exception_check("GetStringRegion");
1839 functionExit(thr);
1840 JNI_END
1841
1842 JNI_ENTRY_CHECKED(void,
1843 checked_jni_GetStringUTFRegion(JNIEnv *env,
1844 jstring str,
1845 jsize start,
1846 jsize len,
1847 char *buf))
1848 functionEnter(thr);
1849 IN_VM(
1850 checkString(thr, str);
1851 )
1852 UNCHECKED()->GetStringUTFRegion(env, str, start, len, buf);
1853 thr->set_pending_jni_exception_check("GetStringUTFRegion");
1854 functionExit(thr);
1855 JNI_END
1856
1857 JNI_ENTRY_CHECKED(void *,
1858 checked_jni_GetPrimitiveArrayCritical(JNIEnv *env,
1859 jarray array,
1860 jboolean *isCopy))
1861 functionEnterCritical(thr);
1862 IN_VM(
1863 check_is_primitive_array(thr, array);
1864 )
1865 void *result = UNCHECKED()->GetPrimitiveArrayCritical(env, array, isCopy);
1866 if (result != NULL) {
1867 result = check_jni_wrap_copy_array(thr, array, result);
1868 }
1869 functionExit(thr);
1870 return result;
1871 JNI_END
1872
1873 JNI_ENTRY_CHECKED(void,
|
168
169 /*
170 * SUPPORT FUNCTIONS
171 */
172
173 /**
174 * Check whether or not a programmer has actually checked for exceptions. According
175 * to the JNI Specification ("jni/spec/design.html#java_exceptions"):
176 *
177 * There are two cases where the programmer needs to check for exceptions without
178 * being able to first check an error code:
179 *
180 * - The JNI functions that invoke a Java method return the result of the Java method.
181 * The programmer must call ExceptionOccurred() to check for possible exceptions
182 * that occurred during the execution of the Java method.
183 *
184 * - Some of the JNI array access functions do not return an error code, but may
185 * throw an ArrayIndexOutOfBoundsException or ArrayStoreException.
186 *
187 * In all other cases, a non-error return value guarantees that no exceptions have been thrown.
188 *
189 * Programmers often defend against ArrayIndexOutOfBoundsException, so warning
190 * for these functions would be pedantic.
191 */
192 static inline void
193 check_pending_exception(JavaThread* thr) {
194 if (thr->has_pending_exception()) {
195 NativeReportJNIWarning(thr, "JNI call made with exception pending");
196 }
197 if (thr->is_pending_jni_exception_check()) {
198 IN_VM(
199 tty->print_cr("WARNING in native method: JNI call made without checking exceptions when required to from %s",
200 thr->get_pending_jni_exception_check());
201 thr->print_stack();
202 )
203 thr->clear_pending_jni_exception_check(); // Just complain once
204 }
205 }
206
207 /**
208 * Add to the planned number of handles. I.e. plus current live & warning threshold
209 */
210 static inline void
211 add_planned_handle_capacity(JNIHandleBlock* handles, size_t capacity) {
212 handles->set_planned_capacity(capacity +
213 handles->get_number_of_live_handles() +
214 CHECK_JNI_LOCAL_REF_CAP_WARN_THRESHOLD);
215 }
216
217
218 static inline void
219 functionEnterCritical(JavaThread* thr)
220 {
221 check_pending_exception(thr);
222 }
223
224 static inline void
225 functionEnterCriticalExceptionAllowed(JavaThread* thr)
226 {
227 }
228
229 static inline void
230 functionEnter(JavaThread* thr)
231 {
232 if (thr->in_critical()) {
233 tty->print_cr("%s", warn_other_function_in_critical);
234 }
235 check_pending_exception(thr);
236 }
239 functionEnterExceptionAllowed(JavaThread* thr)
240 {
241 if (thr->in_critical()) {
242 tty->print_cr("%s", warn_other_function_in_critical);
243 }
244 }
245
246 static inline void
247 functionExit(JavaThread* thr)
248 {
249 JNIHandleBlock* handles = thr->active_handles();
250 size_t planned_capacity = handles->get_planned_capacity();
251 size_t live_handles = handles->get_number_of_live_handles();
252 if (live_handles > planned_capacity) {
253 IN_VM(
254 tty->print_cr("WARNING: JNI local refs: %zu, exceeds capacity: %zu",
255 live_handles, planned_capacity);
256 thr->print_stack();
257 )
258 // Complain just the once, reset to current + warn threshold
259 add_planned_handle_capacity(handles, 0);
260 }
261 }
262
263 static inline void
264 checkStaticFieldID(JavaThread* thr, jfieldID fid, jclass cls, int ftype)
265 {
266 fieldDescriptor fd;
267
268 /* make sure it is a static field */
269 if (!jfieldIDWorkaround::is_static_jfieldID(fid))
270 ReportJNIFatalError(thr, fatal_should_be_static);
271
272 /* validate the class being passed */
273 ASSERT_OOPS_ALLOWED;
274 Klass* k_oop = jniCheck::validate_class(thr, cls, false);
275
276 /* check for proper subclass hierarchy */
277 JNIid* id = jfieldIDWorkaround::from_static_jfieldID(fid);
278 Klass* f_oop = id->holder();
279 if (!InstanceKlass::cast(k_oop)->is_subtype_of(f_oop))
716 functionExit(thr);
717 JNI_END
718
719 JNI_ENTRY_CHECKED(void,
720 checked_jni_FatalError(JNIEnv *env,
721 const char *msg))
722 thr->clear_pending_jni_exception_check();
723 functionEnter(thr);
724 UNCHECKED()->FatalError(env, msg);
725 functionExit(thr);
726 JNI_END
727
728 JNI_ENTRY_CHECKED(jint,
729 checked_jni_PushLocalFrame(JNIEnv *env,
730 jint capacity))
731 functionEnterExceptionAllowed(thr);
732 if (capacity < 0)
733 NativeReportJNIFatalError(thr, "negative capacity");
734 jint result = UNCHECKED()->PushLocalFrame(env, capacity);
735 if (result == JNI_OK) {
736 add_planned_handle_capacity(thr->active_handles(), capacity);
737 }
738 functionExit(thr);
739 return result;
740 JNI_END
741
742 JNI_ENTRY_CHECKED(jobject,
743 checked_jni_PopLocalFrame(JNIEnv *env,
744 jobject result))
745 functionEnterExceptionAllowed(thr);
746 jobject res = UNCHECKED()->PopLocalFrame(env, result);
747 functionExit(thr);
748 return res;
749 JNI_END
750
751 JNI_ENTRY_CHECKED(jobject,
752 checked_jni_NewGlobalRef(JNIEnv *env,
753 jobject lobj))
754 functionEnter(thr);
755 IN_VM(
756 if (lobj != NULL) {
820 functionEnter(thr);
821 IN_VM(
822 if (ref != NULL) {
823 jniCheck::validate_handle(thr, ref);
824 }
825 )
826 jobject result = UNCHECKED()->NewLocalRef(env, ref);
827 functionExit(thr);
828 return result;
829 JNI_END
830
831 JNI_ENTRY_CHECKED(jint,
832 checked_jni_EnsureLocalCapacity(JNIEnv *env,
833 jint capacity))
834 functionEnter(thr);
835 if (capacity < 0) {
836 NativeReportJNIFatalError(thr, "negative capacity");
837 }
838 jint result = UNCHECKED()->EnsureLocalCapacity(env, capacity);
839 if (result == JNI_OK) {
840 add_planned_handle_capacity(thr->active_handles(), capacity);
841 }
842 functionExit(thr);
843 return result;
844 JNI_END
845
846 JNI_ENTRY_CHECKED(jobject,
847 checked_jni_AllocObject(JNIEnv *env,
848 jclass clazz))
849 functionEnter(thr);
850 IN_VM(
851 jniCheck::validate_class(thr, clazz, false);
852 )
853 jobject result = UNCHECKED()->AllocObject(env,clazz);
854 functionExit(thr);
855 return result;
856 JNI_END
857
858 JNI_ENTRY_CHECKED(jobject,
859 checked_jni_NewObject(JNIEnv *env,
860 jclass clazz,
1624 JNI_ENTRY_CHECKED(jobjectArray,
1625 checked_jni_NewObjectArray(JNIEnv *env,
1626 jsize len,
1627 jclass clazz,
1628 jobject init))
1629 functionEnter(thr);
1630 jobjectArray result = UNCHECKED()->NewObjectArray(env,len,clazz,init);
1631 functionExit(thr);
1632 return result;
1633 JNI_END
1634
1635 JNI_ENTRY_CHECKED(jobject,
1636 checked_jni_GetObjectArrayElement(JNIEnv *env,
1637 jobjectArray array,
1638 jsize index))
1639 functionEnter(thr);
1640 IN_VM(
1641 check_is_obj_array(thr, array);
1642 )
1643 jobject result = UNCHECKED()->GetObjectArrayElement(env,array,index);
1644 functionExit(thr);
1645 return result;
1646 JNI_END
1647
1648 JNI_ENTRY_CHECKED(void,
1649 checked_jni_SetObjectArrayElement(JNIEnv *env,
1650 jobjectArray array,
1651 jsize index,
1652 jobject val))
1653 functionEnter(thr);
1654 IN_VM(
1655 check_is_obj_array(thr, array);
1656 )
1657 UNCHECKED()->SetObjectArrayElement(env,array,index,val);
1658 functionExit(thr);
1659 JNI_END
1660
1661 #define WRAPPER_NewScalarArray(Return, Result) \
1662 JNI_ENTRY_CHECKED(Return, \
1663 checked_jni_New##Result##Array(JNIEnv *env, \
1664 jsize len)) \
1665 functionEnter(thr); \
1666 Return result = UNCHECKED()->New##Result##Array(env,len); \
1667 functionExit(thr); \
1668 return (Return) result; \
1669 JNI_END
1670
1671 WRAPPER_NewScalarArray(jbooleanArray, Boolean)
1672 WRAPPER_NewScalarArray(jbyteArray, Byte)
1673 WRAPPER_NewScalarArray(jshortArray, Short)
1674 WRAPPER_NewScalarArray(jcharArray, Char)
1675 WRAPPER_NewScalarArray(jintArray, Int)
1676 WRAPPER_NewScalarArray(jlongArray, Long)
1677 WRAPPER_NewScalarArray(jfloatArray, Float)
1727 WRAPPER_ReleaseScalarArrayElements(T_BYTE, jbyte, Byte, byte)
1728 WRAPPER_ReleaseScalarArrayElements(T_SHORT, jshort, Short, short)
1729 WRAPPER_ReleaseScalarArrayElements(T_CHAR, jchar, Char, char)
1730 WRAPPER_ReleaseScalarArrayElements(T_INT, jint, Int, int)
1731 WRAPPER_ReleaseScalarArrayElements(T_LONG, jlong, Long, long)
1732 WRAPPER_ReleaseScalarArrayElements(T_FLOAT, jfloat, Float, float)
1733 WRAPPER_ReleaseScalarArrayElements(T_DOUBLE, jdouble, Double, double)
1734
1735 #define WRAPPER_GetScalarArrayRegion(ElementTag,ElementType,Result) \
1736 JNI_ENTRY_CHECKED(void, \
1737 checked_jni_Get##Result##ArrayRegion(JNIEnv *env, \
1738 ElementType##Array array, \
1739 jsize start, \
1740 jsize len, \
1741 ElementType *buf)) \
1742 functionEnter(thr); \
1743 IN_VM( \
1744 check_primitive_array_type(thr, array, ElementTag); \
1745 ) \
1746 UNCHECKED()->Get##Result##ArrayRegion(env,array,start,len,buf); \
1747 functionExit(thr); \
1748 JNI_END
1749
1750 WRAPPER_GetScalarArrayRegion(T_BOOLEAN, jboolean, Boolean)
1751 WRAPPER_GetScalarArrayRegion(T_BYTE, jbyte, Byte)
1752 WRAPPER_GetScalarArrayRegion(T_SHORT, jshort, Short)
1753 WRAPPER_GetScalarArrayRegion(T_CHAR, jchar, Char)
1754 WRAPPER_GetScalarArrayRegion(T_INT, jint, Int)
1755 WRAPPER_GetScalarArrayRegion(T_LONG, jlong, Long)
1756 WRAPPER_GetScalarArrayRegion(T_FLOAT, jfloat, Float)
1757 WRAPPER_GetScalarArrayRegion(T_DOUBLE, jdouble, Double)
1758
1759 #define WRAPPER_SetScalarArrayRegion(ElementTag,ElementType,Result) \
1760 JNI_ENTRY_CHECKED(void, \
1761 checked_jni_Set##Result##ArrayRegion(JNIEnv *env, \
1762 ElementType##Array array, \
1763 jsize start, \
1764 jsize len, \
1765 const ElementType *buf)) \
1766 functionEnter(thr); \
1767 IN_VM( \
1768 check_primitive_array_type(thr, array, ElementTag); \
1769 ) \
1770 UNCHECKED()->Set##Result##ArrayRegion(env,array,start,len,buf); \
1771 functionExit(thr); \
1772 JNI_END
1773
1774 WRAPPER_SetScalarArrayRegion(T_BOOLEAN, jboolean, Boolean)
1775 WRAPPER_SetScalarArrayRegion(T_BYTE, jbyte, Byte)
1776 WRAPPER_SetScalarArrayRegion(T_SHORT, jshort, Short)
1777 WRAPPER_SetScalarArrayRegion(T_CHAR, jchar, Char)
1778 WRAPPER_SetScalarArrayRegion(T_INT, jint, Int)
1779 WRAPPER_SetScalarArrayRegion(T_LONG, jlong, Long)
1780 WRAPPER_SetScalarArrayRegion(T_FLOAT, jfloat, Float)
1781 WRAPPER_SetScalarArrayRegion(T_DOUBLE, jdouble, Double)
1782
1783 JNI_ENTRY_CHECKED(jint,
1784 checked_jni_RegisterNatives(JNIEnv *env,
1785 jclass clazz,
1786 const JNINativeMethod *methods,
1787 jint nMethods))
1788 functionEnter(thr);
1789 jint result = UNCHECKED()->RegisterNatives(env,clazz,methods,nMethods);
1790 functionExit(thr);
1827 JNI_ENTRY_CHECKED(jint,
1828 checked_jni_GetJavaVM(JNIEnv *env,
1829 JavaVM **vm))
1830 functionEnter(thr);
1831 jint result = UNCHECKED()->GetJavaVM(env,vm);
1832 functionExit(thr);
1833 return result;
1834 JNI_END
1835
1836 JNI_ENTRY_CHECKED(void,
1837 checked_jni_GetStringRegion(JNIEnv *env,
1838 jstring str,
1839 jsize start,
1840 jsize len,
1841 jchar *buf))
1842 functionEnter(thr);
1843 IN_VM(
1844 checkString(thr, str);
1845 )
1846 UNCHECKED()->GetStringRegion(env, str, start, len, buf);
1847 functionExit(thr);
1848 JNI_END
1849
1850 JNI_ENTRY_CHECKED(void,
1851 checked_jni_GetStringUTFRegion(JNIEnv *env,
1852 jstring str,
1853 jsize start,
1854 jsize len,
1855 char *buf))
1856 functionEnter(thr);
1857 IN_VM(
1858 checkString(thr, str);
1859 )
1860 UNCHECKED()->GetStringUTFRegion(env, str, start, len, buf);
1861 functionExit(thr);
1862 JNI_END
1863
1864 JNI_ENTRY_CHECKED(void *,
1865 checked_jni_GetPrimitiveArrayCritical(JNIEnv *env,
1866 jarray array,
1867 jboolean *isCopy))
1868 functionEnterCritical(thr);
1869 IN_VM(
1870 check_is_primitive_array(thr, array);
1871 )
1872 void *result = UNCHECKED()->GetPrimitiveArrayCritical(env, array, isCopy);
1873 if (result != NULL) {
1874 result = check_jni_wrap_copy_array(thr, array, result);
1875 }
1876 functionExit(thr);
1877 return result;
1878 JNI_END
1879
1880 JNI_ENTRY_CHECKED(void,
|