1 /* 2 * Copyright (c) 1997, 2011, 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 "classfile/systemDictionary.hpp" 27 #include "classfile/vmSymbols.hpp" 28 #include "compiler/compileBroker.hpp" 29 #include "gc_interface/collectedHeap.inline.hpp" 30 #include "interpreter/bytecode.hpp" 31 #include "interpreter/interpreterRuntime.hpp" 32 #include "interpreter/linkResolver.hpp" 33 #include "memory/resourceArea.hpp" 34 #include "memory/universe.inline.hpp" 35 #include "oops/instanceKlass.hpp" 36 #include "oops/objArrayOop.hpp" 37 #include "prims/methodHandles.hpp" 38 #include "prims/nativeLookup.hpp" 39 #include "runtime/compilationPolicy.hpp" 40 #include "runtime/fieldDescriptor.hpp" 41 #include "runtime/frame.inline.hpp" 42 #include "runtime/handles.inline.hpp" 43 #include "runtime/reflection.hpp" 44 #include "runtime/signature.hpp" 45 #include "runtime/vmThread.hpp" 46 #ifdef TARGET_OS_FAMILY_linux 47 # include "thread_linux.inline.hpp" 48 #endif 49 #ifdef TARGET_OS_FAMILY_solaris 50 # include "thread_solaris.inline.hpp" 51 #endif 52 #ifdef TARGET_OS_FAMILY_windows 53 # include "thread_windows.inline.hpp" 54 #endif 55 56 //------------------------------------------------------------------------------------------------------------------------ 57 // Implementation of FieldAccessInfo 58 59 void FieldAccessInfo::set(KlassHandle klass, Symbol* name, int field_index, int field_offset, 60 BasicType field_type, AccessFlags access_flags) { 61 _klass = klass; 62 _name = name; 63 _field_index = field_index; 64 _field_offset = field_offset; 65 _field_type = field_type; 66 _access_flags = access_flags; 67 } 68 69 70 //------------------------------------------------------------------------------------------------------------------------ 71 // Implementation of CallInfo 72 73 74 void CallInfo::set_static(KlassHandle resolved_klass, methodHandle resolved_method, TRAPS) { 75 int vtable_index = methodOopDesc::nonvirtual_vtable_index; 76 set_common(resolved_klass, resolved_klass, resolved_method, resolved_method, vtable_index, CHECK); 77 } 78 79 80 void CallInfo::set_interface(KlassHandle resolved_klass, KlassHandle selected_klass, methodHandle resolved_method, methodHandle selected_method, TRAPS) { 81 // This is only called for interface methods. If the resolved_method 82 // comes from java/lang/Object, it can be the subject of a virtual call, so 83 // we should pick the vtable index from the resolved method. 84 // Other than that case, there is no valid vtable index to specify. 85 int vtable_index = methodOopDesc::invalid_vtable_index; 86 if (resolved_method->method_holder() == SystemDictionary::Object_klass()) { 87 assert(resolved_method->vtable_index() == selected_method->vtable_index(), "sanity check"); 88 vtable_index = resolved_method->vtable_index(); 89 } 90 set_common(resolved_klass, selected_klass, resolved_method, selected_method, vtable_index, CHECK); 91 } 92 93 void CallInfo::set_virtual(KlassHandle resolved_klass, KlassHandle selected_klass, methodHandle resolved_method, methodHandle selected_method, int vtable_index, TRAPS) { 94 assert(vtable_index >= 0 || vtable_index == methodOopDesc::nonvirtual_vtable_index, "valid index"); 95 set_common(resolved_klass, selected_klass, resolved_method, selected_method, vtable_index, CHECK); 96 } 97 98 void CallInfo::set_dynamic(methodHandle resolved_method, TRAPS) { 99 assert(resolved_method->is_method_handle_invoke(), ""); 100 KlassHandle resolved_klass = SystemDictionaryHandles::MethodHandle_klass(); 101 assert(resolved_klass == resolved_method->method_holder(), ""); 102 int vtable_index = methodOopDesc::nonvirtual_vtable_index; 103 assert(resolved_method->vtable_index() == vtable_index, ""); 104 set_common(resolved_klass, KlassHandle(), resolved_method, resolved_method, vtable_index, CHECK); 105 } 106 107 void CallInfo::set_common(KlassHandle resolved_klass, KlassHandle selected_klass, methodHandle resolved_method, methodHandle selected_method, int vtable_index, TRAPS) { 108 assert(resolved_method->signature() == selected_method->signature(), "signatures must correspond"); 109 _resolved_klass = resolved_klass; 110 _selected_klass = selected_klass; 111 _resolved_method = resolved_method; 112 _selected_method = selected_method; 113 _vtable_index = vtable_index; 114 if (CompilationPolicy::must_be_compiled(selected_method)) { 115 // This path is unusual, mostly used by the '-Xcomp' stress test mode. 116 117 // Note: with several active threads, the must_be_compiled may be true 118 // while can_be_compiled is false; remove assert 119 // assert(CompilationPolicy::can_be_compiled(selected_method), "cannot compile"); 120 if (THREAD->is_Compiler_thread()) { 121 // don't force compilation, resolve was on behalf of compiler 122 return; 123 } 124 if (instanceKlass::cast(selected_method->method_holder())->is_not_initialized()) { 125 // 'is_not_initialized' means not only '!is_initialized', but also that 126 // initialization has not been started yet ('!being_initialized') 127 // Do not force compilation of methods in uninitialized classes. 128 // Note that doing this would throw an assert later, 129 // in CompileBroker::compile_method. 130 // We sometimes use the link resolver to do reflective lookups 131 // even before classes are initialized. 132 return; 133 } 134 CompileBroker::compile_method(selected_method, InvocationEntryBci, 135 CompilationPolicy::policy()->initial_compile_level(), 136 methodHandle(), 0, "must_be_compiled", CHECK); 137 } 138 } 139 140 141 //------------------------------------------------------------------------------------------------------------------------ 142 // Klass resolution 143 144 void LinkResolver::check_klass_accessability(KlassHandle ref_klass, KlassHandle sel_klass, TRAPS) { 145 if (!Reflection::verify_class_access(ref_klass->as_klassOop(), 146 sel_klass->as_klassOop(), 147 true)) { 148 ResourceMark rm(THREAD); 149 Exceptions::fthrow( 150 THREAD_AND_LOCATION, 151 vmSymbols::java_lang_IllegalAccessError(), 152 "tried to access class %s from class %s", 153 sel_klass->external_name(), 154 ref_klass->external_name() 155 ); 156 return; 157 } 158 } 159 160 void LinkResolver::resolve_klass(KlassHandle& result, constantPoolHandle pool, int index, TRAPS) { 161 klassOop result_oop = pool->klass_ref_at(index, CHECK); 162 result = KlassHandle(THREAD, result_oop); 163 } 164 165 void LinkResolver::resolve_klass_no_update(KlassHandle& result, constantPoolHandle pool, int index, TRAPS) { 166 klassOop result_oop = 167 constantPoolOopDesc::klass_ref_at_if_loaded_check(pool, index, CHECK); 168 result = KlassHandle(THREAD, result_oop); 169 } 170 171 172 //------------------------------------------------------------------------------------------------------------------------ 173 // Method resolution 174 // 175 // According to JVM spec. $5.4.3c & $5.4.3d 176 177 void LinkResolver::lookup_method_in_klasses(methodHandle& result, KlassHandle klass, Symbol* name, Symbol* signature, TRAPS) { 178 methodOop result_oop = klass->uncached_lookup_method(name, signature); 179 if (EnableInvokeDynamic && result_oop != NULL) { 180 switch (result_oop->intrinsic_id()) { 181 case vmIntrinsics::_invokeExact: 182 case vmIntrinsics::_invokeGeneric: 183 case vmIntrinsics::_invokeDynamic: 184 // Do not link directly to these. The VM must produce a synthetic one using lookup_implicit_method. 185 return; 186 } 187 } 188 result = methodHandle(THREAD, result_oop); 189 } 190 191 // returns first instance method 192 void LinkResolver::lookup_instance_method_in_klasses(methodHandle& result, KlassHandle klass, Symbol* name, Symbol* signature, TRAPS) { 193 methodOop result_oop = klass->uncached_lookup_method(name, signature); 194 result = methodHandle(THREAD, result_oop); 195 while (!result.is_null() && result->is_static()) { 196 klass = KlassHandle(THREAD, Klass::cast(result->method_holder())->super()); 197 result = methodHandle(THREAD, klass->uncached_lookup_method(name, signature)); 198 } 199 } 200 201 202 int LinkResolver::vtable_index_of_miranda_method(KlassHandle klass, Symbol* name, Symbol* signature, TRAPS) { 203 ResourceMark rm(THREAD); 204 klassVtable *vt = instanceKlass::cast(klass())->vtable(); 205 return vt->index_of_miranda(name, signature); 206 } 207 208 void LinkResolver::lookup_method_in_interfaces(methodHandle& result, KlassHandle klass, Symbol* name, Symbol* signature, TRAPS) { 209 instanceKlass *ik = instanceKlass::cast(klass()); 210 result = methodHandle(THREAD, ik->lookup_method_in_all_interfaces(name, signature)); 211 } 212 213 void LinkResolver::lookup_implicit_method(methodHandle& result, 214 KlassHandle klass, Symbol* name, Symbol* signature, 215 KlassHandle current_klass, 216 TRAPS) { 217 if (EnableInvokeDynamic && 218 klass() == SystemDictionary::MethodHandle_klass() && 219 methodOopDesc::is_method_handle_invoke_name(name)) { 220 if (!THREAD->is_Compiler_thread() && !MethodHandles::enabled()) { 221 // Make sure the Java part of the runtime has been booted up. 222 klassOop natives = SystemDictionary::MethodHandleNatives_klass(); 223 if (natives == NULL || instanceKlass::cast(natives)->is_not_initialized()) { 224 SystemDictionary::resolve_or_fail(vmSymbols::java_lang_invoke_MethodHandleNatives(), 225 Handle(), 226 Handle(), 227 true, 228 CHECK); 229 } 230 } 231 methodOop result_oop = SystemDictionary::find_method_handle_invoke(name, 232 signature, 233 current_klass, 234 CHECK); 235 if (result_oop != NULL) { 236 assert(result_oop->is_method_handle_invoke() && result_oop->signature() == signature, "consistent"); 237 result = methodHandle(THREAD, result_oop); 238 } 239 } 240 } 241 242 void LinkResolver::check_method_accessability(KlassHandle ref_klass, 243 KlassHandle resolved_klass, 244 KlassHandle sel_klass, 245 methodHandle sel_method, 246 TRAPS) { 247 248 AccessFlags flags = sel_method->access_flags(); 249 250 // Special case: arrays always override "clone". JVMS 2.15. 251 // If the resolved klass is an array class, and the declaring class 252 // is java.lang.Object and the method is "clone", set the flags 253 // to public. 254 // 255 // We'll check for the method name first, as that's most likely 256 // to be false (so we'll short-circuit out of these tests). 257 if (sel_method->name() == vmSymbols::clone_name() && 258 sel_klass() == SystemDictionary::Object_klass() && 259 resolved_klass->oop_is_array()) { 260 // We need to change "protected" to "public". 261 assert(flags.is_protected(), "clone not protected?"); 262 jint new_flags = flags.as_int(); 263 new_flags = new_flags & (~JVM_ACC_PROTECTED); 264 new_flags = new_flags | JVM_ACC_PUBLIC; 265 flags.set_flags(new_flags); 266 } 267 268 if (!Reflection::verify_field_access(ref_klass->as_klassOop(), 269 resolved_klass->as_klassOop(), 270 sel_klass->as_klassOop(), 271 flags, 272 true)) { 273 ResourceMark rm(THREAD); 274 Exceptions::fthrow( 275 THREAD_AND_LOCATION, 276 vmSymbols::java_lang_IllegalAccessError(), 277 "tried to access method %s.%s%s from class %s", 278 sel_klass->external_name(), 279 sel_method->name()->as_C_string(), 280 sel_method->signature()->as_C_string(), 281 ref_klass->external_name() 282 ); 283 return; 284 } 285 } 286 287 void LinkResolver::resolve_method(methodHandle& resolved_method, KlassHandle& resolved_klass, 288 constantPoolHandle pool, int index, TRAPS) { 289 290 // resolve klass 291 resolve_klass(resolved_klass, pool, index, CHECK); 292 293 Symbol* method_name = pool->name_ref_at(index); 294 Symbol* method_signature = pool->signature_ref_at(index); 295 KlassHandle current_klass(THREAD, pool->pool_holder()); 296 297 if (pool->has_preresolution() 298 || (resolved_klass() == SystemDictionary::MethodHandle_klass() && 299 methodOopDesc::is_method_handle_invoke_name(method_name))) { 300 methodOop result_oop = constantPoolOopDesc::method_at_if_loaded(pool, index); 301 if (result_oop != NULL) { 302 resolved_method = methodHandle(THREAD, result_oop); 303 return; 304 } 305 } 306 307 resolve_method(resolved_method, resolved_klass, method_name, method_signature, current_klass, true, CHECK); 308 } 309 310 void LinkResolver::resolve_dynamic_method(methodHandle& resolved_method, KlassHandle& resolved_klass, constantPoolHandle pool, int index, TRAPS) { 311 // The class is java.lang.invoke.MethodHandle 312 resolved_klass = SystemDictionaryHandles::MethodHandle_klass(); 313 314 Symbol* method_name = vmSymbols::invokeExact_name(); 315 316 Symbol* method_signature = pool->signature_ref_at(index); 317 KlassHandle current_klass (THREAD, pool->pool_holder()); 318 319 resolve_method(resolved_method, resolved_klass, method_name, method_signature, current_klass, true, CHECK); 320 } 321 322 void LinkResolver::resolve_interface_method(methodHandle& resolved_method, KlassHandle& resolved_klass, constantPoolHandle pool, int index, TRAPS) { 323 324 // resolve klass 325 resolve_klass(resolved_klass, pool, index, CHECK); 326 Symbol* method_name = pool->name_ref_at(index); 327 Symbol* method_signature = pool->signature_ref_at(index); 328 KlassHandle current_klass(THREAD, pool->pool_holder()); 329 330 resolve_interface_method(resolved_method, resolved_klass, method_name, method_signature, current_klass, true, CHECK); 331 } 332 333 334 void LinkResolver::resolve_method(methodHandle& resolved_method, KlassHandle resolved_klass, 335 Symbol* method_name, Symbol* method_signature, 336 KlassHandle current_klass, bool check_access, TRAPS) { 337 338 // 1. check if klass is not interface 339 if (resolved_klass->is_interface()) { 340 ResourceMark rm(THREAD); 341 char buf[200]; 342 jio_snprintf(buf, sizeof(buf), "Found interface %s, but class was expected", Klass::cast(resolved_klass())->external_name()); 343 THROW_MSG(vmSymbols::java_lang_IncompatibleClassChangeError(), buf); 344 } 345 346 // 2. lookup method in resolved klass and its super klasses 347 lookup_method_in_klasses(resolved_method, resolved_klass, method_name, method_signature, CHECK); 348 349 if (resolved_method.is_null()) { // not found in the class hierarchy 350 // 3. lookup method in all the interfaces implemented by the resolved klass 351 lookup_method_in_interfaces(resolved_method, resolved_klass, method_name, method_signature, CHECK); 352 353 if (resolved_method.is_null()) { 354 // JSR 292: see if this is an implicitly generated method MethodHandle.invoke(*...) 355 lookup_implicit_method(resolved_method, resolved_klass, method_name, method_signature, current_klass, CHECK); 356 } 357 358 if (resolved_method.is_null()) { 359 // 4. method lookup failed 360 ResourceMark rm(THREAD); 361 THROW_MSG(vmSymbols::java_lang_NoSuchMethodError(), 362 methodOopDesc::name_and_sig_as_C_string(Klass::cast(resolved_klass()), 363 method_name, 364 method_signature)); 365 } 366 } 367 368 // 5. check if method is concrete 369 if (resolved_method->is_abstract() && !resolved_klass->is_abstract()) { 370 ResourceMark rm(THREAD); 371 THROW_MSG(vmSymbols::java_lang_AbstractMethodError(), 372 methodOopDesc::name_and_sig_as_C_string(Klass::cast(resolved_klass()), 373 method_name, 374 method_signature)); 375 } 376 377 // 6. access checks, access checking may be turned off when calling from within the VM. 378 if (check_access) { 379 assert(current_klass.not_null() , "current_klass should not be null"); 380 381 // check if method can be accessed by the referring class 382 check_method_accessability(current_klass, 383 resolved_klass, 384 KlassHandle(THREAD, resolved_method->method_holder()), 385 resolved_method, 386 CHECK); 387 388 // check loader constraints 389 Handle loader (THREAD, instanceKlass::cast(current_klass())->class_loader()); 390 Handle class_loader (THREAD, instanceKlass::cast(resolved_method->method_holder())->class_loader()); 391 { 392 ResourceMark rm(THREAD); 393 char* failed_type_name = 394 SystemDictionary::check_signature_loaders(method_signature, loader, 395 class_loader, true, CHECK); 396 if (failed_type_name != NULL) { 397 const char* msg = "loader constraint violation: when resolving method" 398 " \"%s\" the class loader (instance of %s) of the current class, %s," 399 " and the class loader (instance of %s) for resolved class, %s, have" 400 " different Class objects for the type %s used in the signature"; 401 char* sig = methodOopDesc::name_and_sig_as_C_string(Klass::cast(resolved_klass()),method_name,method_signature); 402 const char* loader1 = SystemDictionary::loader_name(loader()); 403 char* current = instanceKlass::cast(current_klass())->name()->as_C_string(); 404 const char* loader2 = SystemDictionary::loader_name(class_loader()); 405 char* resolved = instanceKlass::cast(resolved_klass())->name()->as_C_string(); 406 size_t buflen = strlen(msg) + strlen(sig) + strlen(loader1) + 407 strlen(current) + strlen(loader2) + strlen(resolved) + 408 strlen(failed_type_name); 409 char* buf = NEW_RESOURCE_ARRAY_IN_THREAD(THREAD, char, buflen); 410 jio_snprintf(buf, buflen, msg, sig, loader1, current, loader2, 411 resolved, failed_type_name); 412 THROW_MSG(vmSymbols::java_lang_LinkageError(), buf); 413 } 414 } 415 } 416 } 417 418 void LinkResolver::resolve_interface_method(methodHandle& resolved_method, 419 KlassHandle resolved_klass, 420 Symbol* method_name, 421 Symbol* method_signature, 422 KlassHandle current_klass, 423 bool check_access, TRAPS) { 424 425 // check if klass is interface 426 if (!resolved_klass->is_interface()) { 427 ResourceMark rm(THREAD); 428 char buf[200]; 429 jio_snprintf(buf, sizeof(buf), "Found class %s, but interface was expected", Klass::cast(resolved_klass())->external_name()); 430 THROW_MSG(vmSymbols::java_lang_IncompatibleClassChangeError(), buf); 431 } 432 433 // lookup method in this interface or its super, java.lang.Object 434 lookup_instance_method_in_klasses(resolved_method, resolved_klass, method_name, method_signature, CHECK); 435 436 if (resolved_method.is_null()) { 437 // lookup method in all the super-interfaces 438 lookup_method_in_interfaces(resolved_method, resolved_klass, method_name, method_signature, CHECK); 439 if (resolved_method.is_null()) { 440 // no method found 441 ResourceMark rm(THREAD); 442 THROW_MSG(vmSymbols::java_lang_NoSuchMethodError(), 443 methodOopDesc::name_and_sig_as_C_string(Klass::cast(resolved_klass()), 444 method_name, 445 method_signature)); 446 } 447 } 448 449 if (check_access) { 450 HandleMark hm(THREAD); 451 Handle loader (THREAD, instanceKlass::cast(current_klass())->class_loader()); 452 Handle class_loader (THREAD, instanceKlass::cast(resolved_method->method_holder())->class_loader()); 453 { 454 ResourceMark rm(THREAD); 455 char* failed_type_name = 456 SystemDictionary::check_signature_loaders(method_signature, loader, 457 class_loader, true, CHECK); 458 if (failed_type_name != NULL) { 459 const char* msg = "loader constraint violation: when resolving " 460 "interface method \"%s\" the class loader (instance of %s) of the " 461 "current class, %s, and the class loader (instance of %s) for " 462 "resolved class, %s, have different Class objects for the type %s " 463 "used in the signature"; 464 char* sig = methodOopDesc::name_and_sig_as_C_string(Klass::cast(resolved_klass()),method_name,method_signature); 465 const char* loader1 = SystemDictionary::loader_name(loader()); 466 char* current = instanceKlass::cast(current_klass())->name()->as_C_string(); 467 const char* loader2 = SystemDictionary::loader_name(class_loader()); 468 char* resolved = instanceKlass::cast(resolved_klass())->name()->as_C_string(); 469 size_t buflen = strlen(msg) + strlen(sig) + strlen(loader1) + 470 strlen(current) + strlen(loader2) + strlen(resolved) + 471 strlen(failed_type_name); 472 char* buf = NEW_RESOURCE_ARRAY_IN_THREAD(THREAD, char, buflen); 473 jio_snprintf(buf, buflen, msg, sig, loader1, current, loader2, 474 resolved, failed_type_name); 475 THROW_MSG(vmSymbols::java_lang_LinkageError(), buf); 476 } 477 } 478 } 479 } 480 481 //------------------------------------------------------------------------------------------------------------------------ 482 // Field resolution 483 484 void LinkResolver::check_field_accessability(KlassHandle ref_klass, 485 KlassHandle resolved_klass, 486 KlassHandle sel_klass, 487 fieldDescriptor& fd, 488 TRAPS) { 489 if (!Reflection::verify_field_access(ref_klass->as_klassOop(), 490 resolved_klass->as_klassOop(), 491 sel_klass->as_klassOop(), 492 fd.access_flags(), 493 true)) { 494 ResourceMark rm(THREAD); 495 Exceptions::fthrow( 496 THREAD_AND_LOCATION, 497 vmSymbols::java_lang_IllegalAccessError(), 498 "tried to access field %s.%s from class %s", 499 sel_klass->external_name(), 500 fd.name()->as_C_string(), 501 ref_klass->external_name() 502 ); 503 return; 504 } 505 } 506 507 void LinkResolver::resolve_field(FieldAccessInfo& result, constantPoolHandle pool, int index, Bytecodes::Code byte, bool check_only, TRAPS) { 508 resolve_field(result, pool, index, byte, check_only, true, CHECK); 509 } 510 511 void LinkResolver::resolve_field(FieldAccessInfo& result, constantPoolHandle pool, int index, Bytecodes::Code byte, bool check_only, bool update_pool, TRAPS) { 512 assert(byte == Bytecodes::_getstatic || byte == Bytecodes::_putstatic || 513 byte == Bytecodes::_getfield || byte == Bytecodes::_putfield, "bad bytecode"); 514 515 bool is_static = (byte == Bytecodes::_getstatic || byte == Bytecodes::_putstatic); 516 bool is_put = (byte == Bytecodes::_putfield || byte == Bytecodes::_putstatic); 517 518 // resolve specified klass 519 KlassHandle resolved_klass; 520 if (update_pool) { 521 resolve_klass(resolved_klass, pool, index, CHECK); 522 } else { 523 resolve_klass_no_update(resolved_klass, pool, index, CHECK); 524 } 525 // Load these early in case the resolve of the containing klass fails 526 Symbol* field = pool->name_ref_at(index); 527 Symbol* sig = pool->signature_ref_at(index); 528 // Check if there's a resolved klass containing the field 529 if( resolved_klass.is_null() ) { 530 ResourceMark rm(THREAD); 531 THROW_MSG(vmSymbols::java_lang_NoSuchFieldError(), field->as_C_string()); 532 } 533 534 // Resolve instance field 535 fieldDescriptor fd; // find_field initializes fd if found 536 KlassHandle sel_klass(THREAD, instanceKlass::cast(resolved_klass())->find_field(field, sig, &fd)); 537 // check if field exists; i.e., if a klass containing the field def has been selected 538 if (sel_klass.is_null()){ 539 ResourceMark rm(THREAD); 540 THROW_MSG(vmSymbols::java_lang_NoSuchFieldError(), field->as_C_string()); 541 } 542 543 // check access 544 KlassHandle ref_klass(THREAD, pool->pool_holder()); 545 check_field_accessability(ref_klass, resolved_klass, sel_klass, fd, CHECK); 546 547 // check for errors 548 if (is_static != fd.is_static()) { 549 ResourceMark rm(THREAD); 550 char msg[200]; 551 jio_snprintf(msg, sizeof(msg), "Expected %s field %s.%s", is_static ? "static" : "non-static", Klass::cast(resolved_klass())->external_name(), fd.name()->as_C_string()); 552 THROW_MSG(vmSymbols::java_lang_IncompatibleClassChangeError(), msg); 553 } 554 555 // Final fields can only be accessed from its own class. 556 if (is_put && fd.access_flags().is_final() && sel_klass() != pool->pool_holder()) { 557 THROW(vmSymbols::java_lang_IllegalAccessError()); 558 } 559 560 // initialize resolved_klass if necessary 561 // note 1: the klass which declared the field must be initialized (i.e, sel_klass) 562 // according to the newest JVM spec (5.5, p.170) - was bug (gri 7/28/99) 563 // 564 // note 2: we don't want to force initialization if we are just checking 565 // if the field access is legal; e.g., during compilation 566 if (is_static && !check_only) { 567 sel_klass->initialize(CHECK); 568 } 569 570 { 571 HandleMark hm(THREAD); 572 Handle ref_loader (THREAD, instanceKlass::cast(ref_klass())->class_loader()); 573 Handle sel_loader (THREAD, instanceKlass::cast(sel_klass())->class_loader()); 574 Symbol* signature_ref = pool->signature_ref_at(index); 575 { 576 ResourceMark rm(THREAD); 577 char* failed_type_name = 578 SystemDictionary::check_signature_loaders(signature_ref, 579 ref_loader, sel_loader, 580 false, 581 CHECK); 582 if (failed_type_name != NULL) { 583 const char* msg = "loader constraint violation: when resolving field" 584 " \"%s\" the class loader (instance of %s) of the referring class, " 585 "%s, and the class loader (instance of %s) for the field's resolved " 586 "type, %s, have different Class objects for that type"; 587 char* field_name = field->as_C_string(); 588 const char* loader1 = SystemDictionary::loader_name(ref_loader()); 589 char* sel = instanceKlass::cast(sel_klass())->name()->as_C_string(); 590 const char* loader2 = SystemDictionary::loader_name(sel_loader()); 591 size_t buflen = strlen(msg) + strlen(field_name) + strlen(loader1) + 592 strlen(sel) + strlen(loader2) + strlen(failed_type_name); 593 char* buf = NEW_RESOURCE_ARRAY_IN_THREAD(THREAD, char, buflen); 594 jio_snprintf(buf, buflen, msg, field_name, loader1, sel, loader2, 595 failed_type_name); 596 THROW_MSG(vmSymbols::java_lang_LinkageError(), buf); 597 } 598 } 599 } 600 601 // return information. note that the klass is set to the actual klass containing the 602 // field, otherwise access of static fields in superclasses will not work. 603 KlassHandle holder (THREAD, fd.field_holder()); 604 Symbol* name = fd.name(); 605 result.set(holder, name, fd.index(), fd.offset(), fd.field_type(), fd.access_flags()); 606 } 607 608 609 //------------------------------------------------------------------------------------------------------------------------ 610 // Invoke resolution 611 // 612 // Naming conventions: 613 // 614 // resolved_method the specified method (i.e., static receiver specified via constant pool index) 615 // sel_method the selected method (selected via run-time lookup; e.g., based on dynamic receiver class) 616 // resolved_klass the specified klass (i.e., specified via constant pool index) 617 // recv_klass the receiver klass 618 619 620 void LinkResolver::resolve_static_call(CallInfo& result, KlassHandle& resolved_klass, Symbol* method_name, 621 Symbol* method_signature, KlassHandle current_klass, 622 bool check_access, bool initialize_class, TRAPS) { 623 methodHandle resolved_method; 624 linktime_resolve_static_method(resolved_method, resolved_klass, method_name, method_signature, current_klass, check_access, CHECK); 625 resolved_klass = KlassHandle(THREAD, Klass::cast(resolved_method->method_holder())); 626 627 // Initialize klass (this should only happen if everything is ok) 628 if (initialize_class && resolved_klass->should_be_initialized()) { 629 resolved_klass->initialize(CHECK); 630 linktime_resolve_static_method(resolved_method, resolved_klass, method_name, method_signature, current_klass, check_access, CHECK); 631 } 632 633 // setup result 634 result.set_static(resolved_klass, resolved_method, CHECK); 635 } 636 637 // throws linktime exceptions 638 void LinkResolver::linktime_resolve_static_method(methodHandle& resolved_method, KlassHandle resolved_klass, 639 Symbol* method_name, Symbol* method_signature, 640 KlassHandle current_klass, bool check_access, TRAPS) { 641 642 resolve_method(resolved_method, resolved_klass, method_name, method_signature, current_klass, check_access, CHECK); 643 assert(resolved_method->name() != vmSymbols::class_initializer_name(), "should have been checked in verifier"); 644 645 // check if static 646 if (!resolved_method->is_static()) { 647 ResourceMark rm(THREAD); 648 char buf[200]; 649 jio_snprintf(buf, sizeof(buf), "Expected static method %s", methodOopDesc::name_and_sig_as_C_string(Klass::cast(resolved_klass()), 650 resolved_method->name(), 651 resolved_method->signature())); 652 THROW_MSG(vmSymbols::java_lang_IncompatibleClassChangeError(), buf); 653 } 654 } 655 656 657 void LinkResolver::resolve_special_call(CallInfo& result, KlassHandle resolved_klass, Symbol* method_name, 658 Symbol* method_signature, KlassHandle current_klass, bool check_access, TRAPS) { 659 methodHandle resolved_method; 660 linktime_resolve_special_method(resolved_method, resolved_klass, method_name, method_signature, current_klass, check_access, CHECK); 661 runtime_resolve_special_method(result, resolved_method, resolved_klass, current_klass, check_access, CHECK); 662 } 663 664 // throws linktime exceptions 665 void LinkResolver::linktime_resolve_special_method(methodHandle& resolved_method, KlassHandle resolved_klass, 666 Symbol* method_name, Symbol* method_signature, 667 KlassHandle current_klass, bool check_access, TRAPS) { 668 669 resolve_method(resolved_method, resolved_klass, method_name, method_signature, current_klass, check_access, CHECK); 670 671 // check if method name is <init>, that it is found in same klass as static type 672 if (resolved_method->name() == vmSymbols::object_initializer_name() && 673 resolved_method->method_holder() != resolved_klass()) { 674 ResourceMark rm(THREAD); 675 Exceptions::fthrow( 676 THREAD_AND_LOCATION, 677 vmSymbols::java_lang_NoSuchMethodError(), 678 "%s: method %s%s not found", 679 resolved_klass->external_name(), 680 resolved_method->name()->as_C_string(), 681 resolved_method->signature()->as_C_string() 682 ); 683 return; 684 } 685 686 // check if not static 687 if (resolved_method->is_static()) { 688 ResourceMark rm(THREAD); 689 char buf[200]; 690 jio_snprintf(buf, sizeof(buf), 691 "Expecting non-static method %s", 692 methodOopDesc::name_and_sig_as_C_string(Klass::cast(resolved_klass()), 693 resolved_method->name(), 694 resolved_method->signature())); 695 THROW_MSG(vmSymbols::java_lang_IncompatibleClassChangeError(), buf); 696 } 697 } 698 699 // throws runtime exceptions 700 void LinkResolver::runtime_resolve_special_method(CallInfo& result, methodHandle resolved_method, KlassHandle resolved_klass, 701 KlassHandle current_klass, bool check_access, TRAPS) { 702 703 // resolved method is selected method unless we have an old-style lookup 704 methodHandle sel_method(THREAD, resolved_method()); 705 706 // check if this is an old-style super call and do a new lookup if so 707 { KlassHandle method_klass = KlassHandle(THREAD, 708 resolved_method->method_holder()); 709 710 if (check_access && 711 // a) check if ACC_SUPER flag is set for the current class 712 current_klass->is_super() && 713 // b) check if the method class is a superclass of the current class (superclass relation is not reflexive!) 714 current_klass->is_subtype_of(method_klass()) && current_klass() != method_klass() && 715 // c) check if the method is not <init> 716 resolved_method->name() != vmSymbols::object_initializer_name()) { 717 // Lookup super method 718 KlassHandle super_klass(THREAD, current_klass->super()); 719 lookup_instance_method_in_klasses(sel_method, super_klass, 720 resolved_method->name(), 721 resolved_method->signature(), CHECK); 722 // check if found 723 if (sel_method.is_null()) { 724 ResourceMark rm(THREAD); 725 THROW_MSG(vmSymbols::java_lang_AbstractMethodError(), 726 methodOopDesc::name_and_sig_as_C_string(Klass::cast(resolved_klass()), 727 resolved_method->name(), 728 resolved_method->signature())); 729 } 730 } 731 } 732 733 // check if not static 734 if (sel_method->is_static()) { 735 ResourceMark rm(THREAD); 736 char buf[200]; 737 jio_snprintf(buf, sizeof(buf), "Expecting non-static method %s", methodOopDesc::name_and_sig_as_C_string(Klass::cast(resolved_klass()), 738 resolved_method->name(), 739 resolved_method->signature())); 740 THROW_MSG(vmSymbols::java_lang_IncompatibleClassChangeError(), buf); 741 } 742 743 // check if abstract 744 if (sel_method->is_abstract()) { 745 ResourceMark rm(THREAD); 746 THROW_MSG(vmSymbols::java_lang_AbstractMethodError(), 747 methodOopDesc::name_and_sig_as_C_string(Klass::cast(resolved_klass()), 748 sel_method->name(), 749 sel_method->signature())); 750 } 751 752 // setup result 753 result.set_static(resolved_klass, sel_method, CHECK); 754 } 755 756 void LinkResolver::resolve_virtual_call(CallInfo& result, Handle recv, KlassHandle receiver_klass, KlassHandle resolved_klass, 757 Symbol* method_name, Symbol* method_signature, KlassHandle current_klass, 758 bool check_access, bool check_null_and_abstract, TRAPS) { 759 methodHandle resolved_method; 760 linktime_resolve_virtual_method(resolved_method, resolved_klass, method_name, method_signature, current_klass, check_access, CHECK); 761 runtime_resolve_virtual_method(result, resolved_method, resolved_klass, recv, receiver_klass, check_null_and_abstract, CHECK); 762 } 763 764 // throws linktime exceptions 765 void LinkResolver::linktime_resolve_virtual_method(methodHandle &resolved_method, KlassHandle resolved_klass, 766 Symbol* method_name, Symbol* method_signature, 767 KlassHandle current_klass, bool check_access, TRAPS) { 768 // normal method resolution 769 resolve_method(resolved_method, resolved_klass, method_name, method_signature, current_klass, check_access, CHECK); 770 771 assert(resolved_method->name() != vmSymbols::object_initializer_name(), "should have been checked in verifier"); 772 assert(resolved_method->name() != vmSymbols::class_initializer_name (), "should have been checked in verifier"); 773 774 // check if not static 775 if (resolved_method->is_static()) { 776 ResourceMark rm(THREAD); 777 char buf[200]; 778 jio_snprintf(buf, sizeof(buf), "Expecting non-static method %s", methodOopDesc::name_and_sig_as_C_string(Klass::cast(resolved_klass()), 779 resolved_method->name(), 780 resolved_method->signature())); 781 THROW_MSG(vmSymbols::java_lang_IncompatibleClassChangeError(), buf); 782 } 783 } 784 785 // throws runtime exceptions 786 void LinkResolver::runtime_resolve_virtual_method(CallInfo& result, 787 methodHandle resolved_method, 788 KlassHandle resolved_klass, 789 Handle recv, 790 KlassHandle recv_klass, 791 bool check_null_and_abstract, 792 TRAPS) { 793 794 // setup default return values 795 int vtable_index = methodOopDesc::invalid_vtable_index; 796 methodHandle selected_method; 797 798 assert(recv.is_null() || recv->is_oop(), "receiver is not an oop"); 799 800 // runtime method resolution 801 if (check_null_and_abstract && recv.is_null()) { // check if receiver exists 802 THROW(vmSymbols::java_lang_NullPointerException()); 803 } 804 805 // Virtual methods cannot be resolved before its klass has been linked, for otherwise the methodOop's 806 // has not been rewritten, and the vtable initialized. 807 assert(instanceKlass::cast(resolved_method->method_holder())->is_linked(), "must be linked"); 808 809 // Virtual methods cannot be resolved before its klass has been linked, for otherwise the methodOop's 810 // has not been rewritten, and the vtable initialized. Make sure to do this after the nullcheck, since 811 // a missing receiver might result in a bogus lookup. 812 assert(instanceKlass::cast(resolved_method->method_holder())->is_linked(), "must be linked"); 813 814 // do lookup based on receiver klass using the vtable index 815 if (resolved_method->method_holder()->klass_part()->is_interface()) { // miranda method 816 vtable_index = vtable_index_of_miranda_method(resolved_klass, 817 resolved_method->name(), 818 resolved_method->signature(), CHECK); 819 assert(vtable_index >= 0 , "we should have valid vtable index at this point"); 820 821 instanceKlass* inst = instanceKlass::cast(recv_klass()); 822 selected_method = methodHandle(THREAD, inst->method_at_vtable(vtable_index)); 823 } else { 824 // at this point we are sure that resolved_method is virtual and not 825 // a miranda method; therefore, it must have a valid vtable index. 826 vtable_index = resolved_method->vtable_index(); 827 // We could get a negative vtable_index for final methods, 828 // because as an optimization they are they are never put in the vtable, 829 // unless they override an existing method. 830 // If we do get a negative, it means the resolved method is the the selected 831 // method, and it can never be changed by an override. 832 if (vtable_index == methodOopDesc::nonvirtual_vtable_index) { 833 assert(resolved_method->can_be_statically_bound(), "cannot override this method"); 834 selected_method = resolved_method; 835 } else { 836 // recv_klass might be an arrayKlassOop but all vtables start at 837 // the same place. The cast is to avoid virtual call and assertion. 838 instanceKlass* inst = (instanceKlass*)recv_klass()->klass_part(); 839 selected_method = methodHandle(THREAD, inst->method_at_vtable(vtable_index)); 840 } 841 } 842 843 // check if method exists 844 if (selected_method.is_null()) { 845 ResourceMark rm(THREAD); 846 THROW_MSG(vmSymbols::java_lang_AbstractMethodError(), 847 methodOopDesc::name_and_sig_as_C_string(Klass::cast(resolved_klass()), 848 resolved_method->name(), 849 resolved_method->signature())); 850 } 851 852 // check if abstract 853 if (check_null_and_abstract && selected_method->is_abstract()) { 854 ResourceMark rm(THREAD); 855 THROW_MSG(vmSymbols::java_lang_AbstractMethodError(), 856 methodOopDesc::name_and_sig_as_C_string(Klass::cast(resolved_klass()), 857 selected_method->name(), 858 selected_method->signature())); 859 } 860 861 // setup result 862 result.set_virtual(resolved_klass, recv_klass, resolved_method, selected_method, vtable_index, CHECK); 863 } 864 865 void LinkResolver::resolve_interface_call(CallInfo& result, Handle recv, KlassHandle recv_klass, KlassHandle resolved_klass, 866 Symbol* method_name, Symbol* method_signature, KlassHandle current_klass, 867 bool check_access, bool check_null_and_abstract, TRAPS) { 868 methodHandle resolved_method; 869 linktime_resolve_interface_method(resolved_method, resolved_klass, method_name, method_signature, current_klass, check_access, CHECK); 870 runtime_resolve_interface_method(result, resolved_method, resolved_klass, recv, recv_klass, check_null_and_abstract, CHECK); 871 } 872 873 // throws linktime exceptions 874 void LinkResolver::linktime_resolve_interface_method(methodHandle& resolved_method, KlassHandle resolved_klass, Symbol* method_name, 875 Symbol* method_signature, KlassHandle current_klass, bool check_access, TRAPS) { 876 // normal interface method resolution 877 resolve_interface_method(resolved_method, resolved_klass, method_name, method_signature, current_klass, check_access, CHECK); 878 879 assert(resolved_method->name() != vmSymbols::object_initializer_name(), "should have been checked in verifier"); 880 assert(resolved_method->name() != vmSymbols::class_initializer_name (), "should have been checked in verifier"); 881 } 882 883 // throws runtime exceptions 884 void LinkResolver::runtime_resolve_interface_method(CallInfo& result, methodHandle resolved_method, KlassHandle resolved_klass, 885 Handle recv, KlassHandle recv_klass, bool check_null_and_abstract, TRAPS) { 886 // check if receiver exists 887 if (check_null_and_abstract && recv.is_null()) { 888 THROW(vmSymbols::java_lang_NullPointerException()); 889 } 890 891 // check if receiver klass implements the resolved interface 892 if (!recv_klass->is_subtype_of(resolved_klass())) { 893 ResourceMark rm(THREAD); 894 char buf[200]; 895 jio_snprintf(buf, sizeof(buf), "Class %s does not implement the requested interface %s", 896 (Klass::cast(recv_klass()))->external_name(), 897 (Klass::cast(resolved_klass()))->external_name()); 898 THROW_MSG(vmSymbols::java_lang_IncompatibleClassChangeError(), buf); 899 } 900 // do lookup based on receiver klass 901 methodHandle sel_method; 902 lookup_instance_method_in_klasses(sel_method, recv_klass, 903 resolved_method->name(), 904 resolved_method->signature(), CHECK); 905 // check if method exists 906 if (sel_method.is_null()) { 907 ResourceMark rm(THREAD); 908 THROW_MSG(vmSymbols::java_lang_AbstractMethodError(), 909 methodOopDesc::name_and_sig_as_C_string(Klass::cast(recv_klass()), 910 resolved_method->name(), 911 resolved_method->signature())); 912 } 913 // check if public 914 if (!sel_method->is_public()) { 915 ResourceMark rm(THREAD); 916 THROW_MSG(vmSymbols::java_lang_IllegalAccessError(), 917 methodOopDesc::name_and_sig_as_C_string(Klass::cast(recv_klass()), 918 sel_method->name(), 919 sel_method->signature())); 920 } 921 // check if abstract 922 if (check_null_and_abstract && sel_method->is_abstract()) { 923 ResourceMark rm(THREAD); 924 THROW_MSG(vmSymbols::java_lang_AbstractMethodError(), 925 methodOopDesc::name_and_sig_as_C_string(Klass::cast(recv_klass()), 926 sel_method->name(), 927 sel_method->signature())); 928 } 929 // setup result 930 result.set_interface(resolved_klass, recv_klass, resolved_method, sel_method, CHECK); 931 } 932 933 934 methodHandle LinkResolver::linktime_resolve_interface_method_or_null( 935 KlassHandle resolved_klass, 936 Symbol* method_name, 937 Symbol* method_signature, 938 KlassHandle current_klass, 939 bool check_access) { 940 EXCEPTION_MARK; 941 methodHandle method_result; 942 linktime_resolve_interface_method(method_result, resolved_klass, method_name, method_signature, current_klass, check_access, THREAD); 943 if (HAS_PENDING_EXCEPTION) { 944 CLEAR_PENDING_EXCEPTION; 945 return methodHandle(); 946 } else { 947 return method_result; 948 } 949 } 950 951 methodHandle LinkResolver::linktime_resolve_virtual_method_or_null( 952 KlassHandle resolved_klass, 953 Symbol* method_name, 954 Symbol* method_signature, 955 KlassHandle current_klass, 956 bool check_access) { 957 EXCEPTION_MARK; 958 methodHandle method_result; 959 linktime_resolve_virtual_method(method_result, resolved_klass, method_name, method_signature, current_klass, check_access, THREAD); 960 if (HAS_PENDING_EXCEPTION) { 961 CLEAR_PENDING_EXCEPTION; 962 return methodHandle(); 963 } else { 964 return method_result; 965 } 966 } 967 968 methodHandle LinkResolver::resolve_virtual_call_or_null( 969 KlassHandle receiver_klass, 970 KlassHandle resolved_klass, 971 Symbol* name, 972 Symbol* signature, 973 KlassHandle current_klass) { 974 EXCEPTION_MARK; 975 CallInfo info; 976 resolve_virtual_call(info, Handle(), receiver_klass, resolved_klass, name, signature, current_klass, true, false, THREAD); 977 if (HAS_PENDING_EXCEPTION) { 978 CLEAR_PENDING_EXCEPTION; 979 return methodHandle(); 980 } 981 return info.selected_method(); 982 } 983 984 methodHandle LinkResolver::resolve_interface_call_or_null( 985 KlassHandle receiver_klass, 986 KlassHandle resolved_klass, 987 Symbol* name, 988 Symbol* signature, 989 KlassHandle current_klass) { 990 EXCEPTION_MARK; 991 CallInfo info; 992 resolve_interface_call(info, Handle(), receiver_klass, resolved_klass, name, signature, current_klass, true, false, THREAD); 993 if (HAS_PENDING_EXCEPTION) { 994 CLEAR_PENDING_EXCEPTION; 995 return methodHandle(); 996 } 997 return info.selected_method(); 998 } 999 1000 int LinkResolver::resolve_virtual_vtable_index( 1001 KlassHandle receiver_klass, 1002 KlassHandle resolved_klass, 1003 Symbol* name, 1004 Symbol* signature, 1005 KlassHandle current_klass) { 1006 EXCEPTION_MARK; 1007 CallInfo info; 1008 resolve_virtual_call(info, Handle(), receiver_klass, resolved_klass, name, signature, current_klass, true, false, THREAD); 1009 if (HAS_PENDING_EXCEPTION) { 1010 CLEAR_PENDING_EXCEPTION; 1011 return methodOopDesc::invalid_vtable_index; 1012 } 1013 return info.vtable_index(); 1014 } 1015 1016 methodHandle LinkResolver::resolve_static_call_or_null( 1017 KlassHandle resolved_klass, 1018 Symbol* name, 1019 Symbol* signature, 1020 KlassHandle current_klass) { 1021 EXCEPTION_MARK; 1022 CallInfo info; 1023 resolve_static_call(info, resolved_klass, name, signature, current_klass, true, false, THREAD); 1024 if (HAS_PENDING_EXCEPTION) { 1025 CLEAR_PENDING_EXCEPTION; 1026 return methodHandle(); 1027 } 1028 return info.selected_method(); 1029 } 1030 1031 methodHandle LinkResolver::resolve_special_call_or_null(KlassHandle resolved_klass, Symbol* name, Symbol* signature, 1032 KlassHandle current_klass) { 1033 EXCEPTION_MARK; 1034 CallInfo info; 1035 resolve_special_call(info, resolved_klass, name, signature, current_klass, true, THREAD); 1036 if (HAS_PENDING_EXCEPTION) { 1037 CLEAR_PENDING_EXCEPTION; 1038 return methodHandle(); 1039 } 1040 return info.selected_method(); 1041 } 1042 1043 1044 1045 //------------------------------------------------------------------------------------------------------------------------ 1046 // ConstantPool entries 1047 1048 void LinkResolver::resolve_invoke(CallInfo& result, Handle recv, constantPoolHandle pool, int index, Bytecodes::Code byte, TRAPS) { 1049 switch (byte) { 1050 case Bytecodes::_invokestatic : resolve_invokestatic (result, pool, index, CHECK); break; 1051 case Bytecodes::_invokespecial : resolve_invokespecial (result, pool, index, CHECK); break; 1052 case Bytecodes::_invokevirtual : resolve_invokevirtual (result, recv, pool, index, CHECK); break; 1053 case Bytecodes::_invokedynamic : resolve_invokedynamic (result, pool, index, CHECK); break; 1054 case Bytecodes::_invokeinterface: resolve_invokeinterface(result, recv, pool, index, CHECK); break; 1055 } 1056 return; 1057 } 1058 1059 void LinkResolver::resolve_pool(KlassHandle& resolved_klass, Symbol*& method_name, Symbol*& method_signature, 1060 KlassHandle& current_klass, constantPoolHandle pool, int index, TRAPS) { 1061 // resolve klass 1062 resolve_klass(resolved_klass, pool, index, CHECK); 1063 1064 // Get name, signature, and static klass 1065 method_name = pool->name_ref_at(index); 1066 method_signature = pool->signature_ref_at(index); 1067 current_klass = KlassHandle(THREAD, pool->pool_holder()); 1068 } 1069 1070 1071 void LinkResolver::resolve_invokestatic(CallInfo& result, constantPoolHandle pool, int index, TRAPS) { 1072 KlassHandle resolved_klass; 1073 Symbol* method_name = NULL; 1074 Symbol* method_signature = NULL; 1075 KlassHandle current_klass; 1076 resolve_pool(resolved_klass, method_name, method_signature, current_klass, pool, index, CHECK); 1077 resolve_static_call(result, resolved_klass, method_name, method_signature, current_klass, true, true, CHECK); 1078 } 1079 1080 1081 void LinkResolver::resolve_invokespecial(CallInfo& result, constantPoolHandle pool, int index, TRAPS) { 1082 KlassHandle resolved_klass; 1083 Symbol* method_name = NULL; 1084 Symbol* method_signature = NULL; 1085 KlassHandle current_klass; 1086 resolve_pool(resolved_klass, method_name, method_signature, current_klass, pool, index, CHECK); 1087 resolve_special_call(result, resolved_klass, method_name, method_signature, current_klass, true, CHECK); 1088 } 1089 1090 1091 void LinkResolver::resolve_invokevirtual(CallInfo& result, Handle recv, 1092 constantPoolHandle pool, int index, 1093 TRAPS) { 1094 1095 KlassHandle resolved_klass; 1096 Symbol* method_name = NULL; 1097 Symbol* method_signature = NULL; 1098 KlassHandle current_klass; 1099 resolve_pool(resolved_klass, method_name, method_signature, current_klass, pool, index, CHECK); 1100 KlassHandle recvrKlass (THREAD, recv.is_null() ? (klassOop)NULL : recv->klass()); 1101 resolve_virtual_call(result, recv, recvrKlass, resolved_klass, method_name, method_signature, current_klass, true, true, CHECK); 1102 } 1103 1104 1105 void LinkResolver::resolve_invokeinterface(CallInfo& result, Handle recv, constantPoolHandle pool, int index, TRAPS) { 1106 KlassHandle resolved_klass; 1107 Symbol* method_name = NULL; 1108 Symbol* method_signature = NULL; 1109 KlassHandle current_klass; 1110 resolve_pool(resolved_klass, method_name, method_signature, current_klass, pool, index, CHECK); 1111 KlassHandle recvrKlass (THREAD, recv.is_null() ? (klassOop)NULL : recv->klass()); 1112 resolve_interface_call(result, recv, recvrKlass, resolved_klass, method_name, method_signature, current_klass, true, true, CHECK); 1113 } 1114 1115 1116 void LinkResolver::resolve_invokedynamic(CallInfo& result, constantPoolHandle pool, int raw_index, TRAPS) { 1117 assert(EnableInvokeDynamic, ""); 1118 1119 // This guy is reached from InterpreterRuntime::resolve_invokedynamic. 1120 1121 // At this point, we only need the signature, and can ignore the name. 1122 Symbol* method_signature = pool->signature_ref_at(raw_index); // raw_index works directly 1123 Symbol* method_name = vmSymbols::invokeExact_name(); 1124 KlassHandle resolved_klass = SystemDictionaryHandles::MethodHandle_klass(); 1125 1126 // JSR 292: this must be an implicitly generated method MethodHandle.invokeExact(*...) 1127 // The extra MH receiver will be inserted into the stack on every call. 1128 methodHandle resolved_method; 1129 KlassHandle current_klass(THREAD, pool->pool_holder()); 1130 lookup_implicit_method(resolved_method, resolved_klass, method_name, method_signature, current_klass, THREAD); 1131 if (HAS_PENDING_EXCEPTION) { 1132 if (PENDING_EXCEPTION->is_a(SystemDictionary::BootstrapMethodError_klass())) { 1133 // throw these guys, since they are already wrapped 1134 return; 1135 } 1136 if (!PENDING_EXCEPTION->is_a(SystemDictionary::LinkageError_klass())) { 1137 // intercept only LinkageErrors which might have failed to wrap 1138 return; 1139 } 1140 // See the "Linking Exceptions" section for the invokedynamic instruction in the JVMS. 1141 Handle ex(THREAD, PENDING_EXCEPTION); 1142 CLEAR_PENDING_EXCEPTION; 1143 oop bsme = Klass::cast(SystemDictionary::BootstrapMethodError_klass())->java_mirror(); 1144 MethodHandles::raise_exception(Bytecodes::_athrow, ex(), bsme, CHECK); 1145 // java code should not return, but if it does throw out anyway 1146 THROW(vmSymbols::java_lang_InternalError()); 1147 } 1148 if (resolved_method.is_null()) { 1149 THROW(vmSymbols::java_lang_InternalError()); 1150 } 1151 result.set_dynamic(resolved_method, CHECK); 1152 } 1153 1154 //------------------------------------------------------------------------------------------------------------------------ 1155 #ifndef PRODUCT 1156 1157 void FieldAccessInfo::print() { 1158 ResourceMark rm; 1159 tty->print_cr("Field %s@%d", name()->as_C_string(), field_offset()); 1160 } 1161 1162 #endif