1 /*
   2  * Copyright (c) 1997, 2018, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 #include "precompiled.hpp"
  26 #include "jvm.h"
  27 #include "classfile/defaultMethods.hpp"
  28 #include "classfile/javaClasses.hpp"
  29 #include "classfile/resolutionErrors.hpp"
  30 #include "classfile/symbolTable.hpp"
  31 #include "classfile/systemDictionary.hpp"
  32 #include "classfile/vmSymbols.hpp"
  33 #include "compiler/compileBroker.hpp"
  34 #include "gc/shared/collectedHeap.inline.hpp"
  35 #include "interpreter/bytecode.hpp"
  36 #include "interpreter/interpreterRuntime.hpp"
  37 #include "interpreter/linkResolver.hpp"
  38 #include "logging/log.hpp"
  39 #include "logging/logStream.hpp"
  40 #include "memory/resourceArea.hpp"
  41 #include "memory/universe.hpp"
  42 #include "oops/cpCache.inline.hpp"
  43 #include "oops/instanceKlass.hpp"
  44 #include "oops/method.hpp"
  45 #include "oops/objArrayKlass.hpp"
  46 #include "oops/objArrayOop.hpp"
  47 #include "oops/oop.inline.hpp"
  48 #include "prims/methodHandles.hpp"
  49 #include "prims/nativeLookup.hpp"
  50 #include "runtime/compilationPolicy.hpp"
  51 #include "runtime/fieldDescriptor.hpp"
  52 #include "runtime/frame.inline.hpp"
  53 #include "runtime/handles.inline.hpp"
  54 #include "runtime/reflection.hpp"
  55 #include "runtime/signature.hpp"
  56 #include "runtime/thread.inline.hpp"
  57 #include "runtime/vmThread.hpp"
  58 
  59 //------------------------------------------------------------------------------------------------------------------------
  60 // Implementation of CallInfo
  61 
  62 
  63 void CallInfo::set_static(Klass* resolved_klass, const methodHandle& resolved_method, TRAPS) {
  64   int vtable_index = Method::nonvirtual_vtable_index;
  65   set_common(resolved_klass, resolved_klass, resolved_method, resolved_method, CallInfo::direct_call, vtable_index, CHECK);
  66 }
  67 
  68 
  69 void CallInfo::set_interface(Klass* resolved_klass,
  70                              Klass* selected_klass,
  71                              const methodHandle& resolved_method,
  72                              const methodHandle& selected_method,
  73                              int itable_index, TRAPS) {
  74   // This is only called for interface methods. If the resolved_method
  75   // comes from java/lang/Object, it can be the subject of a virtual call, so
  76   // we should pick the vtable index from the resolved method.
  77   // In that case, the caller must call set_virtual instead of set_interface.
  78   assert(resolved_method->method_holder()->is_interface(), "");
  79   assert(itable_index == resolved_method()->itable_index(), "");
  80   set_common(resolved_klass, selected_klass, resolved_method, selected_method, CallInfo::itable_call, itable_index, CHECK);
  81 }
  82 
  83 void CallInfo::set_virtual(Klass* resolved_klass,
  84                            Klass* selected_klass,
  85                            const methodHandle& resolved_method,
  86                            const methodHandle& selected_method,
  87                            int vtable_index, TRAPS) {
  88   assert(vtable_index >= 0 || vtable_index == Method::nonvirtual_vtable_index, "valid index");
  89   assert(vtable_index < 0 || !resolved_method->has_vtable_index() || vtable_index == resolved_method->vtable_index(), "");
  90   CallKind kind = (vtable_index >= 0 && !resolved_method->can_be_statically_bound() ? CallInfo::vtable_call : CallInfo::direct_call);
  91   set_common(resolved_klass, selected_klass, resolved_method, selected_method, kind, vtable_index, CHECK);
  92   assert(!resolved_method->is_compiled_lambda_form(), "these must be handled via an invokehandle call");
  93 }
  94 
  95 void CallInfo::set_handle(const methodHandle& resolved_method,
  96                           Handle resolved_appendix,
  97                           Handle resolved_method_type, TRAPS) {
  98   set_handle(SystemDictionary::MethodHandle_klass(), resolved_method, resolved_appendix, resolved_method_type, CHECK);
  99 }
 100 
 101 void CallInfo::set_handle(Klass* resolved_klass,
 102                           const methodHandle& resolved_method,
 103                           Handle resolved_appendix,
 104                           Handle resolved_method_type, TRAPS) {
 105   if (resolved_method.is_null()) {
 106     THROW_MSG(vmSymbols::java_lang_InternalError(), "resolved method is null");
 107   }
 108   assert(resolved_method->intrinsic_id() == vmIntrinsics::_invokeBasic ||
 109          resolved_method->is_compiled_lambda_form(),
 110          "linkMethod must return one of these");
 111   int vtable_index = Method::nonvirtual_vtable_index;
 112   assert(!resolved_method->has_vtable_index(), "");
 113   set_common(resolved_klass, resolved_klass, resolved_method, resolved_method, CallInfo::direct_call, vtable_index, CHECK);
 114   _resolved_appendix    = resolved_appendix;
 115   _resolved_method_type = resolved_method_type;
 116 }
 117 
 118 void CallInfo::set_common(Klass* resolved_klass,
 119                           Klass* selected_klass,
 120                           const methodHandle& resolved_method,
 121                           const methodHandle& selected_method,
 122                           CallKind kind,
 123                           int index,
 124                           TRAPS) {
 125   assert(resolved_method->signature() == selected_method->signature(), "signatures must correspond");
 126   _resolved_klass  = resolved_klass;
 127   _selected_klass  = selected_klass;
 128   _resolved_method = resolved_method;
 129   _selected_method = selected_method;
 130   _call_kind       = kind;
 131   _call_index      = index;
 132   _resolved_appendix = Handle();
 133   DEBUG_ONLY(verify());  // verify before making side effects
 134 
 135   CompilationPolicy::compile_if_required(selected_method, THREAD);
 136 }
 137 
 138 // utility query for unreflecting a method
 139 CallInfo::CallInfo(Method* resolved_method, Klass* resolved_klass, TRAPS) {
 140   Klass* resolved_method_holder = resolved_method->method_holder();
 141   if (resolved_klass == NULL) { // 2nd argument defaults to holder of 1st
 142     resolved_klass = resolved_method_holder;
 143   }
 144   _resolved_klass  = resolved_klass;
 145   _selected_klass  = resolved_klass;
 146   _resolved_method = resolved_method;
 147   _selected_method = resolved_method;
 148   // classify:
 149   CallKind kind = CallInfo::unknown_kind;
 150   int index = resolved_method->vtable_index();
 151   if (resolved_method->can_be_statically_bound()) {
 152     kind = CallInfo::direct_call;
 153   } else if (!resolved_method_holder->is_interface()) {
 154     // Could be an Object method inherited into an interface, but still a vtable call.
 155     kind = CallInfo::vtable_call;
 156   } else if (!resolved_klass->is_interface()) {
 157     // A default or miranda method.  Compute the vtable index.
 158     index = LinkResolver::vtable_index_of_interface_method(resolved_klass,
 159                            resolved_method);
 160     assert(index >= 0 , "we should have valid vtable index at this point");
 161 
 162     kind = CallInfo::vtable_call;
 163   } else if (resolved_method->has_vtable_index()) {
 164     // Can occur if an interface redeclares a method of Object.
 165 
 166 #ifdef ASSERT
 167     // Ensure that this is really the case.
 168     Klass* object_klass = SystemDictionary::Object_klass();
 169     Method * object_resolved_method = object_klass->vtable().method_at(index);
 170     assert(object_resolved_method->name() == resolved_method->name(),
 171       "Object and interface method names should match at vtable index %d, %s != %s",
 172       index, object_resolved_method->name()->as_C_string(), resolved_method->name()->as_C_string());
 173     assert(object_resolved_method->signature() == resolved_method->signature(),
 174       "Object and interface method signatures should match at vtable index %d, %s != %s",
 175       index, object_resolved_method->signature()->as_C_string(), resolved_method->signature()->as_C_string());
 176 #endif // ASSERT
 177 
 178     kind = CallInfo::vtable_call;
 179   } else {
 180     // A regular interface call.
 181     kind = CallInfo::itable_call;
 182     index = resolved_method->itable_index();
 183   }
 184   assert(index == Method::nonvirtual_vtable_index || index >= 0, "bad index %d", index);
 185   _call_kind  = kind;
 186   _call_index = index;
 187   _resolved_appendix = Handle();
 188   // Find or create a ResolvedMethod instance for this Method*
 189   set_resolved_method_name(CHECK);
 190 
 191   DEBUG_ONLY(verify());
 192 }
 193 
 194 void CallInfo::set_resolved_method_name(TRAPS) {
 195   Method* m = _resolved_method();
 196   assert(m != NULL, "Should already have a Method*");
 197   oop rmethod_name = java_lang_invoke_ResolvedMethodName::find_resolved_method(m, CHECK);
 198   _resolved_method_name = Handle(THREAD, rmethod_name);
 199 }
 200 
 201 #ifdef ASSERT
 202 void CallInfo::verify() {
 203   switch (call_kind()) {  // the meaning and allowed value of index depends on kind
 204   case CallInfo::direct_call:
 205     if (_call_index == Method::nonvirtual_vtable_index)  break;
 206     // else fall through to check vtable index:
 207   case CallInfo::vtable_call:
 208     assert(resolved_klass()->verify_vtable_index(_call_index), "");
 209     break;
 210   case CallInfo::itable_call:
 211     assert(resolved_method()->method_holder()->verify_itable_index(_call_index), "");
 212     break;
 213   case CallInfo::unknown_kind:
 214     assert(call_kind() != CallInfo::unknown_kind, "CallInfo must be set");
 215     break;
 216   default:
 217     fatal("Unexpected call kind %d", call_kind());
 218   }
 219 }
 220 #endif //ASSERT
 221 
 222 #ifndef PRODUCT
 223 void CallInfo::print() {
 224   ResourceMark rm;
 225   const char* kindstr;
 226   switch (_call_kind) {
 227   case direct_call: kindstr = "direct";  break;
 228   case vtable_call: kindstr = "vtable";  break;
 229   case itable_call: kindstr = "itable";  break;
 230   default         : kindstr = "unknown"; break;
 231   }
 232   tty->print_cr("Call %s@%d %s", kindstr, _call_index,
 233                 _resolved_method.is_null() ? "(none)" : _resolved_method->name_and_sig_as_C_string());
 234 }
 235 #endif
 236 
 237 //------------------------------------------------------------------------------------------------------------------------
 238 // Implementation of LinkInfo
 239 
 240 LinkInfo::LinkInfo(const constantPoolHandle& pool, int index, const methodHandle& current_method, TRAPS) {
 241    // resolve klass
 242   _resolved_klass = pool->klass_ref_at(index, CHECK);
 243 
 244   // Get name, signature, and static klass
 245   _name          = pool->name_ref_at(index);
 246   _signature     = pool->signature_ref_at(index);
 247   _tag           = pool->tag_ref_at(index);
 248   _current_klass = pool->pool_holder();
 249   _current_method = current_method;
 250 
 251   // Coming from the constant pool always checks access
 252   _check_access  = true;
 253 }
 254 
 255 LinkInfo::LinkInfo(const constantPoolHandle& pool, int index, TRAPS) {
 256    // resolve klass
 257   _resolved_klass = pool->klass_ref_at(index, CHECK);
 258 
 259   // Get name, signature, and static klass
 260   _name          = pool->name_ref_at(index);
 261   _signature     = pool->signature_ref_at(index);
 262   _tag           = pool->tag_ref_at(index);
 263   _current_klass = pool->pool_holder();
 264   _current_method = methodHandle();
 265 
 266   // Coming from the constant pool always checks access
 267   _check_access  = true;
 268 }
 269 
 270 char* LinkInfo::method_string() const {
 271   return Method::name_and_sig_as_C_string(_resolved_klass, _name, _signature);
 272 }
 273 
 274 #ifndef PRODUCT
 275 void LinkInfo::print() {
 276   ResourceMark rm;
 277   tty->print_cr("Link resolved_klass=%s name=%s signature=%s current_klass=%s check_access=%s",
 278                 _resolved_klass->name()->as_C_string(),
 279                 _name->as_C_string(),
 280                 _signature->as_C_string(),
 281                 _current_klass == NULL ? "(none)" : _current_klass->name()->as_C_string(),
 282                 _check_access ? "true" : "false");
 283 }
 284 #endif // PRODUCT
 285 //------------------------------------------------------------------------------------------------------------------------
 286 // Klass resolution
 287 
 288 void LinkResolver::check_klass_accessability(Klass* ref_klass, Klass* sel_klass,
 289                                              bool fold_type_to_class, TRAPS) {
 290   Klass* base_klass = sel_klass;
 291   if (fold_type_to_class) {
 292     if (sel_klass->is_objArray_klass()) {
 293       base_klass = ObjArrayKlass::cast(sel_klass)->bottom_klass();
 294     }
 295     // The element type could be a typeArray - we only need the access
 296     // check if it is an reference to another class.
 297     if (!base_klass->is_instance_klass()) {
 298       return;  // no relevant check to do
 299     }
 300   }
 301   Reflection::VerifyClassAccessResults vca_result =
 302     Reflection::verify_class_access(ref_klass, InstanceKlass::cast(base_klass), true);
 303   if (vca_result != Reflection::ACCESS_OK) {
 304     ResourceMark rm(THREAD);
 305     char* msg = Reflection::verify_class_access_msg(ref_klass,
 306                                                     InstanceKlass::cast(base_klass),
 307                                                     vca_result);
 308     if (msg == NULL) {
 309       Exceptions::fthrow(
 310         THREAD_AND_LOCATION,
 311         vmSymbols::java_lang_IllegalAccessError(),
 312         "failed to access class %s from class %s",
 313         base_klass->external_name(),
 314         ref_klass->external_name());
 315     } else {
 316       // Use module specific message returned by verify_class_access_msg().
 317       Exceptions::fthrow(
 318         THREAD_AND_LOCATION,
 319         vmSymbols::java_lang_IllegalAccessError(),
 320         "%s", msg);
 321     }
 322   }
 323 }
 324 
 325 //------------------------------------------------------------------------------------------------------------------------
 326 // Method resolution
 327 //
 328 // According to JVM spec. $5.4.3c & $5.4.3d
 329 
 330 // Look up method in klasses, including static methods
 331 // Then look up local default methods
 332 Method* LinkResolver::lookup_method_in_klasses(const LinkInfo& link_info,
 333                                                bool checkpolymorphism,
 334                                                bool in_imethod_resolve) {
 335   NoSafepointVerifier nsv;  // Method* returned may not be reclaimed
 336 
 337   Klass* klass = link_info.resolved_klass();
 338   Symbol* name = link_info.name();
 339   Symbol* signature = link_info.signature();
 340 
 341   // Ignore overpasses so statics can be found during resolution
 342   Method* result = klass->uncached_lookup_method(name, signature, Klass::skip_overpass);
 343 
 344   if (klass->is_array_klass()) {
 345     // Only consider klass and super klass for arrays
 346     return result;
 347   }
 348 
 349   InstanceKlass* ik = InstanceKlass::cast(klass);
 350 
 351   // JDK 8, JVMS 5.4.3.4: Interface method resolution should
 352   // ignore static and non-public methods of java.lang.Object,
 353   // like clone, finalize, registerNatives.
 354   if (in_imethod_resolve &&
 355       result != NULL &&
 356       ik->is_interface() &&
 357       (result->is_static() || !result->is_public()) &&
 358       result->method_holder() == SystemDictionary::Object_klass()) {
 359     result = NULL;
 360   }
 361 
 362   // Before considering default methods, check for an overpass in the
 363   // current class if a method has not been found.
 364   if (result == NULL) {
 365     result = ik->find_method(name, signature);
 366   }
 367 
 368   if (result == NULL) {
 369     Array<Method*>* default_methods = ik->default_methods();
 370     if (default_methods != NULL) {
 371       result = InstanceKlass::find_method(default_methods, name, signature);
 372     }
 373   }
 374 
 375   if (checkpolymorphism && result != NULL) {
 376     vmIntrinsics::ID iid = result->intrinsic_id();
 377     if (MethodHandles::is_signature_polymorphic(iid)) {
 378       // Do not link directly to these.  The VM must produce a synthetic one using lookup_polymorphic_method.
 379       return NULL;
 380     }
 381   }
 382   return result;
 383 }
 384 
 385 // returns first instance method
 386 // Looks up method in classes, then looks up local default methods
 387 methodHandle LinkResolver::lookup_instance_method_in_klasses(Klass* klass,
 388                                                              Symbol* name,
 389                                                              Symbol* signature, TRAPS) {
 390   Method* result = klass->uncached_lookup_method(name, signature, Klass::find_overpass);
 391 
 392   while (result != NULL && result->is_static() && result->method_holder()->super() != NULL) {
 393     Klass* super_klass = result->method_holder()->super();
 394     result = super_klass->uncached_lookup_method(name, signature, Klass::find_overpass);
 395   }
 396 
 397   if (klass->is_array_klass()) {
 398     // Only consider klass and super klass for arrays
 399     return methodHandle(THREAD, result);
 400   }
 401 
 402   if (result == NULL) {
 403     Array<Method*>* default_methods = InstanceKlass::cast(klass)->default_methods();
 404     if (default_methods != NULL) {
 405       result = InstanceKlass::find_method(default_methods, name, signature);
 406       assert(result == NULL || !result->is_static(), "static defaults not allowed");
 407     }
 408   }
 409   return methodHandle(THREAD, result);
 410 }
 411 
 412 int LinkResolver::vtable_index_of_interface_method(Klass* klass,
 413                                                    const methodHandle& resolved_method) {
 414 
 415   int vtable_index = Method::invalid_vtable_index;
 416   Symbol* name = resolved_method->name();
 417   Symbol* signature = resolved_method->signature();
 418   InstanceKlass* ik = InstanceKlass::cast(klass);
 419 
 420   // First check in default method array
 421   if (!resolved_method->is_abstract() && ik->default_methods() != NULL) {
 422     int index = InstanceKlass::find_method_index(ik->default_methods(),
 423                                                  name, signature, Klass::find_overpass,
 424                                                  Klass::find_static, Klass::find_private);
 425     if (index >= 0 ) {
 426       vtable_index = ik->default_vtable_indices()->at(index);
 427     }
 428   }
 429   if (vtable_index == Method::invalid_vtable_index) {
 430     // get vtable_index for miranda methods
 431     klassVtable vt = ik->vtable();
 432     vtable_index = vt.index_of_miranda(name, signature);
 433   }
 434   return vtable_index;
 435 }
 436 
 437 Method* LinkResolver::lookup_method_in_interfaces(const LinkInfo& cp_info) {
 438   InstanceKlass *ik = InstanceKlass::cast(cp_info.resolved_klass());
 439 
 440   // Specify 'true' in order to skip default methods when searching the
 441   // interfaces.  Function lookup_method_in_klasses() already looked for
 442   // the method in the default methods table.
 443   return ik->lookup_method_in_all_interfaces(cp_info.name(), cp_info.signature(), Klass::skip_defaults);
 444 }
 445 
 446 methodHandle LinkResolver::lookup_polymorphic_method(
 447                                              const LinkInfo& link_info,
 448                                              Handle *appendix_result_or_null,
 449                                              Handle *method_type_result,
 450                                              TRAPS) {
 451   Klass* klass = link_info.resolved_klass();
 452   Symbol* name = link_info.name();
 453   Symbol* full_signature = link_info.signature();
 454 
 455   vmIntrinsics::ID iid = MethodHandles::signature_polymorphic_name_id(name);
 456   if (TraceMethodHandles) {
 457     ResourceMark rm(THREAD);
 458     tty->print_cr("lookup_polymorphic_method iid=%s %s.%s%s",
 459                   vmIntrinsics::name_at(iid), klass->external_name(),
 460                   name->as_C_string(), full_signature->as_C_string());
 461   }
 462   if ((klass == SystemDictionary::MethodHandle_klass() ||
 463        klass == SystemDictionary::VarHandle_klass()) &&
 464       iid != vmIntrinsics::_none) {
 465     if (MethodHandles::is_signature_polymorphic_intrinsic(iid)) {
 466       // Most of these do not need an up-call to Java to resolve, so can be done anywhere.
 467       // Do not erase last argument type (MemberName) if it is a static linkTo method.
 468       bool keep_last_arg = MethodHandles::is_signature_polymorphic_static(iid);
 469       TempNewSymbol basic_signature =
 470         MethodHandles::lookup_basic_type_signature(full_signature, keep_last_arg, CHECK_NULL);
 471       if (TraceMethodHandles) {
 472         ResourceMark rm(THREAD);
 473         tty->print_cr("lookup_polymorphic_method %s %s => basic %s",
 474                       name->as_C_string(),
 475                       full_signature->as_C_string(),
 476                       basic_signature->as_C_string());
 477       }
 478       methodHandle result = SystemDictionary::find_method_handle_intrinsic(iid,
 479                                                               basic_signature,
 480                                                               CHECK_NULL);
 481       if (result.not_null()) {
 482         assert(result->is_method_handle_intrinsic(), "MH.invokeBasic or MH.linkTo* intrinsic");
 483         assert(result->intrinsic_id() != vmIntrinsics::_invokeGeneric, "wrong place to find this");
 484         assert(basic_signature == result->signature(), "predict the result signature");
 485         if (TraceMethodHandles) {
 486           ttyLocker ttyl;
 487           tty->print("lookup_polymorphic_method => intrinsic ");
 488           result->print_on(tty);
 489         }
 490       }
 491       return result;
 492     } else if (iid == vmIntrinsics::_invokeGeneric
 493                && THREAD->can_call_java()
 494                && appendix_result_or_null != NULL) {
 495       // This is a method with type-checking semantics.
 496       // We will ask Java code to spin an adapter method for it.
 497       if (!MethodHandles::enabled()) {
 498         // Make sure the Java part of the runtime has been booted up.
 499         Klass* natives = SystemDictionary::MethodHandleNatives_klass();
 500         if (natives == NULL || InstanceKlass::cast(natives)->is_not_initialized()) {
 501           SystemDictionary::resolve_or_fail(vmSymbols::java_lang_invoke_MethodHandleNatives(),
 502                                             Handle(),
 503                                             Handle(),
 504                                             true,
 505                                             CHECK_NULL);
 506         }
 507       }
 508 
 509       Handle appendix;
 510       Handle method_type;
 511       methodHandle result = SystemDictionary::find_method_handle_invoker(
 512                                                             klass,
 513                                                             name,
 514                                                             full_signature,
 515                                                             link_info.current_klass(),
 516                                                             &appendix,
 517                                                             &method_type,
 518                                                             CHECK_NULL);
 519       if (TraceMethodHandles) {
 520         ttyLocker ttyl;
 521         tty->print("lookup_polymorphic_method => (via Java) ");
 522         result->print_on(tty);
 523         tty->print("  lookup_polymorphic_method => appendix = ");
 524         if (appendix.is_null())  tty->print_cr("(none)");
 525         else                     appendix->print_on(tty);
 526       }
 527       if (result.not_null()) {
 528 #ifdef ASSERT
 529         ResourceMark rm(THREAD);
 530 
 531         TempNewSymbol basic_signature =
 532           MethodHandles::lookup_basic_type_signature(full_signature, CHECK_NULL);
 533         int actual_size_of_params = result->size_of_parameters();
 534         int expected_size_of_params = ArgumentSizeComputer(basic_signature).size();
 535         // +1 for MethodHandle.this, +1 for trailing MethodType
 536         if (!MethodHandles::is_signature_polymorphic_static(iid))  expected_size_of_params += 1;
 537         if (appendix.not_null())                                   expected_size_of_params += 1;
 538         if (actual_size_of_params != expected_size_of_params) {
 539           tty->print_cr("*** basic_signature=%s", basic_signature->as_C_string());
 540           tty->print_cr("*** result for %s: ", vmIntrinsics::name_at(iid));
 541           result->print();
 542         }
 543         assert(actual_size_of_params == expected_size_of_params,
 544                "%d != %d", actual_size_of_params, expected_size_of_params);
 545 #endif //ASSERT
 546 
 547         assert(appendix_result_or_null != NULL, "");
 548         (*appendix_result_or_null) = appendix;
 549         (*method_type_result)      = method_type;
 550       }
 551       return result;
 552     }
 553   }
 554   return NULL;
 555 }
 556 
 557 void LinkResolver::check_method_accessability(Klass* ref_klass,
 558                                               Klass* resolved_klass,
 559                                               Klass* sel_klass,
 560                                               const methodHandle& sel_method,
 561                                               TRAPS) {
 562 
 563   AccessFlags flags = sel_method->access_flags();
 564 
 565   // Special case:  arrays always override "clone". JVMS 2.15.
 566   // If the resolved klass is an array class, and the declaring class
 567   // is java.lang.Object and the method is "clone", set the flags
 568   // to public.
 569   //
 570   // We'll check for the method name first, as that's most likely
 571   // to be false (so we'll short-circuit out of these tests).
 572   if (sel_method->name() == vmSymbols::clone_name() &&
 573       sel_klass == SystemDictionary::Object_klass() &&
 574       resolved_klass->is_array_klass()) {
 575     // We need to change "protected" to "public".
 576     assert(flags.is_protected(), "clone not protected?");
 577     jint new_flags = flags.as_int();
 578     new_flags = new_flags & (~JVM_ACC_PROTECTED);
 579     new_flags = new_flags | JVM_ACC_PUBLIC;
 580     flags.set_flags(new_flags);
 581   }
 582 //  assert(extra_arg_result_or_null != NULL, "must be able to return extra argument");
 583 
 584   if (!Reflection::verify_field_access(ref_klass,
 585                                        resolved_klass,
 586                                        sel_klass,
 587                                        flags,
 588                                        true)) {
 589     ResourceMark rm(THREAD);
 590     Exceptions::fthrow(
 591       THREAD_AND_LOCATION,
 592       vmSymbols::java_lang_IllegalAccessError(),
 593       "tried to access method %s.%s%s from class %s",
 594       sel_klass->external_name(),
 595       sel_method->name()->as_C_string(),
 596       sel_method->signature()->as_C_string(),
 597       ref_klass->external_name()
 598     );
 599     return;
 600   }
 601 }
 602 
 603 methodHandle LinkResolver::resolve_method_statically(Bytecodes::Code code,
 604                                                      const constantPoolHandle& pool, int index, TRAPS) {
 605   // This method is used only
 606   // (1) in C2 from InlineTree::ok_to_inline (via ciMethod::check_call),
 607   // and
 608   // (2) in Bytecode_invoke::static_target
 609   // It appears to fail when applied to an invokeinterface call site.
 610   // FIXME: Remove this method and ciMethod::check_call; refactor to use the other LinkResolver entry points.
 611   // resolve klass
 612   if (code == Bytecodes::_invokedynamic) {
 613     Klass* resolved_klass = SystemDictionary::MethodHandle_klass();
 614     Symbol* method_name = vmSymbols::invoke_name();
 615     Symbol* method_signature = pool->signature_ref_at(index);
 616     Klass*  current_klass = pool->pool_holder();
 617     LinkInfo link_info(resolved_klass, method_name, method_signature, current_klass);
 618     return resolve_method(link_info, code, THREAD);
 619   }
 620 
 621   LinkInfo link_info(pool, index, methodHandle(), CHECK_NULL);
 622   Klass* resolved_klass = link_info.resolved_klass();
 623 
 624   if (pool->has_preresolution()
 625       || (resolved_klass == SystemDictionary::MethodHandle_klass() &&
 626           MethodHandles::is_signature_polymorphic_name(resolved_klass, link_info.name()))) {
 627     Method* result = ConstantPool::method_at_if_loaded(pool, index);
 628     if (result != NULL) {
 629       return methodHandle(THREAD, result);
 630     }
 631   }
 632 
 633   if (code == Bytecodes::_invokeinterface) {
 634     return resolve_interface_method(link_info, code, THREAD);
 635   } else if (code == Bytecodes::_invokevirtual) {
 636     return resolve_method(link_info, code, THREAD);
 637   } else if (!resolved_klass->is_interface()) {
 638     return resolve_method(link_info, code, THREAD);
 639   } else {
 640     return resolve_interface_method(link_info, code, THREAD);
 641   }
 642 }
 643 
 644 // Check and print a loader constraint violation message for method or interface method
 645 void LinkResolver::check_method_loader_constraints(const LinkInfo& link_info,
 646                                                    const methodHandle& resolved_method,
 647                                                    const char* method_type, TRAPS) {
 648   Handle current_loader(THREAD, link_info.current_klass()->class_loader());
 649   Handle resolved_loader(THREAD, resolved_method->method_holder()->class_loader());
 650 
 651   ResourceMark rm(THREAD);
 652   Symbol* failed_type_symbol =
 653     SystemDictionary::check_signature_loaders(link_info.signature(), current_loader,
 654                                               resolved_loader, true, CHECK);
 655   if (failed_type_symbol != NULL) {
 656     const char* msg = "loader constraint violation: when resolving %s"
 657       " \"%s\" the class loader (instance of %s) of the current class, %s,"
 658       " and the class loader (instance of %s) for the method's defining class, %s, have"
 659       " different Class objects for the type %s used in the signature";
 660     char* sig = link_info.method_string();
 661     const char* loader1_name = SystemDictionary::loader_name(current_loader());
 662     char* current = link_info.current_klass()->name()->as_C_string();
 663     const char* loader2_name = SystemDictionary::loader_name(resolved_loader());
 664     char* target = resolved_method->method_holder()->name()->as_C_string();
 665     char* failed_type_name = failed_type_symbol->as_C_string();
 666     size_t buflen = strlen(msg) + strlen(sig) + strlen(loader1_name) +
 667       strlen(current) + strlen(loader2_name) + strlen(target) +
 668       strlen(failed_type_name) + strlen(method_type) + 1;
 669     char* buf = NEW_RESOURCE_ARRAY_IN_THREAD(THREAD, char, buflen);
 670     jio_snprintf(buf, buflen, msg, method_type, sig, loader1_name, current, loader2_name,
 671                  target, failed_type_name);
 672     THROW_MSG(vmSymbols::java_lang_LinkageError(), buf);
 673   }
 674 }
 675 
 676 void LinkResolver::check_field_loader_constraints(Symbol* field, Symbol* sig,
 677                                                   Klass* current_klass,
 678                                                   Klass* sel_klass, TRAPS) {
 679   Handle ref_loader(THREAD, current_klass->class_loader());
 680   Handle sel_loader(THREAD, sel_klass->class_loader());
 681 
 682   ResourceMark rm(THREAD);  // needed for check_signature_loaders
 683   Symbol* failed_type_symbol =
 684     SystemDictionary::check_signature_loaders(sig,
 685                                               ref_loader, sel_loader,
 686                                               false,
 687                                               CHECK);
 688   if (failed_type_symbol != NULL) {
 689     const char* msg = "loader constraint violation: when resolving field"
 690       " \"%s\" the class loader (instance of %s) of the referring class, "
 691       "%s, and the class loader (instance of %s) for the field's resolved "
 692       "type, %s, have different Class objects for that type";
 693     char* field_name = field->as_C_string();
 694     const char* loader1_name = SystemDictionary::loader_name(ref_loader());
 695     char* sel = sel_klass->name()->as_C_string();
 696     const char* loader2_name = SystemDictionary::loader_name(sel_loader());
 697     char* failed_type_name = failed_type_symbol->as_C_string();
 698     size_t buflen = strlen(msg) + strlen(field_name) + strlen(loader1_name) +
 699                     strlen(sel) + strlen(loader2_name) + strlen(failed_type_name) + 1;
 700     char* buf = NEW_RESOURCE_ARRAY_IN_THREAD(THREAD, char, buflen);
 701     jio_snprintf(buf, buflen, msg, field_name, loader1_name, sel, loader2_name,
 702                      failed_type_name);
 703     THROW_MSG(vmSymbols::java_lang_LinkageError(), buf);
 704   }
 705 }
 706 
 707 methodHandle LinkResolver::resolve_method(const LinkInfo& link_info,
 708                                           Bytecodes::Code code, TRAPS) {
 709 
 710   Handle nested_exception;
 711   Klass* resolved_klass = link_info.resolved_klass();
 712 
 713   // 1. For invokevirtual, cannot call an interface method
 714   if (code == Bytecodes::_invokevirtual && resolved_klass->is_interface()) {
 715     ResourceMark rm(THREAD);
 716     char buf[200];
 717     jio_snprintf(buf, sizeof(buf), "Found interface %s, but class was expected",
 718         resolved_klass->external_name());
 719     THROW_MSG_NULL(vmSymbols::java_lang_IncompatibleClassChangeError(), buf);
 720   }
 721 
 722   // 2. check constant pool tag for called method - must be JVM_CONSTANT_Methodref
 723   if (!link_info.tag().is_invalid() && !link_info.tag().is_method()) {
 724     ResourceMark rm(THREAD);
 725     char buf[200];
 726     jio_snprintf(buf, sizeof(buf), "Method %s must be Methodref constant", link_info.method_string());
 727     THROW_MSG_NULL(vmSymbols::java_lang_IncompatibleClassChangeError(), buf);
 728   }
 729 
 730   // 3. lookup method in resolved klass and its super klasses
 731   methodHandle resolved_method(THREAD, lookup_method_in_klasses(link_info, true, false));
 732 
 733   // 4. lookup method in all the interfaces implemented by the resolved klass
 734   if (resolved_method.is_null() && !resolved_klass->is_array_klass()) { // not found in the class hierarchy
 735     resolved_method = methodHandle(THREAD, lookup_method_in_interfaces(link_info));
 736 
 737     if (resolved_method.is_null()) {
 738       // JSR 292:  see if this is an implicitly generated method MethodHandle.linkToVirtual(*...), etc
 739       resolved_method = lookup_polymorphic_method(link_info, (Handle*)NULL, (Handle*)NULL, THREAD);
 740       if (HAS_PENDING_EXCEPTION) {
 741         nested_exception = Handle(THREAD, PENDING_EXCEPTION);
 742         CLEAR_PENDING_EXCEPTION;
 743       }
 744     }
 745   }
 746 
 747   // 5. method lookup failed
 748   if (resolved_method.is_null()) {
 749     ResourceMark rm(THREAD);
 750     THROW_MSG_CAUSE_(vmSymbols::java_lang_NoSuchMethodError(),
 751                     Method::name_and_sig_as_C_string(resolved_klass,
 752                                                      link_info.name(),
 753                                                      link_info.signature()),
 754                     nested_exception, NULL);
 755   }
 756 
 757   // 5. access checks, access checking may be turned off when calling from within the VM.
 758   Klass* current_klass = link_info.current_klass();
 759   if (link_info.check_access()) {
 760     assert(current_klass != NULL , "current_klass should not be null");
 761 
 762     // check if method can be accessed by the referring class
 763     check_method_accessability(current_klass,
 764                                resolved_klass,
 765                                resolved_method->method_holder(),
 766                                resolved_method,
 767                                CHECK_NULL);
 768 
 769     // check loader constraints
 770     check_method_loader_constraints(link_info, resolved_method, "method", CHECK_NULL);
 771   }
 772 
 773   return resolved_method;
 774 }
 775 
 776 static void trace_method_resolution(const char* prefix,
 777                                     Klass* klass,
 778                                     Klass* resolved_klass,
 779                                     const methodHandle& method,
 780                                     bool logitables,
 781                                     int index = -1) {
 782 #ifndef PRODUCT
 783   ResourceMark rm;
 784   Log(itables) logi;
 785   LogStream lsi(logi.trace());
 786   Log(vtables) logv;
 787   LogStream lsv(logv.trace());
 788   outputStream* st;
 789   if (logitables) {
 790     st = &lsi;
 791   } else {
 792     st = &lsv;
 793   }
 794   st->print("%s%s, compile-time-class:%s, method:%s, method_holder:%s, access_flags: ",
 795             prefix,
 796             (klass == NULL ? "<NULL>" : klass->internal_name()),
 797             (resolved_klass == NULL ? "<NULL>" : resolved_klass->internal_name()),
 798             Method::name_and_sig_as_C_string(resolved_klass,
 799                                              method->name(),
 800                                              method->signature()),
 801             method->method_holder()->internal_name());
 802   method->print_linkage_flags(st);
 803   if (index != -1) {
 804     st->print("vtable_index:%d", index);
 805   }
 806   st->cr();
 807 #endif // PRODUCT
 808 }
 809 
 810 // Do linktime resolution of a method in the interface within the context of the specied bytecode.
 811 methodHandle LinkResolver::resolve_interface_method(const LinkInfo& link_info, Bytecodes::Code code, TRAPS) {
 812 
 813   Klass* resolved_klass = link_info.resolved_klass();
 814 
 815   // check if klass is interface
 816   if (!resolved_klass->is_interface()) {
 817     ResourceMark rm(THREAD);
 818     char buf[200];
 819     jio_snprintf(buf, sizeof(buf), "Found class %s, but interface was expected", resolved_klass->external_name());
 820     THROW_MSG_NULL(vmSymbols::java_lang_IncompatibleClassChangeError(), buf);
 821   }
 822 
 823   // check constant pool tag for called method - must be JVM_CONSTANT_InterfaceMethodref
 824   if (!link_info.tag().is_invalid() && !link_info.tag().is_interface_method()) {
 825     ResourceMark rm(THREAD);
 826     char buf[200];
 827     jio_snprintf(buf, sizeof(buf), "Method %s must be InterfaceMethodref constant", link_info.method_string());
 828     THROW_MSG_NULL(vmSymbols::java_lang_IncompatibleClassChangeError(), buf);
 829   }
 830 
 831   // lookup method in this interface or its super, java.lang.Object
 832   // JDK8: also look for static methods
 833   methodHandle resolved_method(THREAD, lookup_method_in_klasses(link_info, false, true));
 834 
 835   if (resolved_method.is_null() && !resolved_klass->is_array_klass()) {
 836     // lookup method in all the super-interfaces
 837     resolved_method = methodHandle(THREAD, lookup_method_in_interfaces(link_info));
 838   }
 839 
 840   if (resolved_method.is_null()) {
 841     // no method found
 842     ResourceMark rm(THREAD);
 843     THROW_MSG_NULL(vmSymbols::java_lang_NoSuchMethodError(),
 844                    Method::name_and_sig_as_C_string(resolved_klass,
 845                                                     link_info.name(),
 846                                                     link_info.signature()));
 847   }
 848 
 849   if (link_info.check_access()) {
 850     // JDK8 adds non-public interface methods, and accessability check requirement
 851     Klass* current_klass = link_info.current_klass();
 852 
 853     assert(current_klass != NULL , "current_klass should not be null");
 854 
 855     // check if method can be accessed by the referring class
 856     check_method_accessability(current_klass,
 857                                resolved_klass,
 858                                resolved_method->method_holder(),
 859                                resolved_method,
 860                                CHECK_NULL);
 861 
 862     check_method_loader_constraints(link_info, resolved_method, "interface method", CHECK_NULL);
 863   }
 864 
 865   if (code != Bytecodes::_invokestatic && resolved_method->is_static()) {
 866     ResourceMark rm(THREAD);
 867     char buf[200];
 868     jio_snprintf(buf, sizeof(buf), "Expected instance not static method %s",
 869                  Method::name_and_sig_as_C_string(resolved_klass,
 870                  resolved_method->name(), resolved_method->signature()));
 871     THROW_MSG_NULL(vmSymbols::java_lang_IncompatibleClassChangeError(), buf);
 872   }
 873 
 874   if (code == Bytecodes::_invokeinterface && resolved_method->is_private()) {
 875     ResourceMark rm(THREAD);
 876     char buf[200];
 877 
 878     Klass* current_klass = link_info.current_klass();
 879     jio_snprintf(buf, sizeof(buf), "private interface method requires invokespecial, not invokeinterface: method %s, caller-class:%s",
 880                  Method::name_and_sig_as_C_string(resolved_klass,
 881                                                   resolved_method->name(),
 882                                                   resolved_method->signature()),
 883                                                   (current_klass == NULL ? "<NULL>" : current_klass->internal_name()));
 884      THROW_MSG_NULL(vmSymbols::java_lang_IncompatibleClassChangeError(), buf);
 885   }
 886 
 887   if (log_develop_is_enabled(Trace, itables)) {
 888     char buf[200];
 889     jio_snprintf(buf, sizeof(buf), "%s resolved interface method: caller-class:",
 890                  Bytecodes::name(code));
 891     trace_method_resolution(buf, link_info.current_klass(), resolved_klass,
 892                             resolved_method, true);
 893   }
 894 
 895   return resolved_method;
 896 }
 897 
 898 //------------------------------------------------------------------------------------------------------------------------
 899 // Field resolution
 900 
 901 void LinkResolver::check_field_accessability(Klass* ref_klass,
 902                                              Klass* resolved_klass,
 903                                              Klass* sel_klass,
 904                                              const fieldDescriptor& fd,
 905                                              TRAPS) {
 906   if (!Reflection::verify_field_access(ref_klass,
 907                                        resolved_klass,
 908                                        sel_klass,
 909                                        fd.access_flags(),
 910                                        true)) {
 911     ResourceMark rm(THREAD);
 912     Exceptions::fthrow(
 913       THREAD_AND_LOCATION,
 914       vmSymbols::java_lang_IllegalAccessError(),
 915       "tried to access field %s.%s from class %s",
 916       sel_klass->external_name(),
 917       fd.name()->as_C_string(),
 918       ref_klass->external_name()
 919     );
 920     return;
 921   }
 922 }
 923 
 924 void LinkResolver::resolve_field_access(fieldDescriptor& fd, const constantPoolHandle& pool, int index, const methodHandle& method, Bytecodes::Code byte, TRAPS) {
 925   LinkInfo link_info(pool, index, method, CHECK);
 926   resolve_field(fd, link_info, byte, true, CHECK);
 927 }
 928 
 929 void LinkResolver::resolve_field(fieldDescriptor& fd,
 930                                  const LinkInfo& link_info,
 931                                  Bytecodes::Code byte, bool initialize_class,
 932                                  TRAPS) {
 933   assert(byte == Bytecodes::_getstatic || byte == Bytecodes::_putstatic ||
 934          byte == Bytecodes::_getfield  || byte == Bytecodes::_putfield  ||
 935          byte == Bytecodes::_nofast_getfield  || byte == Bytecodes::_nofast_putfield  ||
 936          (byte == Bytecodes::_nop && !link_info.check_access()), "bad field access bytecode");
 937 
 938   bool is_static = (byte == Bytecodes::_getstatic || byte == Bytecodes::_putstatic);
 939   bool is_put    = (byte == Bytecodes::_putfield  || byte == Bytecodes::_putstatic || byte == Bytecodes::_nofast_putfield);
 940   // Check if there's a resolved klass containing the field
 941   Klass* resolved_klass = link_info.resolved_klass();
 942   Symbol* field = link_info.name();
 943   Symbol* sig = link_info.signature();
 944 
 945   if (resolved_klass == NULL) {
 946     ResourceMark rm(THREAD);
 947     THROW_MSG(vmSymbols::java_lang_NoSuchFieldError(), field->as_C_string());
 948   }
 949 
 950   // Resolve instance field
 951   Klass* sel_klass = resolved_klass->find_field(field, sig, &fd);
 952   // check if field exists; i.e., if a klass containing the field def has been selected
 953   if (sel_klass == NULL) {
 954     ResourceMark rm(THREAD);
 955     THROW_MSG(vmSymbols::java_lang_NoSuchFieldError(), field->as_C_string());
 956   }
 957 
 958   if (!link_info.check_access())
 959     // Access checking may be turned off when calling from within the VM.
 960     return;
 961 
 962   // check access
 963   Klass* current_klass = link_info.current_klass();
 964   check_field_accessability(current_klass, resolved_klass, sel_klass, fd, CHECK);
 965 
 966   // check for errors
 967   if (is_static != fd.is_static()) {
 968     ResourceMark rm(THREAD);
 969     char msg[200];
 970     jio_snprintf(msg, sizeof(msg), "Expected %s field %s.%s", is_static ? "static" : "non-static", resolved_klass->external_name(), fd.name()->as_C_string());
 971     THROW_MSG(vmSymbols::java_lang_IncompatibleClassChangeError(), msg);
 972   }
 973 
 974   // A final field can be modified only
 975   // (1) by methods declared in the class declaring the field and
 976   // (2) by the <clinit> method (in case of a static field)
 977   //     or by the <init> method (in case of an instance field).
 978   if (is_put && fd.access_flags().is_final()) {
 979     ResourceMark rm(THREAD);
 980     stringStream ss;
 981 
 982     if (sel_klass != current_klass) {
 983       ss.print("Update to %s final field %s.%s attempted from a different class (%s) than the field's declaring class",
 984                 is_static ? "static" : "non-static", resolved_klass->external_name(), fd.name()->as_C_string(),
 985                 current_klass->external_name());
 986       THROW_MSG(vmSymbols::java_lang_IllegalAccessError(), ss.as_string());
 987     }
 988 
 989     if (fd.constants()->pool_holder()->major_version() >= 53) {
 990       methodHandle m = link_info.current_method();
 991       assert(!m.is_null(), "information about the current method must be available for 'put' bytecodes");
 992       bool is_initialized_static_final_update = (byte == Bytecodes::_putstatic &&
 993                                                  fd.is_static() &&
 994                                                  !m()->is_static_initializer());
 995       bool is_initialized_instance_final_update = ((byte == Bytecodes::_putfield || byte == Bytecodes::_nofast_putfield) &&
 996                                                    !fd.is_static() &&
 997                                                    !m->is_object_initializer());
 998 
 999       if (is_initialized_static_final_update || is_initialized_instance_final_update) {
1000         ss.print("Update to %s final field %s.%s attempted from a different method (%s) than the initializer method %s ",
1001                  is_static ? "static" : "non-static", resolved_klass->external_name(), fd.name()->as_C_string(),
1002                  m()->name()->as_C_string(),
1003                  is_static ? "<clinit>" : "<init>");
1004         THROW_MSG(vmSymbols::java_lang_IllegalAccessError(), ss.as_string());
1005       }
1006     }
1007   }
1008 
1009   // initialize resolved_klass if necessary
1010   // note 1: the klass which declared the field must be initialized (i.e, sel_klass)
1011   //         according to the newest JVM spec (5.5, p.170) - was bug (gri 7/28/99)
1012   //
1013   // note 2: we don't want to force initialization if we are just checking
1014   //         if the field access is legal; e.g., during compilation
1015   if (is_static && initialize_class) {
1016     sel_klass->initialize(CHECK);
1017   }
1018 
1019   if (sel_klass != current_klass) {
1020     check_field_loader_constraints(field, sig, current_klass, sel_klass, CHECK);
1021   }
1022 
1023   // return information. note that the klass is set to the actual klass containing the
1024   // field, otherwise access of static fields in superclasses will not work.
1025 }
1026 
1027 
1028 //------------------------------------------------------------------------------------------------------------------------
1029 // Invoke resolution
1030 //
1031 // Naming conventions:
1032 //
1033 // resolved_method    the specified method (i.e., static receiver specified via constant pool index)
1034 // sel_method         the selected method  (selected via run-time lookup; e.g., based on dynamic receiver class)
1035 // resolved_klass     the specified klass  (i.e., specified via constant pool index)
1036 // recv_klass         the receiver klass
1037 
1038 
1039 void LinkResolver::resolve_static_call(CallInfo& result,
1040                                        const LinkInfo& link_info,
1041                                        bool initialize_class, TRAPS) {
1042   methodHandle resolved_method = linktime_resolve_static_method(link_info, CHECK);
1043 
1044   // The resolved class can change as a result of this resolution.
1045   Klass* resolved_klass = resolved_method->method_holder();
1046 
1047   // Initialize klass (this should only happen if everything is ok)
1048   if (initialize_class && resolved_klass->should_be_initialized()) {
1049     resolved_klass->initialize(CHECK);
1050     // Use updated LinkInfo to reresolve with resolved method holder
1051     LinkInfo new_info(resolved_klass, link_info.name(), link_info.signature(),
1052                       link_info.current_klass(),
1053                       link_info.check_access() ? LinkInfo::needs_access_check : LinkInfo::skip_access_check);
1054     resolved_method = linktime_resolve_static_method(new_info, CHECK);
1055   }
1056 
1057   // setup result
1058   result.set_static(resolved_klass, resolved_method, CHECK);
1059 }
1060 
1061 // throws linktime exceptions
1062 methodHandle LinkResolver::linktime_resolve_static_method(const LinkInfo& link_info, TRAPS) {
1063 
1064   Klass* resolved_klass = link_info.resolved_klass();
1065   methodHandle resolved_method;
1066   if (!resolved_klass->is_interface()) {
1067     resolved_method = resolve_method(link_info, Bytecodes::_invokestatic, CHECK_NULL);
1068   } else {
1069     resolved_method = resolve_interface_method(link_info, Bytecodes::_invokestatic, CHECK_NULL);
1070   }
1071   assert(resolved_method->name() != vmSymbols::class_initializer_name(), "should have been checked in verifier");
1072 
1073   // check if static
1074   if (!resolved_method->is_static()) {
1075     ResourceMark rm(THREAD);
1076     char buf[200];
1077     jio_snprintf(buf, sizeof(buf), "Expected static method %s", Method::name_and_sig_as_C_string(resolved_klass,
1078                                                       resolved_method->name(),
1079                                                       resolved_method->signature()));
1080     THROW_MSG_NULL(vmSymbols::java_lang_IncompatibleClassChangeError(), buf);
1081   }
1082   return resolved_method;
1083 }
1084 
1085 
1086 void LinkResolver::resolve_special_call(CallInfo& result,
1087                                         Handle recv,
1088                                         const LinkInfo& link_info,
1089                                         TRAPS) {
1090   methodHandle resolved_method = linktime_resolve_special_method(link_info, CHECK);
1091   runtime_resolve_special_method(result, link_info, resolved_method, recv, CHECK);
1092 }
1093 
1094 // throws linktime exceptions
1095 methodHandle LinkResolver::linktime_resolve_special_method(const LinkInfo& link_info,
1096                                                            TRAPS) {
1097 
1098   // Invokespecial is called for multiple special reasons:
1099   // <init>
1100   // local private method invocation, for classes and interfaces
1101   // superclass.method, which can also resolve to a default method
1102   // and the selected method is recalculated relative to the direct superclass
1103   // superinterface.method, which explicitly does not check shadowing
1104   Klass* resolved_klass = link_info.resolved_klass();
1105   methodHandle resolved_method;
1106 
1107   if (!resolved_klass->is_interface()) {
1108     resolved_method = resolve_method(link_info, Bytecodes::_invokespecial, CHECK_NULL);
1109   } else {
1110     resolved_method = resolve_interface_method(link_info, Bytecodes::_invokespecial, CHECK_NULL);
1111   }
1112 
1113   // check if method name is <init>, that it is found in same klass as static type
1114   if (resolved_method->name() == vmSymbols::object_initializer_name() &&
1115       resolved_method->method_holder() != resolved_klass) {
1116     ResourceMark rm(THREAD);
1117     Exceptions::fthrow(
1118       THREAD_AND_LOCATION,
1119       vmSymbols::java_lang_NoSuchMethodError(),
1120       "%s: method %s%s not found",
1121       resolved_klass->external_name(),
1122       resolved_method->name()->as_C_string(),
1123       resolved_method->signature()->as_C_string()
1124     );
1125     return NULL;
1126   }
1127 
1128   // check if invokespecial's interface method reference is in an indirect superinterface
1129   Klass* current_klass = link_info.current_klass();
1130   if (current_klass != NULL && resolved_klass->is_interface()) {
1131     InstanceKlass* ck = InstanceKlass::cast(current_klass);
1132     InstanceKlass *klass_to_check = !ck->is_anonymous() ?
1133                                     ck :
1134                                     InstanceKlass::cast(ck->host_klass());
1135     // Disable verification for the dynamically-generated reflection bytecodes.
1136     bool is_reflect = klass_to_check->is_subclass_of(
1137                         SystemDictionary::reflect_MagicAccessorImpl_klass());
1138 
1139     if (!is_reflect &&
1140         !klass_to_check->is_same_or_direct_interface(resolved_klass)) {
1141       ResourceMark rm(THREAD);
1142       char buf[200];
1143       jio_snprintf(buf, sizeof(buf),
1144                    "Interface method reference: %s, is in an indirect superinterface of %s",
1145                    Method::name_and_sig_as_C_string(resolved_klass,
1146                                                     resolved_method->name(),
1147                                                     resolved_method->signature()),
1148                    current_klass->external_name());
1149       THROW_MSG_NULL(vmSymbols::java_lang_IncompatibleClassChangeError(), buf);
1150     }
1151   }
1152 
1153   // check if not static
1154   if (resolved_method->is_static()) {
1155     ResourceMark rm(THREAD);
1156     char buf[200];
1157     jio_snprintf(buf, sizeof(buf),
1158                  "Expecting non-static method %s",
1159                  Method::name_and_sig_as_C_string(resolved_klass,
1160                                                   resolved_method->name(),
1161                                                   resolved_method->signature()));
1162     THROW_MSG_NULL(vmSymbols::java_lang_IncompatibleClassChangeError(), buf);
1163   }
1164 
1165   if (log_develop_is_enabled(Trace, itables)) {
1166     trace_method_resolution("invokespecial resolved method: caller-class:",
1167                             current_klass, resolved_klass, resolved_method, true);
1168   }
1169 
1170   return resolved_method;
1171 }
1172 
1173 // throws runtime exceptions
1174 void LinkResolver::runtime_resolve_special_method(CallInfo& result,
1175                                                   const LinkInfo& link_info,
1176                                                   const methodHandle& resolved_method,
1177                                                   Handle recv, TRAPS) {
1178 
1179   Klass* resolved_klass = link_info.resolved_klass();
1180 
1181   // resolved method is selected method unless we have an old-style lookup
1182   // for a superclass method
1183   // Invokespecial for a superinterface, resolved method is selected method,
1184   // no checks for shadowing
1185   methodHandle sel_method(THREAD, resolved_method());
1186 
1187   if (link_info.check_access() &&
1188       // check if the method is not <init>
1189       resolved_method->name() != vmSymbols::object_initializer_name()) {
1190 
1191      // check if this is an old-style super call and do a new lookup if so
1192         // a) check if ACC_SUPER flag is set for the current class
1193     Klass* current_klass = link_info.current_klass();
1194     if ((current_klass->is_super() || !AllowNonVirtualCalls) &&
1195         // b) check if the class of the resolved_klass is a superclass
1196         // (not supertype in order to exclude interface classes) of the current class.
1197         // This check is not performed for super.invoke for interface methods
1198         // in super interfaces.
1199         current_klass->is_subclass_of(resolved_klass) &&
1200         current_klass != resolved_klass) {
1201       // Lookup super method
1202       Klass* super_klass = current_klass->super();
1203       sel_method = lookup_instance_method_in_klasses(super_klass,
1204                            resolved_method->name(),
1205                            resolved_method->signature(), CHECK);
1206       // check if found
1207       if (sel_method.is_null()) {
1208         ResourceMark rm(THREAD);
1209         THROW_MSG(vmSymbols::java_lang_AbstractMethodError(),
1210                   Method::name_and_sig_as_C_string(resolved_klass,
1211                                             resolved_method->name(),
1212                                             resolved_method->signature()));
1213       // check loader constraints if found a different method
1214       } else if (sel_method() != resolved_method()) {
1215         check_method_loader_constraints(link_info, sel_method, "method", CHECK);
1216       }
1217     }
1218 
1219     // Check that the class of objectref (the receiver) is the current class or interface,
1220     // or a subtype of the current class or interface (the sender), otherwise invokespecial
1221     // throws IllegalAccessError.
1222     // The verifier checks that the sender is a subtype of the class in the I/MR operand.
1223     // The verifier also checks that the receiver is a subtype of the sender, if the sender is
1224     // a class.  If the sender is an interface, the check has to be performed at runtime.
1225     InstanceKlass* sender = InstanceKlass::cast(current_klass);
1226     sender = sender->is_anonymous() ? sender->host_klass() : sender;
1227     if (sender->is_interface() && recv.not_null()) {
1228       Klass* receiver_klass = recv->klass();
1229       if (!receiver_klass->is_subtype_of(sender)) {
1230         ResourceMark rm(THREAD);
1231         char buf[500];
1232         jio_snprintf(buf, sizeof(buf),
1233                      "Receiver class %s must be the current class or a subtype of interface %s",
1234                      receiver_klass->name()->as_C_string(),
1235                      sender->name()->as_C_string());
1236         THROW_MSG(vmSymbols::java_lang_IllegalAccessError(), buf);
1237       }
1238     }
1239   }
1240 
1241   // check if not static
1242   if (sel_method->is_static()) {
1243     ResourceMark rm(THREAD);
1244     char buf[200];
1245     jio_snprintf(buf, sizeof(buf), "Expecting non-static method %s", Method::name_and_sig_as_C_string(resolved_klass,
1246                                                                                       resolved_method->name(),
1247                                                                                       resolved_method->signature()));
1248     THROW_MSG(vmSymbols::java_lang_IncompatibleClassChangeError(), buf);
1249   }
1250 
1251   // check if abstract
1252   if (sel_method->is_abstract()) {
1253     ResourceMark rm(THREAD);
1254     THROW_MSG(vmSymbols::java_lang_AbstractMethodError(),
1255               Method::name_and_sig_as_C_string(resolved_klass,
1256                                                sel_method->name(),
1257                                                sel_method->signature()));
1258   }
1259 
1260   if (log_develop_is_enabled(Trace, itables)) {
1261     trace_method_resolution("invokespecial selected method: resolved-class:",
1262                             resolved_klass, resolved_klass, sel_method, true);
1263   }
1264 
1265   // setup result
1266   result.set_static(resolved_klass, sel_method, CHECK);
1267 }
1268 
1269 void LinkResolver::resolve_virtual_call(CallInfo& result, Handle recv, Klass* receiver_klass,
1270                                         const LinkInfo& link_info,
1271                                         bool check_null_and_abstract, TRAPS) {
1272   methodHandle resolved_method = linktime_resolve_virtual_method(link_info, CHECK);
1273   runtime_resolve_virtual_method(result, resolved_method,
1274                                  link_info.resolved_klass(),
1275                                  recv, receiver_klass,
1276                                  check_null_and_abstract, CHECK);
1277 }
1278 
1279 // throws linktime exceptions
1280 methodHandle LinkResolver::linktime_resolve_virtual_method(const LinkInfo& link_info,
1281                                                            TRAPS) {
1282   // normal method resolution
1283   methodHandle resolved_method = resolve_method(link_info, Bytecodes::_invokevirtual, CHECK_NULL);
1284 
1285   assert(resolved_method->name() != vmSymbols::object_initializer_name(), "should have been checked in verifier");
1286   assert(resolved_method->name() != vmSymbols::class_initializer_name (), "should have been checked in verifier");
1287 
1288   // check if private interface method
1289   Klass* resolved_klass = link_info.resolved_klass();
1290   Klass* current_klass = link_info.current_klass();
1291 
1292   // This is impossible, if resolve_klass is an interface, we've thrown icce in resolve_method
1293   if (resolved_klass->is_interface() && resolved_method->is_private()) {
1294     ResourceMark rm(THREAD);
1295     char buf[200];
1296     jio_snprintf(buf, sizeof(buf), "private interface method requires invokespecial, not invokevirtual: method %s, caller-class:%s",
1297                  Method::name_and_sig_as_C_string(resolved_klass,
1298                                                   resolved_method->name(),
1299                                                   resolved_method->signature()),
1300                    (current_klass == NULL ? "<NULL>" : current_klass->internal_name()));
1301     THROW_MSG_NULL(vmSymbols::java_lang_IncompatibleClassChangeError(), buf);
1302   }
1303 
1304   // check if not static
1305   if (resolved_method->is_static()) {
1306     ResourceMark rm(THREAD);
1307     char buf[200];
1308     jio_snprintf(buf, sizeof(buf), "Expecting non-static method %s", Method::name_and_sig_as_C_string(resolved_klass,
1309                                                                                            resolved_method->name(),
1310                                                                                            resolved_method->signature()));
1311     THROW_MSG_NULL(vmSymbols::java_lang_IncompatibleClassChangeError(), buf);
1312   }
1313 
1314   if (log_develop_is_enabled(Trace, vtables)) {
1315     trace_method_resolution("invokevirtual resolved method: caller-class:",
1316                             current_klass, resolved_klass, resolved_method, false);
1317   }
1318 
1319   return resolved_method;
1320 }
1321 
1322 // throws runtime exceptions
1323 void LinkResolver::runtime_resolve_virtual_method(CallInfo& result,
1324                                                   const methodHandle& resolved_method,
1325                                                   Klass* resolved_klass,
1326                                                   Handle recv,
1327                                                   Klass* recv_klass,
1328                                                   bool check_null_and_abstract,
1329                                                   TRAPS) {
1330 
1331   // setup default return values
1332   int vtable_index = Method::invalid_vtable_index;
1333   methodHandle selected_method;
1334 
1335   // runtime method resolution
1336   if (check_null_and_abstract && recv.is_null()) { // check if receiver exists
1337     THROW(vmSymbols::java_lang_NullPointerException());
1338   }
1339 
1340   // Virtual methods cannot be resolved before its klass has been linked, for otherwise the Method*'s
1341   // has not been rewritten, and the vtable initialized. Make sure to do this after the nullcheck, since
1342   // a missing receiver might result in a bogus lookup.
1343   assert(resolved_method->method_holder()->is_linked(), "must be linked");
1344 
1345   // do lookup based on receiver klass using the vtable index
1346   if (resolved_method->method_holder()->is_interface()) { // default or miranda method
1347     vtable_index = vtable_index_of_interface_method(resolved_klass, resolved_method);
1348     assert(vtable_index >= 0 , "we should have valid vtable index at this point");
1349 
1350     selected_method = methodHandle(THREAD, recv_klass->method_at_vtable(vtable_index));
1351   } else {
1352     // at this point we are sure that resolved_method is virtual and not
1353     // a default or miranda method; therefore, it must have a valid vtable index.
1354     assert(!resolved_method->has_itable_index(), "");
1355     vtable_index = resolved_method->vtable_index();
1356     // We could get a negative vtable_index for final methods,
1357     // because as an optimization they are never put in the vtable,
1358     // unless they override an existing method.
1359     // If we do get a negative, it means the resolved method is the the selected
1360     // method, and it can never be changed by an override.
1361     if (vtable_index == Method::nonvirtual_vtable_index) {
1362       assert(resolved_method->can_be_statically_bound(), "cannot override this method");
1363       selected_method = resolved_method;
1364     } else {
1365       selected_method = methodHandle(THREAD, recv_klass->method_at_vtable(vtable_index));
1366     }
1367   }
1368 
1369   // check if method exists
1370   if (selected_method.is_null()) {
1371     throw_abstract_method_error(resolved_method, recv_klass, CHECK);
1372   }
1373 
1374   // check if abstract
1375   if (check_null_and_abstract && selected_method->is_abstract()) {
1376     // Pass arguments for generating a verbose error message.
1377     throw_abstract_method_error(resolved_method, selected_method, recv_klass, CHECK);
1378   }
1379 
1380   if (log_develop_is_enabled(Trace, vtables)) {
1381     trace_method_resolution("invokevirtual selected method: receiver-class:",
1382                             recv_klass, resolved_klass, selected_method,
1383                             false, vtable_index);
1384   }
1385   // setup result
1386   result.set_virtual(resolved_klass, recv_klass, resolved_method, selected_method, vtable_index, CHECK);
1387 }
1388 
1389 void LinkResolver::resolve_interface_call(CallInfo& result, Handle recv, Klass* recv_klass,
1390                                           const LinkInfo& link_info,
1391                                           bool check_null_and_abstract, TRAPS) {
1392   // throws linktime exceptions
1393   methodHandle resolved_method = linktime_resolve_interface_method(link_info, CHECK);
1394   runtime_resolve_interface_method(result, resolved_method,link_info.resolved_klass(),
1395                                    recv, recv_klass, check_null_and_abstract, CHECK);
1396 }
1397 
1398 methodHandle LinkResolver::linktime_resolve_interface_method(const LinkInfo& link_info,
1399                                                              TRAPS) {
1400   // normal interface method resolution
1401   methodHandle resolved_method = resolve_interface_method(link_info, Bytecodes::_invokeinterface, CHECK_NULL);
1402   assert(resolved_method->name() != vmSymbols::object_initializer_name(), "should have been checked in verifier");
1403   assert(resolved_method->name() != vmSymbols::class_initializer_name (), "should have been checked in verifier");
1404 
1405   return resolved_method;
1406 }
1407 
1408 // throws runtime exceptions
1409 void LinkResolver::runtime_resolve_interface_method(CallInfo& result,
1410                                                     const methodHandle& resolved_method,
1411                                                     Klass* resolved_klass,
1412                                                     Handle recv,
1413                                                     Klass* recv_klass,
1414                                                     bool check_null_and_abstract, TRAPS) {
1415   // check if receiver exists
1416   if (check_null_and_abstract && recv.is_null()) {
1417     THROW(vmSymbols::java_lang_NullPointerException());
1418   }
1419 
1420   // check if receiver klass implements the resolved interface
1421   if (!recv_klass->is_subtype_of(resolved_klass)) {
1422     ResourceMark rm(THREAD);
1423     char buf[200];
1424     jio_snprintf(buf, sizeof(buf), "Class %s does not implement the requested interface %s",
1425                  recv_klass->external_name(),
1426                  resolved_klass->external_name());
1427     THROW_MSG(vmSymbols::java_lang_IncompatibleClassChangeError(), buf);
1428   }
1429 
1430   // do lookup based on receiver klass
1431   // This search must match the linktime preparation search for itable initialization
1432   // to correctly enforce loader constraints for interface method inheritance
1433   methodHandle selected_method = lookup_instance_method_in_klasses(recv_klass,
1434                                                   resolved_method->name(),
1435                                                   resolved_method->signature(), CHECK);
1436   if (selected_method.is_null() && !check_null_and_abstract) {
1437     // In theory this is a harmless placeholder value, but
1438     // in practice leaving in null affects the nsk default method tests.
1439     // This needs further study.
1440     selected_method = resolved_method;
1441   }
1442   // check if method exists
1443   if (selected_method.is_null()) {
1444     // Pass arguments for generating a verbose error message.
1445     throw_abstract_method_error(resolved_method, recv_klass, CHECK);
1446   }
1447   // check access
1448   // Throw Illegal Access Error if selected_method is not public.
1449   if (!selected_method->is_public()) {
1450     ResourceMark rm(THREAD);
1451     THROW_MSG(vmSymbols::java_lang_IllegalAccessError(),
1452               Method::name_and_sig_as_C_string(recv_klass,
1453                                                selected_method->name(),
1454                                                selected_method->signature()));
1455   }
1456   // check if abstract
1457   if (check_null_and_abstract && selected_method->is_abstract()) {
1458     throw_abstract_method_error(resolved_method, selected_method, recv_klass, CHECK);
1459   }
1460 
1461   if (log_develop_is_enabled(Trace, itables)) {
1462     trace_method_resolution("invokeinterface selected method: receiver-class:",
1463                             recv_klass, resolved_klass, selected_method, true);
1464   }
1465   // setup result
1466   if (!resolved_method->has_itable_index()) {
1467     int vtable_index = resolved_method->vtable_index();
1468     assert(vtable_index == selected_method->vtable_index(), "sanity check");
1469     result.set_virtual(resolved_klass, recv_klass, resolved_method, selected_method, vtable_index, CHECK);
1470   } else {
1471     int itable_index = resolved_method()->itable_index();
1472     result.set_interface(resolved_klass, recv_klass, resolved_method, selected_method, itable_index, CHECK);
1473   }
1474 }
1475 
1476 
1477 methodHandle LinkResolver::linktime_resolve_interface_method_or_null(
1478                                                  const LinkInfo& link_info) {
1479   EXCEPTION_MARK;
1480   methodHandle method_result = linktime_resolve_interface_method(link_info, THREAD);
1481   if (HAS_PENDING_EXCEPTION) {
1482     CLEAR_PENDING_EXCEPTION;
1483     return methodHandle();
1484   } else {
1485     return method_result;
1486   }
1487 }
1488 
1489 methodHandle LinkResolver::linktime_resolve_virtual_method_or_null(
1490                                                  const LinkInfo& link_info) {
1491   EXCEPTION_MARK;
1492   methodHandle method_result = linktime_resolve_virtual_method(link_info, THREAD);
1493   if (HAS_PENDING_EXCEPTION) {
1494     CLEAR_PENDING_EXCEPTION;
1495     return methodHandle();
1496   } else {
1497     return method_result;
1498   }
1499 }
1500 
1501 methodHandle LinkResolver::resolve_virtual_call_or_null(
1502                                                  Klass* receiver_klass,
1503                                                  const LinkInfo& link_info) {
1504   EXCEPTION_MARK;
1505   CallInfo info;
1506   resolve_virtual_call(info, Handle(), receiver_klass, link_info, false, THREAD);
1507   if (HAS_PENDING_EXCEPTION) {
1508     CLEAR_PENDING_EXCEPTION;
1509     return methodHandle();
1510   }
1511   return info.selected_method();
1512 }
1513 
1514 methodHandle LinkResolver::resolve_interface_call_or_null(
1515                                                  Klass* receiver_klass,
1516                                                  const LinkInfo& link_info) {
1517   EXCEPTION_MARK;
1518   CallInfo info;
1519   resolve_interface_call(info, Handle(), receiver_klass, link_info, false, THREAD);
1520   if (HAS_PENDING_EXCEPTION) {
1521     CLEAR_PENDING_EXCEPTION;
1522     return methodHandle();
1523   }
1524   return info.selected_method();
1525 }
1526 
1527 int LinkResolver::resolve_virtual_vtable_index(Klass* receiver_klass,
1528                                                const LinkInfo& link_info) {
1529   EXCEPTION_MARK;
1530   CallInfo info;
1531   resolve_virtual_call(info, Handle(), receiver_klass, link_info,
1532                        /*check_null_or_abstract*/false, THREAD);
1533   if (HAS_PENDING_EXCEPTION) {
1534     CLEAR_PENDING_EXCEPTION;
1535     return Method::invalid_vtable_index;
1536   }
1537   return info.vtable_index();
1538 }
1539 
1540 methodHandle LinkResolver::resolve_static_call_or_null(const LinkInfo& link_info) {
1541   EXCEPTION_MARK;
1542   CallInfo info;
1543   resolve_static_call(info, link_info, /*initialize_class*/false, THREAD);
1544   if (HAS_PENDING_EXCEPTION) {
1545     CLEAR_PENDING_EXCEPTION;
1546     return methodHandle();
1547   }
1548   return info.selected_method();
1549 }
1550 
1551 methodHandle LinkResolver::resolve_special_call_or_null(const LinkInfo& link_info) {
1552   EXCEPTION_MARK;
1553   CallInfo info;
1554   resolve_special_call(info, Handle(), link_info, THREAD);
1555   if (HAS_PENDING_EXCEPTION) {
1556     CLEAR_PENDING_EXCEPTION;
1557     return methodHandle();
1558   }
1559   return info.selected_method();
1560 }
1561 
1562 
1563 
1564 //------------------------------------------------------------------------------------------------------------------------
1565 // ConstantPool entries
1566 
1567 void LinkResolver::resolve_invoke(CallInfo& result, Handle recv, const constantPoolHandle& pool, int index, Bytecodes::Code byte, TRAPS) {
1568   switch (byte) {
1569     case Bytecodes::_invokestatic   : resolve_invokestatic   (result,       pool, index, CHECK); break;
1570     case Bytecodes::_invokespecial  : resolve_invokespecial  (result, recv, pool, index, CHECK); break;
1571     case Bytecodes::_invokevirtual  : resolve_invokevirtual  (result, recv, pool, index, CHECK); break;
1572     case Bytecodes::_invokehandle   : resolve_invokehandle   (result,       pool, index, CHECK); break;
1573     case Bytecodes::_invokedynamic  : resolve_invokedynamic  (result,       pool, index, CHECK); break;
1574     case Bytecodes::_invokeinterface: resolve_invokeinterface(result, recv, pool, index, CHECK); break;
1575     default                         :                                                            break;
1576   }
1577   return;
1578 }
1579 
1580 void LinkResolver::resolve_invoke(CallInfo& result, Handle& recv,
1581                              const methodHandle& attached_method,
1582                              Bytecodes::Code byte, TRAPS) {
1583   Klass* defc = attached_method->method_holder();
1584   Symbol* name = attached_method->name();
1585   Symbol* type = attached_method->signature();
1586   LinkInfo link_info(defc, name, type);
1587   switch(byte) {
1588     case Bytecodes::_invokevirtual:
1589       resolve_virtual_call(result, recv, recv->klass(), link_info,
1590                            /*check_null_and_abstract=*/true, CHECK);
1591       break;
1592     case Bytecodes::_invokeinterface:
1593       resolve_interface_call(result, recv, recv->klass(), link_info,
1594                              /*check_null_and_abstract=*/true, CHECK);
1595       break;
1596     case Bytecodes::_invokestatic:
1597       resolve_static_call(result, link_info, /*initialize_class=*/false, CHECK);
1598       break;
1599     case Bytecodes::_invokespecial:
1600       resolve_special_call(result, recv, link_info, CHECK);
1601       break;
1602     default:
1603       fatal("bad call: %s", Bytecodes::name(byte));
1604       break;
1605   }
1606 }
1607 
1608 void LinkResolver::resolve_invokestatic(CallInfo& result, const constantPoolHandle& pool, int index, TRAPS) {
1609   LinkInfo link_info(pool, index, CHECK);
1610   resolve_static_call(result, link_info, /*initialize_class*/true, CHECK);
1611 }
1612 
1613 
1614 void LinkResolver::resolve_invokespecial(CallInfo& result, Handle recv,
1615                                          const constantPoolHandle& pool, int index, TRAPS) {
1616   LinkInfo link_info(pool, index, CHECK);
1617   resolve_special_call(result, recv, link_info, CHECK);
1618 }
1619 
1620 
1621 void LinkResolver::resolve_invokevirtual(CallInfo& result, Handle recv,
1622                                           const constantPoolHandle& pool, int index,
1623                                           TRAPS) {
1624 
1625   LinkInfo link_info(pool, index, CHECK);
1626   Klass* recvrKlass = recv.is_null() ? (Klass*)NULL : recv->klass();
1627   resolve_virtual_call(result, recv, recvrKlass, link_info, /*check_null_or_abstract*/true, CHECK);
1628 }
1629 
1630 
1631 void LinkResolver::resolve_invokeinterface(CallInfo& result, Handle recv, const constantPoolHandle& pool, int index, TRAPS) {
1632   LinkInfo link_info(pool, index, CHECK);
1633   Klass* recvrKlass = recv.is_null() ? (Klass*)NULL : recv->klass();
1634   resolve_interface_call(result, recv, recvrKlass, link_info, true, CHECK);
1635 }
1636 
1637 
1638 void LinkResolver::resolve_invokehandle(CallInfo& result, const constantPoolHandle& pool, int index, TRAPS) {
1639   // This guy is reached from InterpreterRuntime::resolve_invokehandle.
1640   LinkInfo link_info(pool, index, CHECK);
1641   if (TraceMethodHandles) {
1642     ResourceMark rm(THREAD);
1643     tty->print_cr("resolve_invokehandle %s %s", link_info.name()->as_C_string(),
1644                   link_info.signature()->as_C_string());
1645   }
1646   resolve_handle_call(result, link_info, CHECK);
1647 }
1648 
1649 void LinkResolver::resolve_handle_call(CallInfo& result,
1650                                        const LinkInfo& link_info,
1651                                        TRAPS) {
1652   // JSR 292:  this must be an implicitly generated method MethodHandle.invokeExact(*...) or similar
1653   Klass* resolved_klass = link_info.resolved_klass();
1654   assert(resolved_klass == SystemDictionary::MethodHandle_klass() ||
1655          resolved_klass == SystemDictionary::VarHandle_klass(), "");
1656   assert(MethodHandles::is_signature_polymorphic_name(link_info.name()), "");
1657   Handle       resolved_appendix;
1658   Handle       resolved_method_type;
1659   methodHandle resolved_method = lookup_polymorphic_method(link_info,
1660                                        &resolved_appendix, &resolved_method_type, CHECK);
1661   result.set_handle(resolved_klass, resolved_method, resolved_appendix, resolved_method_type, CHECK);
1662 }
1663 
1664 void LinkResolver::resolve_invokedynamic(CallInfo& result, const constantPoolHandle& pool, int index, TRAPS) {
1665   Symbol* method_name       = pool->name_ref_at(index);
1666   Symbol* method_signature  = pool->signature_ref_at(index);
1667   Klass* current_klass = pool->pool_holder();
1668 
1669   // Resolve the bootstrap specifier (BSM + optional arguments).
1670   Handle bootstrap_specifier;
1671   // Check if CallSite has been bound already:
1672   ConstantPoolCacheEntry* cpce = pool->invokedynamic_cp_cache_entry_at(index);
1673   int pool_index = cpce->constant_pool_index();
1674 
1675   if (cpce->is_f1_null()) {
1676     if (cpce->indy_resolution_failed()) {
1677       ConstantPool::throw_resolution_error(pool,
1678                                            ResolutionErrorTable::encode_cpcache_index(index),
1679                                            CHECK);
1680     }
1681 
1682     // The initial step in Call Site Specifier Resolution is to resolve the symbolic
1683     // reference to a method handle which will be the bootstrap method for a dynamic
1684     // call site.  If resolution for the java.lang.invoke.MethodHandle for the bootstrap
1685     // method fails, then a MethodHandleInError is stored at the corresponding bootstrap
1686     // method's CP index for the CONSTANT_MethodHandle_info.  So, there is no need to
1687     // set the indy_rf flag since any subsequent invokedynamic instruction which shares
1688     // this bootstrap method will encounter the resolution of MethodHandleInError.
1689     oop bsm_info = pool->resolve_bootstrap_specifier_at(pool_index, THREAD);
1690     Exceptions::wrap_dynamic_exception(CHECK);
1691     assert(bsm_info != NULL, "");
1692     // FIXME: Cache this once per BootstrapMethods entry, not once per CONSTANT_InvokeDynamic.
1693     bootstrap_specifier = Handle(THREAD, bsm_info);
1694   }
1695   if (!cpce->is_f1_null()) {
1696     methodHandle method(     THREAD, cpce->f1_as_method());
1697     Handle       appendix(   THREAD, cpce->appendix_if_resolved(pool));
1698     Handle       method_type(THREAD, cpce->method_type_if_resolved(pool));
1699     result.set_handle(method, appendix, method_type, THREAD);
1700     Exceptions::wrap_dynamic_exception(CHECK);
1701     return;
1702   }
1703 
1704   if (TraceMethodHandles) {
1705     ResourceMark rm(THREAD);
1706     tty->print_cr("resolve_invokedynamic #%d %s %s in %s",
1707                   ConstantPool::decode_invokedynamic_index(index),
1708                   method_name->as_C_string(), method_signature->as_C_string(),
1709                   current_klass->name()->as_C_string());
1710     tty->print("  BSM info: "); bootstrap_specifier->print();
1711   }
1712 
1713   resolve_dynamic_call(result, pool_index, bootstrap_specifier, method_name,
1714                        method_signature, current_klass, THREAD);
1715   if (HAS_PENDING_EXCEPTION && PENDING_EXCEPTION->is_a(SystemDictionary::LinkageError_klass())) {
1716     int encoded_index = ResolutionErrorTable::encode_cpcache_index(index);
1717     bool recorded_res_status = cpce->save_and_throw_indy_exc(pool, pool_index,
1718                                                              encoded_index,
1719                                                              pool()->tag_at(pool_index),
1720                                                              CHECK);
1721     if (!recorded_res_status) {
1722       // Another thread got here just before we did.  So, either use the method
1723       // that it resolved or throw the LinkageError exception that it threw.
1724       if (!cpce->is_f1_null()) {
1725         methodHandle method(     THREAD, cpce->f1_as_method());
1726         Handle       appendix(   THREAD, cpce->appendix_if_resolved(pool));
1727         Handle       method_type(THREAD, cpce->method_type_if_resolved(pool));
1728         result.set_handle(method, appendix, method_type, THREAD);
1729         Exceptions::wrap_dynamic_exception(CHECK);
1730       } else {
1731         assert(cpce->indy_resolution_failed(), "Resolution failure flag not set");
1732         ConstantPool::throw_resolution_error(pool, encoded_index, CHECK);
1733       }
1734       return;
1735     }
1736     assert(cpce->indy_resolution_failed(), "Resolution failure flag wasn't set");
1737   }
1738 }
1739 
1740 void LinkResolver::resolve_dynamic_call(CallInfo& result,
1741                                         int pool_index,
1742                                         Handle bootstrap_specifier,
1743                                         Symbol* method_name, Symbol* method_signature,
1744                                         Klass* current_klass,
1745                                         TRAPS) {
1746   // JSR 292:  this must resolve to an implicitly generated method MH.linkToCallSite(*...)
1747   // The appendix argument is likely to be a freshly-created CallSite.
1748   Handle       resolved_appendix;
1749   Handle       resolved_method_type;
1750   methodHandle resolved_method =
1751     SystemDictionary::find_dynamic_call_site_invoker(current_klass,
1752                                                      pool_index,
1753                                                      bootstrap_specifier,
1754                                                      method_name, method_signature,
1755                                                      &resolved_appendix,
1756                                                      &resolved_method_type,
1757                                                      THREAD);
1758   Exceptions::wrap_dynamic_exception(CHECK);
1759   result.set_handle(resolved_method, resolved_appendix, resolved_method_type, THREAD);
1760   Exceptions::wrap_dynamic_exception(CHECK);
1761 }
1762 
1763 // Selected method is abstract.
1764 void LinkResolver::throw_abstract_method_error(const methodHandle& resolved_method,
1765                                                const methodHandle& selected_method,
1766                                                Klass *recv_klass, TRAPS) {
1767   Klass *resolved_klass = resolved_method->method_holder();
1768   ResourceMark rm(THREAD);
1769   stringStream ss;
1770 
1771   if (recv_klass != NULL) {
1772     ss.print("Receiver class %s does not define or inherit an "
1773              "implementation of the",
1774              recv_klass->external_name());
1775   } else {
1776     ss.print("Missing implementation of");
1777   }
1778 
1779   assert(resolved_method.not_null(), "Sanity");
1780   ss.print(" resolved method %s%s%s%s of %s %s.",
1781            resolved_method->is_abstract() ? "abstract " : "",
1782            resolved_method->is_private()  ? "private "  : "",
1783            resolved_method->name()->as_C_string(),
1784            resolved_method->signature()->as_C_string(),
1785            resolved_klass->external_kind(),
1786            resolved_klass->external_name());
1787 
1788   if (selected_method.not_null() && !(resolved_method == selected_method)) {
1789     ss.print(" Selected method is %s%s%s.",
1790              selected_method->is_abstract() ? "abstract " : "",
1791              selected_method->is_private()  ? "private "  : "",
1792              selected_method->name_and_sig_as_C_string());
1793   }
1794 
1795   THROW_MSG(vmSymbols::java_lang_AbstractMethodError(), ss.as_string());
1796 }