431 NativeReportJNIFatalError(thr, "Unrecognized array release mode");
432 }
433 // We always need to release the copy we made with GuardedMemory
434 GuardedMemory::free_copy(carray);
435 return orig_result;
436 }
437
438 oop jniCheck::validate_handle(JavaThread* thr, jobject obj) {
439 if ((obj != NULL) && (JNIHandles::handle_type(thr, obj) != JNIInvalidRefType)) {
440 ASSERT_OOPS_ALLOWED;
441 return JNIHandles::resolve_external_guard(obj);
442 }
443 ReportJNIFatalError(thr, fatal_bad_ref_to_jni);
444 return NULL;
445 }
446
447
448 Method* jniCheck::validate_jmethod_id(JavaThread* thr, jmethodID method_id) {
449 ASSERT_OOPS_ALLOWED;
450 // do the fast jmethodID check first
451 Method* moop = Method::checked_resolve_jmethod_id(method_id);
452 if (moop == NULL) {
453 ReportJNIFatalError(thr, fatal_wrong_class_or_method);
454 }
455 // jmethodIDs are supposed to be weak handles in the class loader data,
456 // but that can be expensive so check it last
457 else if (!Method::is_method_id(method_id)) {
458 ReportJNIFatalError(thr, fatal_non_weak_method);
459 }
460 return moop;
461 }
462
463
464 oop jniCheck::validate_object(JavaThread* thr, jobject obj) {
465 if (obj == NULL) return NULL;
466 ASSERT_OOPS_ALLOWED;
467 oop oopObj = jniCheck::validate_handle(thr, obj);
468 if (oopObj == NULL) {
469 ReportJNIFatalError(thr, fatal_bad_ref_to_jni);
470 }
471 return oopObj;
472 }
473
474 // Warn if a class descriptor is in decorated form; class descriptors
475 // passed to JNI findClass should not be decorated unless they are
476 // array descriptors.
477 void jniCheck::validate_class_descriptor(JavaThread* thr, const char* name) {
478 if (name == NULL) return; // implementation accepts NULL so just return
479
480 size_t len = strlen(name);
508 return k;
509 }
510
511 void jniCheck::validate_throwable_klass(JavaThread* thr, Klass* klass) {
512 ASSERT_OOPS_ALLOWED;
513 assert(klass != NULL, "klass argument must have a value");
514
515 if (!klass->is_instance_klass() ||
516 !InstanceKlass::cast(klass)->is_subclass_of(SystemDictionary::Throwable_klass())) {
517 ReportJNIFatalError(thr, fatal_class_not_a_throwable_class);
518 }
519 }
520
521 void jniCheck::validate_call_object(JavaThread* thr, jobject obj, jmethodID method_id) {
522 /* validate the object being passed */
523 ASSERT_OOPS_ALLOWED;
524 jniCheck::validate_jmethod_id(thr, method_id);
525 jniCheck::validate_object(thr, obj);
526 }
527
528 void jniCheck::validate_call_class(JavaThread* thr, jclass clazz, jmethodID method_id) {
529 /* validate the class being passed */
530 ASSERT_OOPS_ALLOWED;
531 jniCheck::validate_jmethod_id(thr, method_id);
532 jniCheck::validate_class(thr, clazz, false);
533 }
534
535
536 /*
537 * IMPLEMENTATION OF FUNCTIONS IN CHECKED TABLE
538 */
539
540 JNI_ENTRY_CHECKED(jclass,
541 checked_jni_DefineClass(JNIEnv *env,
542 const char *name,
543 jobject loader,
544 const jbyte *buf,
545 jsize len))
546 functionEnter(thr);
547 IN_VM(
548 jniCheck::validate_object(thr, loader);
549 )
550 jclass result = UNCHECKED()->DefineClass(env, name, loader, buf, len);
551 functionExit(thr);
552 return result;
578
579 JNI_ENTRY_CHECKED(jfieldID,
580 checked_jni_FromReflectedField(JNIEnv *env,
581 jobject field))
582 functionEnter(thr);
583 IN_VM(
584 jniCheck::validate_object(thr, field);
585 )
586 jfieldID result = UNCHECKED()->FromReflectedField(env, field);
587 functionExit(thr);
588 return result;
589 JNI_END
590
591 JNI_ENTRY_CHECKED(jobject,
592 checked_jni_ToReflectedMethod(JNIEnv *env,
593 jclass cls,
594 jmethodID methodID,
595 jboolean isStatic))
596 functionEnter(thr);
597 IN_VM(
598 jniCheck::validate_class(thr, cls, false);
599 jniCheck::validate_jmethod_id(thr, methodID);
600 )
601 jobject result = UNCHECKED()->ToReflectedMethod(env, cls, methodID,
602 isStatic);
603 functionExit(thr);
604 return result;
605 JNI_END
606
607 JNI_ENTRY_CHECKED(jclass,
608 checked_jni_GetSuperclass(JNIEnv *env,
609 jclass sub))
610 functionEnter(thr);
611 IN_VM(
612 jniCheck::validate_class(thr, sub, true);
613 )
614 jclass result = UNCHECKED()->GetSuperclass(env, sub);
615 functionExit(thr);
616 return result;
617 JNI_END
618
619 JNI_ENTRY_CHECKED(jboolean,
835 JNI_ENTRY_CHECKED(jobject,
836 checked_jni_AllocObject(JNIEnv *env,
837 jclass clazz))
838 functionEnter(thr);
839 IN_VM(
840 jniCheck::validate_class(thr, clazz, false);
841 )
842 jobject result = UNCHECKED()->AllocObject(env,clazz);
843 functionExit(thr);
844 return result;
845 JNI_END
846
847 JNI_ENTRY_CHECKED(jobject,
848 checked_jni_NewObject(JNIEnv *env,
849 jclass clazz,
850 jmethodID methodID,
851 ...))
852 functionEnter(thr);
853 va_list args;
854 IN_VM(
855 jniCheck::validate_class(thr, clazz, false);
856 jniCheck::validate_jmethod_id(thr, methodID);
857 )
858 va_start(args, methodID);
859 jobject result = UNCHECKED()->NewObjectV(env,clazz,methodID,args);
860 va_end(args);
861 functionExit(thr);
862 return result;
863 JNI_END
864
865 JNI_ENTRY_CHECKED(jobject,
866 checked_jni_NewObjectV(JNIEnv *env,
867 jclass clazz,
868 jmethodID methodID,
869 va_list args))
870 functionEnter(thr);
871 IN_VM(
872 jniCheck::validate_class(thr, clazz, false);
873 jniCheck::validate_jmethod_id(thr, methodID);
874 )
875 jobject result = UNCHECKED()->NewObjectV(env,clazz,methodID,args);
876 functionExit(thr);
877 return result;
878 JNI_END
879
880 JNI_ENTRY_CHECKED(jobject,
881 checked_jni_NewObjectA(JNIEnv *env,
882 jclass clazz,
883 jmethodID methodID,
884 const jvalue *args))
885 functionEnter(thr);
886 IN_VM(
887 jniCheck::validate_class(thr, clazz, false);
888 jniCheck::validate_jmethod_id(thr, methodID);
889 )
890 jobject result = UNCHECKED()->NewObjectA(env,clazz,methodID,args);
891 functionExit(thr);
892 return result;
893 JNI_END
894
895 JNI_ENTRY_CHECKED(jclass,
896 checked_jni_GetObjectClass(JNIEnv *env,
897 jobject obj))
898 functionEnter(thr);
899 IN_VM(
900 jniCheck::validate_object(thr, obj);
901 )
902 jclass result = UNCHECKED()->GetObjectClass(env,obj);
903 functionExit(thr);
904 return result;
905 JNI_END
906
907 JNI_ENTRY_CHECKED(jboolean,
908 checked_jni_IsInstanceOf(JNIEnv *env,
1032 const jvalue * args))
1033 functionEnter(thr);
1034 IN_VM(
1035 jniCheck::validate_call_object(thr, obj, methodID);
1036 )
1037 UNCHECKED()->CallVoidMethodA(env,obj,methodID,args);
1038 thr->set_pending_jni_exception_check("CallVoidMethodA");
1039 functionExit(thr);
1040 JNI_END
1041
1042 #define WRAPPER_CallNonvirtualMethod(ResultType, Result) \
1043 JNI_ENTRY_CHECKED(ResultType, \
1044 checked_jni_CallNonvirtual##Result##Method(JNIEnv *env, \
1045 jobject obj, \
1046 jclass clazz, \
1047 jmethodID methodID, \
1048 ...)) \
1049 functionEnter(thr); \
1050 va_list args; \
1051 IN_VM( \
1052 jniCheck::validate_call_object(thr, obj, methodID); \
1053 jniCheck::validate_call_class(thr, clazz, methodID); \
1054 ) \
1055 va_start(args,methodID); \
1056 ResultType result = UNCHECKED()->CallNonvirtual##Result##MethodV(env, \
1057 obj, \
1058 clazz, \
1059 methodID,\
1060 args); \
1061 va_end(args); \
1062 thr->set_pending_jni_exception_check("CallNonvirtual"#Result"Method"); \
1063 functionExit(thr); \
1064 return result; \
1065 JNI_END \
1066 \
1067 JNI_ENTRY_CHECKED(ResultType, \
1068 checked_jni_CallNonvirtual##Result##MethodV(JNIEnv *env, \
1069 jobject obj, \
1070 jclass clazz, \
1071 jmethodID methodID, \
1072 va_list args)) \
1073 functionEnter(thr); \
1074 IN_VM( \
1075 jniCheck::validate_call_object(thr, obj, methodID); \
1076 jniCheck::validate_call_class(thr, clazz, methodID); \
1077 ) \
1078 ResultType result = UNCHECKED()->CallNonvirtual##Result##MethodV(env, \
1079 obj, \
1080 clazz, \
1081 methodID,\
1082 args); \
1083 thr->set_pending_jni_exception_check("CallNonvirtual"#Result"MethodV"); \
1084 functionExit(thr); \
1085 return result; \
1086 JNI_END \
1087 \
1088 JNI_ENTRY_CHECKED(ResultType, \
1089 checked_jni_CallNonvirtual##Result##MethodA(JNIEnv *env, \
1090 jobject obj, \
1091 jclass clazz, \
1092 jmethodID methodID, \
1093 const jvalue * args)) \
1094 functionEnter(thr); \
1095 IN_VM( \
1096 jniCheck::validate_call_object(thr, obj, methodID); \
1097 jniCheck::validate_call_class(thr, clazz, methodID); \
1098 ) \
1099 ResultType result = UNCHECKED()->CallNonvirtual##Result##MethodA(env, \
1100 obj, \
1101 clazz, \
1102 methodID,\
1103 args); \
1104 thr->set_pending_jni_exception_check("CallNonvirtual"#Result"MethodA"); \
1105 functionExit(thr); \
1106 return result; \
1107 JNI_END
1108
1109 WRAPPER_CallNonvirtualMethod(jobject,Object)
1110 WRAPPER_CallNonvirtualMethod(jboolean,Boolean)
1111 WRAPPER_CallNonvirtualMethod(jbyte,Byte)
1112 WRAPPER_CallNonvirtualMethod(jshort,Short)
1113 WRAPPER_CallNonvirtualMethod(jchar,Char)
1114 WRAPPER_CallNonvirtualMethod(jint,Int)
1115 WRAPPER_CallNonvirtualMethod(jlong,Long)
1116 WRAPPER_CallNonvirtualMethod(jfloat,Float)
1117 WRAPPER_CallNonvirtualMethod(jdouble,Double)
1118
1119 JNI_ENTRY_CHECKED(void,
1120 checked_jni_CallNonvirtualVoidMethod(JNIEnv *env,
1121 jobject obj,
1122 jclass clazz,
1123 jmethodID methodID,
1124 ...))
1125 functionEnter(thr);
1126 va_list args;
1127 IN_VM(
1128 jniCheck::validate_call_object(thr, obj, methodID);
1129 jniCheck::validate_call_class(thr, clazz, methodID);
1130 )
1131 va_start(args,methodID);
1132 UNCHECKED()->CallNonvirtualVoidMethodV(env,obj,clazz,methodID,args);
1133 va_end(args);
1134 thr->set_pending_jni_exception_check("CallNonvirtualVoidMethod");
1135 functionExit(thr);
1136 JNI_END
1137
1138 JNI_ENTRY_CHECKED(void,
1139 checked_jni_CallNonvirtualVoidMethodV(JNIEnv *env,
1140 jobject obj,
1141 jclass clazz,
1142 jmethodID methodID,
1143 va_list args))
1144 functionEnter(thr);
1145 IN_VM(
1146 jniCheck::validate_call_object(thr, obj, methodID);
1147 jniCheck::validate_call_class(thr, clazz, methodID);
1148 )
1149 UNCHECKED()->CallNonvirtualVoidMethodV(env,obj,clazz,methodID,args);
1150 thr->set_pending_jni_exception_check("CallNonvirtualVoidMethodV");
1151 functionExit(thr);
1152 JNI_END
1153
1154 JNI_ENTRY_CHECKED(void,
1155 checked_jni_CallNonvirtualVoidMethodA(JNIEnv *env,
1156 jobject obj,
1157 jclass clazz,
1158 jmethodID methodID,
1159 const jvalue * args))
1160 functionEnter(thr);
1161 IN_VM(
1162 jniCheck::validate_call_object(thr, obj, methodID);
1163 jniCheck::validate_call_class(thr, clazz, methodID);
1164 )
1165 UNCHECKED()->CallNonvirtualVoidMethodA(env,obj,clazz,methodID,args);
1166 thr->set_pending_jni_exception_check("CallNonvirtualVoidMethodA");
1167 functionExit(thr);
1168 JNI_END
1169
1170 JNI_ENTRY_CHECKED(jfieldID,
1171 checked_jni_GetFieldID(JNIEnv *env,
1172 jclass clazz,
1173 const char *name,
1174 const char *sig))
1175 functionEnter(thr);
1176 IN_VM(
1177 jniCheck::validate_class(thr, clazz, false);
1178 )
1179 jfieldID result = UNCHECKED()->GetFieldID(env,clazz,name,sig);
1180 functionExit(thr);
1181 return result;
1182 JNI_END
1183
1236 const char *name,
1237 const char *sig))
1238 functionEnter(thr);
1239 IN_VM(
1240 jniCheck::validate_class(thr, clazz, false);
1241 )
1242 jmethodID result = UNCHECKED()->GetStaticMethodID(env,clazz,name,sig);
1243 functionExit(thr);
1244 return result;
1245 JNI_END
1246
1247 #define WRAPPER_CallStaticMethod(ReturnType,Result) \
1248 JNI_ENTRY_CHECKED(ReturnType, \
1249 checked_jni_CallStatic##Result##Method(JNIEnv *env, \
1250 jclass clazz, \
1251 jmethodID methodID, \
1252 ...)) \
1253 functionEnter(thr); \
1254 va_list args; \
1255 IN_VM( \
1256 jniCheck::validate_jmethod_id(thr, methodID); \
1257 jniCheck::validate_class(thr, clazz, false); \
1258 ) \
1259 va_start(args,methodID); \
1260 ReturnType result = UNCHECKED()->CallStatic##Result##MethodV(env, \
1261 clazz, \
1262 methodID, \
1263 args); \
1264 va_end(args); \
1265 thr->set_pending_jni_exception_check("CallStatic"#Result"Method"); \
1266 functionExit(thr); \
1267 return result; \
1268 JNI_END \
1269 \
1270 JNI_ENTRY_CHECKED(ReturnType, \
1271 checked_jni_CallStatic##Result##MethodV(JNIEnv *env, \
1272 jclass clazz, \
1273 jmethodID methodID,\
1274 va_list args)) \
1275 functionEnter(thr); \
1276 IN_VM( \
1277 jniCheck::validate_jmethod_id(thr, methodID); \
1278 jniCheck::validate_class(thr, clazz, false); \
1279 ) \
1280 ReturnType result = UNCHECKED()->CallStatic##Result##MethodV(env, \
1281 clazz, \
1282 methodID, \
1283 args); \
1284 thr->set_pending_jni_exception_check("CallStatic"#Result"MethodV"); \
1285 functionExit(thr); \
1286 return result; \
1287 JNI_END \
1288 \
1289 JNI_ENTRY_CHECKED(ReturnType, \
1290 checked_jni_CallStatic##Result##MethodA(JNIEnv *env, \
1291 jclass clazz, \
1292 jmethodID methodID, \
1293 const jvalue *args)) \
1294 functionEnter(thr); \
1295 IN_VM( \
1296 jniCheck::validate_jmethod_id(thr, methodID); \
1297 jniCheck::validate_class(thr, clazz, false); \
1298 ) \
1299 ReturnType result = UNCHECKED()->CallStatic##Result##MethodA(env, \
1300 clazz, \
1301 methodID, \
1302 args); \
1303 thr->set_pending_jni_exception_check("CallStatic"#Result"MethodA"); \
1304 functionExit(thr); \
1305 return result; \
1306 JNI_END
1307
1308 WRAPPER_CallStaticMethod(jobject,Object)
1309 WRAPPER_CallStaticMethod(jboolean,Boolean)
1310 WRAPPER_CallStaticMethod(jbyte,Byte)
1311 WRAPPER_CallStaticMethod(jshort,Short)
1312 WRAPPER_CallStaticMethod(jchar,Char)
1313 WRAPPER_CallStaticMethod(jint,Int)
1314 WRAPPER_CallStaticMethod(jlong,Long)
1315 WRAPPER_CallStaticMethod(jfloat,Float)
1316 WRAPPER_CallStaticMethod(jdouble,Double)
1317
1318 JNI_ENTRY_CHECKED(void,
1319 checked_jni_CallStaticVoidMethod(JNIEnv *env,
1320 jclass cls,
1321 jmethodID methodID,
1322 ...))
1323 functionEnter(thr);
1324 va_list args;
1325 IN_VM(
1326 jniCheck::validate_jmethod_id(thr, methodID);
1327 jniCheck::validate_class(thr, cls, false);
1328 )
1329 va_start(args,methodID);
1330 UNCHECKED()->CallStaticVoidMethodV(env,cls,methodID,args);
1331 va_end(args);
1332 thr->set_pending_jni_exception_check("CallStaticVoidMethod");
1333 functionExit(thr);
1334 JNI_END
1335
1336 JNI_ENTRY_CHECKED(void,
1337 checked_jni_CallStaticVoidMethodV(JNIEnv *env,
1338 jclass cls,
1339 jmethodID methodID,
1340 va_list args))
1341 functionEnter(thr);
1342 IN_VM(
1343 jniCheck::validate_jmethod_id(thr, methodID);
1344 jniCheck::validate_class(thr, cls, false);
1345 )
1346 UNCHECKED()->CallStaticVoidMethodV(env,cls,methodID,args);
1347 thr->set_pending_jni_exception_check("CallStaticVoidMethodV");
1348 functionExit(thr);
1349 JNI_END
1350
1351 JNI_ENTRY_CHECKED(void,
1352 checked_jni_CallStaticVoidMethodA(JNIEnv *env,
1353 jclass cls,
1354 jmethodID methodID,
1355 const jvalue * args))
1356 functionEnter(thr);
1357 IN_VM(
1358 jniCheck::validate_jmethod_id(thr, methodID);
1359 jniCheck::validate_class(thr, cls, false);
1360 )
1361 UNCHECKED()->CallStaticVoidMethodA(env,cls,methodID,args);
1362 thr->set_pending_jni_exception_check("CallStaticVoidMethodA");
1363 functionExit(thr);
1364 JNI_END
1365
1366 JNI_ENTRY_CHECKED(jfieldID,
1367 checked_jni_GetStaticFieldID(JNIEnv *env,
1368 jclass clazz,
1369 const char *name,
1370 const char *sig))
1371 functionEnter(thr);
1372 IN_VM(
1373 jniCheck::validate_class(thr, clazz, false);
1374 )
1375 jfieldID result = UNCHECKED()->GetStaticFieldID(env,clazz,name,sig);
1376 functionExit(thr);
1377 return result;
1378 JNI_END
1379
|
431 NativeReportJNIFatalError(thr, "Unrecognized array release mode");
432 }
433 // We always need to release the copy we made with GuardedMemory
434 GuardedMemory::free_copy(carray);
435 return orig_result;
436 }
437
438 oop jniCheck::validate_handle(JavaThread* thr, jobject obj) {
439 if ((obj != NULL) && (JNIHandles::handle_type(thr, obj) != JNIInvalidRefType)) {
440 ASSERT_OOPS_ALLOWED;
441 return JNIHandles::resolve_external_guard(obj);
442 }
443 ReportJNIFatalError(thr, fatal_bad_ref_to_jni);
444 return NULL;
445 }
446
447
448 Method* jniCheck::validate_jmethod_id(JavaThread* thr, jmethodID method_id) {
449 ASSERT_OOPS_ALLOWED;
450 // do the fast jmethodID check first
451 Method* m = Method::checked_resolve_jmethod_id(method_id);
452 if (m == NULL) {
453 ReportJNIFatalError(thr, fatal_wrong_class_or_method);
454 }
455 // jmethodIDs are handles in the class loader data,
456 // but that can be expensive so check it last
457 else if (!Method::is_method_id(method_id)) {
458 ReportJNIFatalError(thr, fatal_non_weak_method);
459 }
460 return m;
461 }
462
463
464 oop jniCheck::validate_object(JavaThread* thr, jobject obj) {
465 if (obj == NULL) return NULL;
466 ASSERT_OOPS_ALLOWED;
467 oop oopObj = jniCheck::validate_handle(thr, obj);
468 if (oopObj == NULL) {
469 ReportJNIFatalError(thr, fatal_bad_ref_to_jni);
470 }
471 return oopObj;
472 }
473
474 // Warn if a class descriptor is in decorated form; class descriptors
475 // passed to JNI findClass should not be decorated unless they are
476 // array descriptors.
477 void jniCheck::validate_class_descriptor(JavaThread* thr, const char* name) {
478 if (name == NULL) return; // implementation accepts NULL so just return
479
480 size_t len = strlen(name);
508 return k;
509 }
510
511 void jniCheck::validate_throwable_klass(JavaThread* thr, Klass* klass) {
512 ASSERT_OOPS_ALLOWED;
513 assert(klass != NULL, "klass argument must have a value");
514
515 if (!klass->is_instance_klass() ||
516 !InstanceKlass::cast(klass)->is_subclass_of(SystemDictionary::Throwable_klass())) {
517 ReportJNIFatalError(thr, fatal_class_not_a_throwable_class);
518 }
519 }
520
521 void jniCheck::validate_call_object(JavaThread* thr, jobject obj, jmethodID method_id) {
522 /* validate the object being passed */
523 ASSERT_OOPS_ALLOWED;
524 jniCheck::validate_jmethod_id(thr, method_id);
525 jniCheck::validate_object(thr, obj);
526 }
527
528 void jniCheck::validate_call_class(JavaThread* thr, jclass clazz, jmethodID method_id, jobject obj) {
529 ASSERT_OOPS_ALLOWED;
530 Method* m = jniCheck::validate_jmethod_id(thr, method_id);
531 Klass* k = jniCheck::validate_class(thr, clazz, false);
532 if (obj != NULL) {
533 jniCheck::validate_object(thr, obj);
534 }
535
536 // Check that method is in the class, must be InstanceKlass
537 if (!InstanceKlass::cast(k)->is_subtype_of(m->method_holder())) {
538 ReportJNIFatalError(thr, fatal_wrong_class_or_method);
539 }
540 }
541
542
543 /*
544 * IMPLEMENTATION OF FUNCTIONS IN CHECKED TABLE
545 */
546
547 JNI_ENTRY_CHECKED(jclass,
548 checked_jni_DefineClass(JNIEnv *env,
549 const char *name,
550 jobject loader,
551 const jbyte *buf,
552 jsize len))
553 functionEnter(thr);
554 IN_VM(
555 jniCheck::validate_object(thr, loader);
556 )
557 jclass result = UNCHECKED()->DefineClass(env, name, loader, buf, len);
558 functionExit(thr);
559 return result;
585
586 JNI_ENTRY_CHECKED(jfieldID,
587 checked_jni_FromReflectedField(JNIEnv *env,
588 jobject field))
589 functionEnter(thr);
590 IN_VM(
591 jniCheck::validate_object(thr, field);
592 )
593 jfieldID result = UNCHECKED()->FromReflectedField(env, field);
594 functionExit(thr);
595 return result;
596 JNI_END
597
598 JNI_ENTRY_CHECKED(jobject,
599 checked_jni_ToReflectedMethod(JNIEnv *env,
600 jclass cls,
601 jmethodID methodID,
602 jboolean isStatic))
603 functionEnter(thr);
604 IN_VM(
605 jniCheck::validate_call_class(thr, cls, methodID);
606 )
607 jobject result = UNCHECKED()->ToReflectedMethod(env, cls, methodID,
608 isStatic);
609 functionExit(thr);
610 return result;
611 JNI_END
612
613 JNI_ENTRY_CHECKED(jclass,
614 checked_jni_GetSuperclass(JNIEnv *env,
615 jclass sub))
616 functionEnter(thr);
617 IN_VM(
618 jniCheck::validate_class(thr, sub, true);
619 )
620 jclass result = UNCHECKED()->GetSuperclass(env, sub);
621 functionExit(thr);
622 return result;
623 JNI_END
624
625 JNI_ENTRY_CHECKED(jboolean,
841 JNI_ENTRY_CHECKED(jobject,
842 checked_jni_AllocObject(JNIEnv *env,
843 jclass clazz))
844 functionEnter(thr);
845 IN_VM(
846 jniCheck::validate_class(thr, clazz, false);
847 )
848 jobject result = UNCHECKED()->AllocObject(env,clazz);
849 functionExit(thr);
850 return result;
851 JNI_END
852
853 JNI_ENTRY_CHECKED(jobject,
854 checked_jni_NewObject(JNIEnv *env,
855 jclass clazz,
856 jmethodID methodID,
857 ...))
858 functionEnter(thr);
859 va_list args;
860 IN_VM(
861 jniCheck::validate_call_class(thr, clazz, methodID);
862 )
863 va_start(args, methodID);
864 jobject result = UNCHECKED()->NewObjectV(env,clazz,methodID,args);
865 va_end(args);
866 functionExit(thr);
867 return result;
868 JNI_END
869
870 JNI_ENTRY_CHECKED(jobject,
871 checked_jni_NewObjectV(JNIEnv *env,
872 jclass clazz,
873 jmethodID methodID,
874 va_list args))
875 functionEnter(thr);
876 IN_VM(
877 jniCheck::validate_call_class(thr, clazz, methodID);
878 )
879 jobject result = UNCHECKED()->NewObjectV(env,clazz,methodID,args);
880 functionExit(thr);
881 return result;
882 JNI_END
883
884 JNI_ENTRY_CHECKED(jobject,
885 checked_jni_NewObjectA(JNIEnv *env,
886 jclass clazz,
887 jmethodID methodID,
888 const jvalue *args))
889 functionEnter(thr);
890 IN_VM(
891 jniCheck::validate_call_class(thr, clazz, methodID);
892 )
893 jobject result = UNCHECKED()->NewObjectA(env,clazz,methodID,args);
894 functionExit(thr);
895 return result;
896 JNI_END
897
898 JNI_ENTRY_CHECKED(jclass,
899 checked_jni_GetObjectClass(JNIEnv *env,
900 jobject obj))
901 functionEnter(thr);
902 IN_VM(
903 jniCheck::validate_object(thr, obj);
904 )
905 jclass result = UNCHECKED()->GetObjectClass(env,obj);
906 functionExit(thr);
907 return result;
908 JNI_END
909
910 JNI_ENTRY_CHECKED(jboolean,
911 checked_jni_IsInstanceOf(JNIEnv *env,
1035 const jvalue * args))
1036 functionEnter(thr);
1037 IN_VM(
1038 jniCheck::validate_call_object(thr, obj, methodID);
1039 )
1040 UNCHECKED()->CallVoidMethodA(env,obj,methodID,args);
1041 thr->set_pending_jni_exception_check("CallVoidMethodA");
1042 functionExit(thr);
1043 JNI_END
1044
1045 #define WRAPPER_CallNonvirtualMethod(ResultType, Result) \
1046 JNI_ENTRY_CHECKED(ResultType, \
1047 checked_jni_CallNonvirtual##Result##Method(JNIEnv *env, \
1048 jobject obj, \
1049 jclass clazz, \
1050 jmethodID methodID, \
1051 ...)) \
1052 functionEnter(thr); \
1053 va_list args; \
1054 IN_VM( \
1055 jniCheck::validate_call_class(thr, clazz, methodID, obj); \
1056 ) \
1057 va_start(args,methodID); \
1058 ResultType result = UNCHECKED()->CallNonvirtual##Result##MethodV(env, \
1059 obj, \
1060 clazz, \
1061 methodID,\
1062 args); \
1063 va_end(args); \
1064 thr->set_pending_jni_exception_check("CallNonvirtual"#Result"Method"); \
1065 functionExit(thr); \
1066 return result; \
1067 JNI_END \
1068 \
1069 JNI_ENTRY_CHECKED(ResultType, \
1070 checked_jni_CallNonvirtual##Result##MethodV(JNIEnv *env, \
1071 jobject obj, \
1072 jclass clazz, \
1073 jmethodID methodID, \
1074 va_list args)) \
1075 functionEnter(thr); \
1076 IN_VM( \
1077 jniCheck::validate_call_class(thr, clazz, methodID, obj); \
1078 ) \
1079 ResultType result = UNCHECKED()->CallNonvirtual##Result##MethodV(env, \
1080 obj, \
1081 clazz, \
1082 methodID,\
1083 args); \
1084 thr->set_pending_jni_exception_check("CallNonvirtual"#Result"MethodV"); \
1085 functionExit(thr); \
1086 return result; \
1087 JNI_END \
1088 \
1089 JNI_ENTRY_CHECKED(ResultType, \
1090 checked_jni_CallNonvirtual##Result##MethodA(JNIEnv *env, \
1091 jobject obj, \
1092 jclass clazz, \
1093 jmethodID methodID, \
1094 const jvalue * args)) \
1095 functionEnter(thr); \
1096 IN_VM( \
1097 jniCheck::validate_call_class(thr, clazz, methodID, obj); \
1098 ) \
1099 ResultType result = UNCHECKED()->CallNonvirtual##Result##MethodA(env, \
1100 obj, \
1101 clazz, \
1102 methodID,\
1103 args); \
1104 thr->set_pending_jni_exception_check("CallNonvirtual"#Result"MethodA"); \
1105 functionExit(thr); \
1106 return result; \
1107 JNI_END
1108
1109 WRAPPER_CallNonvirtualMethod(jobject,Object)
1110 WRAPPER_CallNonvirtualMethod(jboolean,Boolean)
1111 WRAPPER_CallNonvirtualMethod(jbyte,Byte)
1112 WRAPPER_CallNonvirtualMethod(jshort,Short)
1113 WRAPPER_CallNonvirtualMethod(jchar,Char)
1114 WRAPPER_CallNonvirtualMethod(jint,Int)
1115 WRAPPER_CallNonvirtualMethod(jlong,Long)
1116 WRAPPER_CallNonvirtualMethod(jfloat,Float)
1117 WRAPPER_CallNonvirtualMethod(jdouble,Double)
1118
1119 JNI_ENTRY_CHECKED(void,
1120 checked_jni_CallNonvirtualVoidMethod(JNIEnv *env,
1121 jobject obj,
1122 jclass clazz,
1123 jmethodID methodID,
1124 ...))
1125 functionEnter(thr);
1126 va_list args;
1127 IN_VM(
1128 jniCheck::validate_call_class(thr, clazz, methodID, obj);
1129 )
1130 va_start(args,methodID);
1131 UNCHECKED()->CallNonvirtualVoidMethodV(env,obj,clazz,methodID,args);
1132 va_end(args);
1133 thr->set_pending_jni_exception_check("CallNonvirtualVoidMethod");
1134 functionExit(thr);
1135 JNI_END
1136
1137 JNI_ENTRY_CHECKED(void,
1138 checked_jni_CallNonvirtualVoidMethodV(JNIEnv *env,
1139 jobject obj,
1140 jclass clazz,
1141 jmethodID methodID,
1142 va_list args))
1143 functionEnter(thr);
1144 IN_VM(
1145 jniCheck::validate_call_class(thr, clazz, methodID, obj);
1146 )
1147 UNCHECKED()->CallNonvirtualVoidMethodV(env,obj,clazz,methodID,args);
1148 thr->set_pending_jni_exception_check("CallNonvirtualVoidMethodV");
1149 functionExit(thr);
1150 JNI_END
1151
1152 JNI_ENTRY_CHECKED(void,
1153 checked_jni_CallNonvirtualVoidMethodA(JNIEnv *env,
1154 jobject obj,
1155 jclass clazz,
1156 jmethodID methodID,
1157 const jvalue * args))
1158 functionEnter(thr);
1159 IN_VM(
1160 jniCheck::validate_call_class(thr, clazz, methodID, obj);
1161 )
1162 UNCHECKED()->CallNonvirtualVoidMethodA(env,obj,clazz,methodID,args);
1163 thr->set_pending_jni_exception_check("CallNonvirtualVoidMethodA");
1164 functionExit(thr);
1165 JNI_END
1166
1167 JNI_ENTRY_CHECKED(jfieldID,
1168 checked_jni_GetFieldID(JNIEnv *env,
1169 jclass clazz,
1170 const char *name,
1171 const char *sig))
1172 functionEnter(thr);
1173 IN_VM(
1174 jniCheck::validate_class(thr, clazz, false);
1175 )
1176 jfieldID result = UNCHECKED()->GetFieldID(env,clazz,name,sig);
1177 functionExit(thr);
1178 return result;
1179 JNI_END
1180
1233 const char *name,
1234 const char *sig))
1235 functionEnter(thr);
1236 IN_VM(
1237 jniCheck::validate_class(thr, clazz, false);
1238 )
1239 jmethodID result = UNCHECKED()->GetStaticMethodID(env,clazz,name,sig);
1240 functionExit(thr);
1241 return result;
1242 JNI_END
1243
1244 #define WRAPPER_CallStaticMethod(ReturnType,Result) \
1245 JNI_ENTRY_CHECKED(ReturnType, \
1246 checked_jni_CallStatic##Result##Method(JNIEnv *env, \
1247 jclass clazz, \
1248 jmethodID methodID, \
1249 ...)) \
1250 functionEnter(thr); \
1251 va_list args; \
1252 IN_VM( \
1253 jniCheck::validate_call_class(thr, clazz, methodID); \
1254 ) \
1255 va_start(args,methodID); \
1256 ReturnType result = UNCHECKED()->CallStatic##Result##MethodV(env, \
1257 clazz, \
1258 methodID, \
1259 args); \
1260 va_end(args); \
1261 thr->set_pending_jni_exception_check("CallStatic"#Result"Method"); \
1262 functionExit(thr); \
1263 return result; \
1264 JNI_END \
1265 \
1266 JNI_ENTRY_CHECKED(ReturnType, \
1267 checked_jni_CallStatic##Result##MethodV(JNIEnv *env, \
1268 jclass clazz, \
1269 jmethodID methodID,\
1270 va_list args)) \
1271 functionEnter(thr); \
1272 IN_VM( \
1273 jniCheck::validate_call_class(thr, clazz, methodID); \
1274 ) \
1275 ReturnType result = UNCHECKED()->CallStatic##Result##MethodV(env, \
1276 clazz, \
1277 methodID, \
1278 args); \
1279 thr->set_pending_jni_exception_check("CallStatic"#Result"MethodV"); \
1280 functionExit(thr); \
1281 return result; \
1282 JNI_END \
1283 \
1284 JNI_ENTRY_CHECKED(ReturnType, \
1285 checked_jni_CallStatic##Result##MethodA(JNIEnv *env, \
1286 jclass clazz, \
1287 jmethodID methodID, \
1288 const jvalue *args)) \
1289 functionEnter(thr); \
1290 IN_VM( \
1291 jniCheck::validate_call_class(thr, clazz, methodID); \
1292 ) \
1293 ReturnType result = UNCHECKED()->CallStatic##Result##MethodA(env, \
1294 clazz, \
1295 methodID, \
1296 args); \
1297 thr->set_pending_jni_exception_check("CallStatic"#Result"MethodA"); \
1298 functionExit(thr); \
1299 return result; \
1300 JNI_END
1301
1302 WRAPPER_CallStaticMethod(jobject,Object)
1303 WRAPPER_CallStaticMethod(jboolean,Boolean)
1304 WRAPPER_CallStaticMethod(jbyte,Byte)
1305 WRAPPER_CallStaticMethod(jshort,Short)
1306 WRAPPER_CallStaticMethod(jchar,Char)
1307 WRAPPER_CallStaticMethod(jint,Int)
1308 WRAPPER_CallStaticMethod(jlong,Long)
1309 WRAPPER_CallStaticMethod(jfloat,Float)
1310 WRAPPER_CallStaticMethod(jdouble,Double)
1311
1312 JNI_ENTRY_CHECKED(void,
1313 checked_jni_CallStaticVoidMethod(JNIEnv *env,
1314 jclass cls,
1315 jmethodID methodID,
1316 ...))
1317 functionEnter(thr);
1318 va_list args;
1319 IN_VM(
1320 jniCheck::validate_call_class(thr, cls, methodID);
1321 )
1322 va_start(args,methodID);
1323 UNCHECKED()->CallStaticVoidMethodV(env,cls,methodID,args);
1324 va_end(args);
1325 thr->set_pending_jni_exception_check("CallStaticVoidMethod");
1326 functionExit(thr);
1327 JNI_END
1328
1329 JNI_ENTRY_CHECKED(void,
1330 checked_jni_CallStaticVoidMethodV(JNIEnv *env,
1331 jclass cls,
1332 jmethodID methodID,
1333 va_list args))
1334 functionEnter(thr);
1335 IN_VM(
1336 jniCheck::validate_call_class(thr, cls, methodID);
1337 )
1338 UNCHECKED()->CallStaticVoidMethodV(env,cls,methodID,args);
1339 thr->set_pending_jni_exception_check("CallStaticVoidMethodV");
1340 functionExit(thr);
1341 JNI_END
1342
1343 JNI_ENTRY_CHECKED(void,
1344 checked_jni_CallStaticVoidMethodA(JNIEnv *env,
1345 jclass cls,
1346 jmethodID methodID,
1347 const jvalue * args))
1348 functionEnter(thr);
1349 IN_VM(
1350 jniCheck::validate_call_class(thr, cls, methodID);
1351 )
1352 UNCHECKED()->CallStaticVoidMethodA(env,cls,methodID,args);
1353 thr->set_pending_jni_exception_check("CallStaticVoidMethodA");
1354 functionExit(thr);
1355 JNI_END
1356
1357 JNI_ENTRY_CHECKED(jfieldID,
1358 checked_jni_GetStaticFieldID(JNIEnv *env,
1359 jclass clazz,
1360 const char *name,
1361 const char *sig))
1362 functionEnter(thr);
1363 IN_VM(
1364 jniCheck::validate_class(thr, clazz, false);
1365 )
1366 jfieldID result = UNCHECKED()->GetStaticFieldID(env,clazz,name,sig);
1367 functionExit(thr);
1368 return result;
1369 JNI_END
1370
|