src/hotspot/share/prims/jniCheck.cpp
changeset 58479 35ce0ad5870a
parent 57829 58891103f9cc
child 58562 e43ac61b89ab
equal deleted inserted replaced
58477:d148a7e7160c 58479:35ce0ad5870a
   446 
   446 
   447 
   447 
   448 Method* jniCheck::validate_jmethod_id(JavaThread* thr, jmethodID method_id) {
   448 Method* jniCheck::validate_jmethod_id(JavaThread* thr, jmethodID method_id) {
   449   ASSERT_OOPS_ALLOWED;
   449   ASSERT_OOPS_ALLOWED;
   450   // do the fast jmethodID check first
   450   // do the fast jmethodID check first
   451   Method* moop = Method::checked_resolve_jmethod_id(method_id);
   451   Method* m = Method::checked_resolve_jmethod_id(method_id);
   452   if (moop == NULL) {
   452   if (m == NULL) {
   453     ReportJNIFatalError(thr, fatal_wrong_class_or_method);
   453     ReportJNIFatalError(thr, fatal_wrong_class_or_method);
   454   }
   454   }
   455   // jmethodIDs are supposed to be weak handles in the class loader data,
   455   // jmethodIDs are handles in the class loader data,
   456   // but that can be expensive so check it last
   456   // but that can be expensive so check it last
   457   else if (!Method::is_method_id(method_id)) {
   457   else if (!Method::is_method_id(method_id)) {
   458     ReportJNIFatalError(thr, fatal_non_weak_method);
   458     ReportJNIFatalError(thr, fatal_non_weak_method);
   459   }
   459   }
   460   return moop;
   460   return m;
   461 }
   461 }
   462 
   462 
   463 
   463 
   464 oop jniCheck::validate_object(JavaThread* thr, jobject obj) {
   464 oop jniCheck::validate_object(JavaThread* thr, jobject obj) {
   465   if (obj == NULL) return NULL;
   465   if (obj == NULL) return NULL;
   516       !InstanceKlass::cast(klass)->is_subclass_of(SystemDictionary::Throwable_klass())) {
   516       !InstanceKlass::cast(klass)->is_subclass_of(SystemDictionary::Throwable_klass())) {
   517     ReportJNIFatalError(thr, fatal_class_not_a_throwable_class);
   517     ReportJNIFatalError(thr, fatal_class_not_a_throwable_class);
   518   }
   518   }
   519 }
   519 }
   520 
   520 
   521 void jniCheck::validate_call_object(JavaThread* thr, jobject obj, jmethodID method_id) {
   521 void jniCheck::validate_call(JavaThread* thr, jclass clazz, jmethodID method_id, jobject obj) {
   522   /* validate the object being passed */
       
   523   ASSERT_OOPS_ALLOWED;
   522   ASSERT_OOPS_ALLOWED;
   524   jniCheck::validate_jmethod_id(thr, method_id);
   523   Method* m = jniCheck::validate_jmethod_id(thr, method_id);
   525   jniCheck::validate_object(thr, obj);
   524   InstanceKlass* holder = m->method_holder();
   526 }
   525 
   527 
   526   if (clazz != NULL) {
   528 void jniCheck::validate_call_class(JavaThread* thr, jclass clazz, jmethodID method_id) {
   527     Klass* k = jniCheck::validate_class(thr, clazz, false);
   529   /* validate the class being passed */
   528     // Check that method is in the class, must be InstanceKlass
   530   ASSERT_OOPS_ALLOWED;
   529     if (!InstanceKlass::cast(k)->is_subtype_of(holder)) {
   531   jniCheck::validate_jmethod_id(thr, method_id);
   530       ReportJNIFatalError(thr, fatal_wrong_class_or_method);
   532   jniCheck::validate_class(thr, clazz, false);
   531     }
       
   532   }
       
   533 
       
   534   if (obj != NULL) {
       
   535     oop recv = jniCheck::validate_object(thr, obj);
       
   536     assert(recv != NULL, "validate_object checks that");
       
   537     Klass* ik = recv->klass();
       
   538 
       
   539     // Check that the object is a subtype of method holder too.
       
   540     if (!InstanceKlass::cast(ik)->is_subtype_of(holder)) {
       
   541       ReportJNIFatalError(thr, fatal_wrong_class_or_method);
       
   542     }
       
   543   }
   533 }
   544 }
   534 
   545 
   535 
   546 
   536 /*
   547 /*
   537  * IMPLEMENTATION OF FUNCTIONS IN CHECKED TABLE
   548  * IMPLEMENTATION OF FUNCTIONS IN CHECKED TABLE
   593                                 jclass cls,
   604                                 jclass cls,
   594                                 jmethodID methodID,
   605                                 jmethodID methodID,
   595                                 jboolean isStatic))
   606                                 jboolean isStatic))
   596     functionEnter(thr);
   607     functionEnter(thr);
   597     IN_VM(
   608     IN_VM(
   598       jniCheck::validate_class(thr, cls, false);
   609       jniCheck::validate_call(thr, cls, methodID);
   599       jniCheck::validate_jmethod_id(thr, methodID);
       
   600     )
   610     )
   601     jobject result = UNCHECKED()->ToReflectedMethod(env, cls, methodID,
   611     jobject result = UNCHECKED()->ToReflectedMethod(env, cls, methodID,
   602                                                     isStatic);
   612                                                     isStatic);
   603     functionExit(thr);
   613     functionExit(thr);
   604     return result;
   614     return result;
   850                         jmethodID methodID,
   860                         jmethodID methodID,
   851                         ...))
   861                         ...))
   852     functionEnter(thr);
   862     functionEnter(thr);
   853     va_list args;
   863     va_list args;
   854     IN_VM(
   864     IN_VM(
   855       jniCheck::validate_class(thr, clazz, false);
   865       jniCheck::validate_call(thr, clazz, methodID);
   856       jniCheck::validate_jmethod_id(thr, methodID);
       
   857     )
   866     )
   858     va_start(args, methodID);
   867     va_start(args, methodID);
   859     jobject result = UNCHECKED()->NewObjectV(env,clazz,methodID,args);
   868     jobject result = UNCHECKED()->NewObjectV(env,clazz,methodID,args);
   860     va_end(args);
   869     va_end(args);
   861     functionExit(thr);
   870     functionExit(thr);
   867                          jclass clazz,
   876                          jclass clazz,
   868                          jmethodID methodID,
   877                          jmethodID methodID,
   869                          va_list args))
   878                          va_list args))
   870     functionEnter(thr);
   879     functionEnter(thr);
   871     IN_VM(
   880     IN_VM(
   872       jniCheck::validate_class(thr, clazz, false);
   881       jniCheck::validate_call(thr, clazz, methodID);
   873       jniCheck::validate_jmethod_id(thr, methodID);
       
   874     )
   882     )
   875     jobject result = UNCHECKED()->NewObjectV(env,clazz,methodID,args);
   883     jobject result = UNCHECKED()->NewObjectV(env,clazz,methodID,args);
   876     functionExit(thr);
   884     functionExit(thr);
   877     return result;
   885     return result;
   878 JNI_END
   886 JNI_END
   882                          jclass clazz,
   890                          jclass clazz,
   883                          jmethodID methodID,
   891                          jmethodID methodID,
   884                          const jvalue *args))
   892                          const jvalue *args))
   885     functionEnter(thr);
   893     functionEnter(thr);
   886     IN_VM(
   894     IN_VM(
   887       jniCheck::validate_class(thr, clazz, false);
   895       jniCheck::validate_call(thr, clazz, methodID);
   888       jniCheck::validate_jmethod_id(thr, methodID);
       
   889     )
   896     )
   890     jobject result = UNCHECKED()->NewObjectA(env,clazz,methodID,args);
   897     jobject result = UNCHECKED()->NewObjectA(env,clazz,methodID,args);
   891     functionExit(thr);
   898     functionExit(thr);
   892     return result;
   899     return result;
   893 JNI_END
   900 JNI_END
   939                                    jmethodID methodID, \
   946                                    jmethodID methodID, \
   940                                    ...)) \
   947                                    ...)) \
   941     functionEnter(thr); \
   948     functionEnter(thr); \
   942     va_list args; \
   949     va_list args; \
   943     IN_VM( \
   950     IN_VM( \
   944       jniCheck::validate_call_object(thr, obj, methodID); \
   951       jniCheck::validate_call(thr, NULL, methodID, obj); \
   945     ) \
   952     ) \
   946     va_start(args,methodID); \
   953     va_start(args,methodID); \
   947     ResultType result =UNCHECKED()->Call##Result##MethodV(env, obj, methodID, \
   954     ResultType result =UNCHECKED()->Call##Result##MethodV(env, obj, methodID, \
   948                                                           args); \
   955                                                           args); \
   949     va_end(args); \
   956     va_end(args); \
   957                                     jobject obj, \
   964                                     jobject obj, \
   958                                     jmethodID methodID, \
   965                                     jmethodID methodID, \
   959                                     va_list args)) \
   966                                     va_list args)) \
   960     functionEnter(thr); \
   967     functionEnter(thr); \
   961     IN_VM(\
   968     IN_VM(\
   962       jniCheck::validate_call_object(thr, obj, methodID); \
   969       jniCheck::validate_call(thr, NULL, methodID, obj); \
   963     ) \
   970     ) \
   964     ResultType result = UNCHECKED()->Call##Result##MethodV(env, obj, methodID,\
   971     ResultType result = UNCHECKED()->Call##Result##MethodV(env, obj, methodID,\
   965                                                            args); \
   972                                                            args); \
   966     thr->set_pending_jni_exception_check("Call"#Result"MethodV"); \
   973     thr->set_pending_jni_exception_check("Call"#Result"MethodV"); \
   967     functionExit(thr); \
   974     functionExit(thr); \
   973                                     jobject obj, \
   980                                     jobject obj, \
   974                                     jmethodID methodID, \
   981                                     jmethodID methodID, \
   975                                     const jvalue * args)) \
   982                                     const jvalue * args)) \
   976     functionEnter(thr); \
   983     functionEnter(thr); \
   977     IN_VM( \
   984     IN_VM( \
   978       jniCheck::validate_call_object(thr, obj, methodID); \
   985       jniCheck::validate_call(thr, NULL, methodID, obj); \
   979     ) \
   986     ) \
   980     ResultType result = UNCHECKED()->Call##Result##MethodA(env, obj, methodID,\
   987     ResultType result = UNCHECKED()->Call##Result##MethodA(env, obj, methodID,\
   981                                                            args); \
   988                                                            args); \
   982     thr->set_pending_jni_exception_check("Call"#Result"MethodA"); \
   989     thr->set_pending_jni_exception_check("Call"#Result"MethodA"); \
   983     functionExit(thr); \
   990     functionExit(thr); \
  1000                              jmethodID methodID, \
  1007                              jmethodID methodID, \
  1001                              ...))
  1008                              ...))
  1002     functionEnter(thr);
  1009     functionEnter(thr);
  1003     va_list args;
  1010     va_list args;
  1004     IN_VM(
  1011     IN_VM(
  1005       jniCheck::validate_call_object(thr, obj, methodID);
  1012       jniCheck::validate_call(thr, NULL, methodID, obj);
  1006     )
  1013     )
  1007     va_start(args,methodID);
  1014     va_start(args,methodID);
  1008     UNCHECKED()->CallVoidMethodV(env,obj,methodID,args);
  1015     UNCHECKED()->CallVoidMethodV(env,obj,methodID,args);
  1009     va_end(args);
  1016     va_end(args);
  1010     thr->set_pending_jni_exception_check("CallVoidMethod");
  1017     thr->set_pending_jni_exception_check("CallVoidMethod");
  1016                               jobject obj,
  1023                               jobject obj,
  1017                               jmethodID methodID,
  1024                               jmethodID methodID,
  1018                               va_list args))
  1025                               va_list args))
  1019     functionEnter(thr);
  1026     functionEnter(thr);
  1020     IN_VM(
  1027     IN_VM(
  1021       jniCheck::validate_call_object(thr, obj, methodID);
  1028       jniCheck::validate_call(thr, NULL, methodID, obj);
  1022     )
  1029     )
  1023     UNCHECKED()->CallVoidMethodV(env,obj,methodID,args);
  1030     UNCHECKED()->CallVoidMethodV(env,obj,methodID,args);
  1024     thr->set_pending_jni_exception_check("CallVoidMethodV");
  1031     thr->set_pending_jni_exception_check("CallVoidMethodV");
  1025     functionExit(thr);
  1032     functionExit(thr);
  1026 JNI_END
  1033 JNI_END
  1030                               jobject obj,
  1037                               jobject obj,
  1031                               jmethodID methodID,
  1038                               jmethodID methodID,
  1032                               const jvalue * args))
  1039                               const jvalue * args))
  1033     functionEnter(thr);
  1040     functionEnter(thr);
  1034     IN_VM(
  1041     IN_VM(
  1035       jniCheck::validate_call_object(thr, obj, methodID);
  1042       jniCheck::validate_call(thr, NULL, methodID, obj);
  1036     )
  1043     )
  1037     UNCHECKED()->CallVoidMethodA(env,obj,methodID,args);
  1044     UNCHECKED()->CallVoidMethodA(env,obj,methodID,args);
  1038     thr->set_pending_jni_exception_check("CallVoidMethodA");
  1045     thr->set_pending_jni_exception_check("CallVoidMethodA");
  1039     functionExit(thr);
  1046     functionExit(thr);
  1040 JNI_END
  1047 JNI_END
  1047                                              jmethodID methodID, \
  1054                                              jmethodID methodID, \
  1048                                              ...)) \
  1055                                              ...)) \
  1049     functionEnter(thr); \
  1056     functionEnter(thr); \
  1050     va_list args; \
  1057     va_list args; \
  1051     IN_VM( \
  1058     IN_VM( \
  1052       jniCheck::validate_call_object(thr, obj, methodID); \
  1059       jniCheck::validate_call(thr, clazz, methodID, obj); \
  1053       jniCheck::validate_call_class(thr, clazz, methodID); \
       
  1054     ) \
  1060     ) \
  1055     va_start(args,methodID); \
  1061     va_start(args,methodID); \
  1056     ResultType result = UNCHECKED()->CallNonvirtual##Result##MethodV(env, \
  1062     ResultType result = UNCHECKED()->CallNonvirtual##Result##MethodV(env, \
  1057                                                                      obj, \
  1063                                                                      obj, \
  1058                                                                      clazz, \
  1064                                                                      clazz, \
  1070                                               jclass clazz, \
  1076                                               jclass clazz, \
  1071                                               jmethodID methodID, \
  1077                                               jmethodID methodID, \
  1072                                               va_list args)) \
  1078                                               va_list args)) \
  1073     functionEnter(thr); \
  1079     functionEnter(thr); \
  1074     IN_VM( \
  1080     IN_VM( \
  1075       jniCheck::validate_call_object(thr, obj, methodID); \
  1081       jniCheck::validate_call(thr, clazz, methodID, obj); \
  1076       jniCheck::validate_call_class(thr, clazz, methodID); \
       
  1077     ) \
  1082     ) \
  1078     ResultType result = UNCHECKED()->CallNonvirtual##Result##MethodV(env, \
  1083     ResultType result = UNCHECKED()->CallNonvirtual##Result##MethodV(env, \
  1079                                                                      obj, \
  1084                                                                      obj, \
  1080                                                                      clazz, \
  1085                                                                      clazz, \
  1081                                                                      methodID,\
  1086                                                                      methodID,\
  1091                                               jclass clazz, \
  1096                                               jclass clazz, \
  1092                                               jmethodID methodID, \
  1097                                               jmethodID methodID, \
  1093                                               const jvalue * args)) \
  1098                                               const jvalue * args)) \
  1094     functionEnter(thr); \
  1099     functionEnter(thr); \
  1095     IN_VM( \
  1100     IN_VM( \
  1096       jniCheck::validate_call_object(thr, obj, methodID); \
  1101       jniCheck::validate_call(thr, clazz, methodID, obj); \
  1097       jniCheck::validate_call_class(thr, clazz, methodID); \
       
  1098     ) \
  1102     ) \
  1099     ResultType result = UNCHECKED()->CallNonvirtual##Result##MethodA(env, \
  1103     ResultType result = UNCHECKED()->CallNonvirtual##Result##MethodA(env, \
  1100                                                                      obj, \
  1104                                                                      obj, \
  1101                                                                      clazz, \
  1105                                                                      clazz, \
  1102                                                                      methodID,\
  1106                                                                      methodID,\
  1123                                        jmethodID methodID,
  1127                                        jmethodID methodID,
  1124                                        ...))
  1128                                        ...))
  1125     functionEnter(thr);
  1129     functionEnter(thr);
  1126     va_list args;
  1130     va_list args;
  1127     IN_VM(
  1131     IN_VM(
  1128       jniCheck::validate_call_object(thr, obj, methodID);
  1132       jniCheck::validate_call(thr, clazz, methodID, obj);
  1129       jniCheck::validate_call_class(thr, clazz, methodID);
       
  1130     )
  1133     )
  1131     va_start(args,methodID);
  1134     va_start(args,methodID);
  1132     UNCHECKED()->CallNonvirtualVoidMethodV(env,obj,clazz,methodID,args);
  1135     UNCHECKED()->CallNonvirtualVoidMethodV(env,obj,clazz,methodID,args);
  1133     va_end(args);
  1136     va_end(args);
  1134     thr->set_pending_jni_exception_check("CallNonvirtualVoidMethod");
  1137     thr->set_pending_jni_exception_check("CallNonvirtualVoidMethod");
  1141                                         jclass clazz,
  1144                                         jclass clazz,
  1142                                         jmethodID methodID,
  1145                                         jmethodID methodID,
  1143                                         va_list args))
  1146                                         va_list args))
  1144     functionEnter(thr);
  1147     functionEnter(thr);
  1145     IN_VM(
  1148     IN_VM(
  1146       jniCheck::validate_call_object(thr, obj, methodID);
  1149       jniCheck::validate_call(thr, clazz, methodID, obj);
  1147       jniCheck::validate_call_class(thr, clazz, methodID);
       
  1148     )
  1150     )
  1149     UNCHECKED()->CallNonvirtualVoidMethodV(env,obj,clazz,methodID,args);
  1151     UNCHECKED()->CallNonvirtualVoidMethodV(env,obj,clazz,methodID,args);
  1150     thr->set_pending_jni_exception_check("CallNonvirtualVoidMethodV");
  1152     thr->set_pending_jni_exception_check("CallNonvirtualVoidMethodV");
  1151     functionExit(thr);
  1153     functionExit(thr);
  1152 JNI_END
  1154 JNI_END
  1157                                         jclass clazz,
  1159                                         jclass clazz,
  1158                                         jmethodID methodID,
  1160                                         jmethodID methodID,
  1159                                         const jvalue * args))
  1161                                         const jvalue * args))
  1160     functionEnter(thr);
  1162     functionEnter(thr);
  1161     IN_VM(
  1163     IN_VM(
  1162       jniCheck::validate_call_object(thr, obj, methodID);
  1164       jniCheck::validate_call(thr, clazz, methodID, obj);
  1163       jniCheck::validate_call_class(thr, clazz, methodID);
       
  1164     )
  1165     )
  1165     UNCHECKED()->CallNonvirtualVoidMethodA(env,obj,clazz,methodID,args);
  1166     UNCHECKED()->CallNonvirtualVoidMethodA(env,obj,clazz,methodID,args);
  1166     thr->set_pending_jni_exception_check("CallNonvirtualVoidMethodA");
  1167     thr->set_pending_jni_exception_check("CallNonvirtualVoidMethodA");
  1167     functionExit(thr);
  1168     functionExit(thr);
  1168 JNI_END
  1169 JNI_END
  1251                                          jmethodID methodID, \
  1252                                          jmethodID methodID, \
  1252                                          ...)) \
  1253                                          ...)) \
  1253     functionEnter(thr); \
  1254     functionEnter(thr); \
  1254     va_list args; \
  1255     va_list args; \
  1255     IN_VM( \
  1256     IN_VM( \
  1256       jniCheck::validate_jmethod_id(thr, methodID); \
  1257       jniCheck::validate_call(thr, clazz, methodID); \
  1257       jniCheck::validate_class(thr, clazz, false); \
       
  1258     ) \
  1258     ) \
  1259     va_start(args,methodID); \
  1259     va_start(args,methodID); \
  1260     ReturnType result = UNCHECKED()->CallStatic##Result##MethodV(env, \
  1260     ReturnType result = UNCHECKED()->CallStatic##Result##MethodV(env, \
  1261                                                                  clazz, \
  1261                                                                  clazz, \
  1262                                                                  methodID, \
  1262                                                                  methodID, \
  1272                                           jclass clazz, \
  1272                                           jclass clazz, \
  1273                                           jmethodID methodID,\
  1273                                           jmethodID methodID,\
  1274                                           va_list args)) \
  1274                                           va_list args)) \
  1275     functionEnter(thr); \
  1275     functionEnter(thr); \
  1276     IN_VM( \
  1276     IN_VM( \
  1277       jniCheck::validate_jmethod_id(thr, methodID); \
  1277       jniCheck::validate_call(thr, clazz, methodID); \
  1278       jniCheck::validate_class(thr, clazz, false); \
       
  1279     ) \
  1278     ) \
  1280     ReturnType result = UNCHECKED()->CallStatic##Result##MethodV(env, \
  1279     ReturnType result = UNCHECKED()->CallStatic##Result##MethodV(env, \
  1281                                                                  clazz, \
  1280                                                                  clazz, \
  1282                                                                  methodID, \
  1281                                                                  methodID, \
  1283                                                                  args); \
  1282                                                                  args); \
  1291                                           jclass clazz, \
  1290                                           jclass clazz, \
  1292                                           jmethodID methodID, \
  1291                                           jmethodID methodID, \
  1293                                           const jvalue *args)) \
  1292                                           const jvalue *args)) \
  1294     functionEnter(thr); \
  1293     functionEnter(thr); \
  1295     IN_VM( \
  1294     IN_VM( \
  1296       jniCheck::validate_jmethod_id(thr, methodID); \
  1295       jniCheck::validate_call(thr, clazz, methodID); \
  1297       jniCheck::validate_class(thr, clazz, false); \
       
  1298     ) \
  1296     ) \
  1299     ReturnType result = UNCHECKED()->CallStatic##Result##MethodA(env, \
  1297     ReturnType result = UNCHECKED()->CallStatic##Result##MethodA(env, \
  1300                                                                  clazz, \
  1298                                                                  clazz, \
  1301                                                                  methodID, \
  1299                                                                  methodID, \
  1302                                                                  args); \
  1300                                                                  args); \
  1321                                    jmethodID methodID,
  1319                                    jmethodID methodID,
  1322                                    ...))
  1320                                    ...))
  1323     functionEnter(thr);
  1321     functionEnter(thr);
  1324     va_list args;
  1322     va_list args;
  1325     IN_VM(
  1323     IN_VM(
  1326       jniCheck::validate_jmethod_id(thr, methodID);
  1324       jniCheck::validate_call(thr, cls, methodID);
  1327       jniCheck::validate_class(thr, cls, false);
       
  1328     )
  1325     )
  1329     va_start(args,methodID);
  1326     va_start(args,methodID);
  1330     UNCHECKED()->CallStaticVoidMethodV(env,cls,methodID,args);
  1327     UNCHECKED()->CallStaticVoidMethodV(env,cls,methodID,args);
  1331     va_end(args);
  1328     va_end(args);
  1332     thr->set_pending_jni_exception_check("CallStaticVoidMethod");
  1329     thr->set_pending_jni_exception_check("CallStaticVoidMethod");
  1338                                     jclass cls,
  1335                                     jclass cls,
  1339                                     jmethodID methodID,
  1336                                     jmethodID methodID,
  1340                                     va_list args))
  1337                                     va_list args))
  1341     functionEnter(thr);
  1338     functionEnter(thr);
  1342     IN_VM(
  1339     IN_VM(
  1343       jniCheck::validate_jmethod_id(thr, methodID);
  1340       jniCheck::validate_call(thr, cls, methodID);
  1344       jniCheck::validate_class(thr, cls, false);
       
  1345     )
  1341     )
  1346     UNCHECKED()->CallStaticVoidMethodV(env,cls,methodID,args);
  1342     UNCHECKED()->CallStaticVoidMethodV(env,cls,methodID,args);
  1347     thr->set_pending_jni_exception_check("CallStaticVoidMethodV");
  1343     thr->set_pending_jni_exception_check("CallStaticVoidMethodV");
  1348     functionExit(thr);
  1344     functionExit(thr);
  1349 JNI_END
  1345 JNI_END
  1353                                     jclass cls,
  1349                                     jclass cls,
  1354                                     jmethodID methodID,
  1350                                     jmethodID methodID,
  1355                                     const jvalue * args))
  1351                                     const jvalue * args))
  1356     functionEnter(thr);
  1352     functionEnter(thr);
  1357     IN_VM(
  1353     IN_VM(
  1358       jniCheck::validate_jmethod_id(thr, methodID);
  1354       jniCheck::validate_call(thr, cls, methodID);
  1359       jniCheck::validate_class(thr, cls, false);
       
  1360     )
  1355     )
  1361     UNCHECKED()->CallStaticVoidMethodA(env,cls,methodID,args);
  1356     UNCHECKED()->CallStaticVoidMethodA(env,cls,methodID,args);
  1362     thr->set_pending_jni_exception_check("CallStaticVoidMethodA");
  1357     thr->set_pending_jni_exception_check("CallStaticVoidMethodA");
  1363     functionExit(thr);
  1358     functionExit(thr);
  1364 JNI_END
  1359 JNI_END