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