1319 
1320 static void jni_invoke_nonstatic(JNIEnv *env, JavaValue* result, jobject receiver, JNICallType call_type, jmethodID method_id, JNI_ArgumentPusher *args, TRAPS) {
1321   oop recv = JNIHandles::resolve(receiver);
1322   if (recv == NULL) {
1323     THROW(vmSymbols::java_lang_NullPointerException());
1324   }
1325   Handle h_recv(THREAD, recv);
1326 
1327   int number_of_parameters;
1328   Method* selected_method;
1329   {
1330     Method* m = Method::resolve_jmethod_id(method_id);
1331     number_of_parameters = m->size_of_parameters();
1332     Klass* holder = m->method_holder();
1333     if (!(holder)->is_interface()) {
1334       // non-interface call -- for that little speed boost, don't handlize
1335       debug_only(No_Safepoint_Verifier nosafepoint;)
1336       if (call_type == JNI_VIRTUAL) {
1337         // jni_GetMethodID makes sure class is linked and initialized
1338         // so m should have a valid vtable index.

1339         int vtbl_index = m->vtable_index();
1340         if (vtbl_index != Method::nonvirtual_vtable_index) {
1341           Klass* k = h_recv->klass();
1342           // k might be an arrayKlassOop but all vtables start at
1343           // the same place. The cast is to avoid virtual call and assertion.
1344           InstanceKlass *ik = (InstanceKlass*)k;
1345           selected_method = ik->method_at_vtable(vtbl_index);
1346         } else {
1347           // final method
1348           selected_method = m;
1349         }
1350       } else {
1351         // JNI_NONVIRTUAL call
1352         selected_method = m;
1353       }
1354     } else {
1355       // interface call
1356       KlassHandle h_holder(THREAD, holder);
1357 
1358       int itbl_index = m->cached_itable_index();
1359       if (itbl_index == -1) {
1360         itbl_index = klassItable::compute_itable_index(m);
1361         m->set_cached_itable_index(itbl_index);
1362         // the above may have grabbed a lock, 'm' and anything non-handlized can't be used again
1363       }
1364       Klass* k = h_recv->klass();
1365       selected_method = InstanceKlass::cast(k)->method_at_itable(h_holder(), itbl_index, CHECK);
1366     }
1367   }
1368 
1369   methodHandle method(THREAD, selected_method);
1370 
1371   // Create object to hold arguments for the JavaCall, and associate it with
1372   // the jni parser
1373   ResourceMark rm(THREAD);
1374   JavaCallArguments java_args(number_of_parameters);
1375   args->set_java_argument_object(&java_args);
1376 
1377   // handle arguments
1378   assert(!method->is_static(), "method should not be static");
1379   args->push_receiver(h_recv); // Push jobject handle
1380 
1381   // Fill out JavaCallArguments object
1382   args->iterate( Fingerprinter(method).fingerprint() );
1383   // Initialize result type

1319 
1320 static void jni_invoke_nonstatic(JNIEnv *env, JavaValue* result, jobject receiver, JNICallType call_type, jmethodID method_id, JNI_ArgumentPusher *args, TRAPS) {
1321   oop recv = JNIHandles::resolve(receiver);
1322   if (recv == NULL) {
1323     THROW(vmSymbols::java_lang_NullPointerException());
1324   }
1325   Handle h_recv(THREAD, recv);
1326 
1327   int number_of_parameters;
1328   Method* selected_method;
1329   {
1330     Method* m = Method::resolve_jmethod_id(method_id);
1331     number_of_parameters = m->size_of_parameters();
1332     Klass* holder = m->method_holder();
1333     if (!(holder)->is_interface()) {
1334       // non-interface call -- for that little speed boost, don't handlize
1335       debug_only(No_Safepoint_Verifier nosafepoint;)
1336       if (call_type == JNI_VIRTUAL) {
1337         // jni_GetMethodID makes sure class is linked and initialized
1338         // so m should have a valid vtable index.
1339         assert(!m->has_itable_index(), "");
1340         int vtbl_index = m->vtable_index();
1341         if (vtbl_index != Method::nonvirtual_vtable_index) {
1342           Klass* k = h_recv->klass();
1343           // k might be an arrayKlassOop but all vtables start at
1344           // the same place. The cast is to avoid virtual call and assertion.
1345           InstanceKlass *ik = (InstanceKlass*)k;
1346           selected_method = ik->method_at_vtable(vtbl_index);
1347         } else {
1348           // final method
1349           selected_method = m;
1350         }
1351       } else {
1352         // JNI_NONVIRTUAL call
1353         selected_method = m;
1354       }
1355     } else {
1356       // interface call
1357       KlassHandle h_holder(THREAD, holder);
1358 
1359       int itbl_index = m->itable_index();





1360       Klass* k = h_recv->klass();
1361       selected_method = InstanceKlass::cast(k)->method_at_itable(h_holder(), itbl_index, CHECK);
1362     }
1363   }
1364 
1365   methodHandle method(THREAD, selected_method);
1366 
1367   // Create object to hold arguments for the JavaCall, and associate it with
1368   // the jni parser
1369   ResourceMark rm(THREAD);
1370   JavaCallArguments java_args(number_of_parameters);
1371   args->set_java_argument_object(&java_args);
1372 
1373   // handle arguments
1374   assert(!method->is_static(), "method should not be static");
1375   args->push_receiver(h_recv); // Push jobject handle
1376 
1377   // Fill out JavaCallArguments object
1378   args->iterate( Fingerprinter(method).fingerprint() );
1379   // Initialize result type