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 CompLevel_initial_compile, 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 (EnableMethodHandles && 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 (EnableMethodHandles && 218 klass() == SystemDictionary::MethodHandle_klass() && 219 methodOopDesc::is_method_handle_invoke_name(name)) { 220 if (!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 Symbol* natives_name = vmSymbols::java_dyn_MethodHandleNatives(); 225 if (natives != NULL && AllowTransitionalJSR292) natives_name = Klass::cast(natives)->name(); 226 SystemDictionary::resolve_or_fail(natives_name, 227 Handle(), 228 Handle(), 229 true, 230 CHECK); 231 } 232 } 233 methodOop result_oop = SystemDictionary::find_method_handle_invoke(name, 234 signature, 235 current_klass, 236 CHECK); 237 if (result_oop != NULL) { 238 assert(result_oop->is_method_handle_invoke() && result_oop->signature() == signature, "consistent"); 239 result = methodHandle(THREAD, result_oop); 240 } 241 } 242 } 243 244 void LinkResolver::check_method_accessability(KlassHandle ref_klass, 245 KlassHandle resolved_klass, 246 KlassHandle sel_klass, 247 methodHandle sel_method, 248 TRAPS) { 249 250 AccessFlags flags = sel_method->access_flags(); 251 252 // Special case: arrays always override "clone". JVMS 2.15. 253 // If the resolved klass is an array class, and the declaring class 254 // is java.lang.Object and the method is "clone", set the flags 255 // to public. 256 // 257 // We'll check for the method name first, as that's most likely 258 // to be false (so we'll short-circuit out of these tests). 259 if (sel_method->name() == vmSymbols::clone_name() && 260 sel_klass() == SystemDictionary::Object_klass() && 261 resolved_klass->oop_is_array()) { 262 // We need to change "protected" to "public". 263 assert(flags.is_protected(), "clone not protected?"); 264 jint new_flags = flags.as_int(); 265 new_flags = new_flags & (~JVM_ACC_PROTECTED); 266 new_flags = new_flags | JVM_ACC_PUBLIC; 267 flags.set_flags(new_flags); 268 } 269 270 if (!Reflection::verify_field_access(ref_klass->as_klassOop(), 271 resolved_klass->as_klassOop(), 272 sel_klass->as_klassOop(), 273 flags, 274 true)) { 275 ResourceMark rm(THREAD); 276 Exceptions::fthrow( 277 THREAD_AND_LOCATION, 278 vmSymbols::java_lang_IllegalAccessError(), 279 "tried to access method %s.%s%s from class %s", 280 sel_klass->external_name(), 281 sel_method->name()->as_C_string(), 282 sel_method->signature()->as_C_string(), 283 ref_klass->external_name() 284 ); 285 return; 286 } 287 } 288 289 void LinkResolver::resolve_method(methodHandle& resolved_method, KlassHandle& resolved_klass, 290 constantPoolHandle pool, int index, TRAPS) { 291 292 // resolve klass 293 resolve_klass(resolved_klass, pool, index, CHECK); 294 295 Symbol* method_name = pool->name_ref_at(index); 296 Symbol* method_signature = pool->signature_ref_at(index); 297 KlassHandle current_klass(THREAD, pool->pool_holder()); 298 299 resolve_method(resolved_method, resolved_klass, method_name, method_signature, current_klass, true, CHECK); 300 } 301 302 void LinkResolver::resolve_dynamic_method(methodHandle& resolved_method, KlassHandle& resolved_klass, constantPoolHandle pool, int index, TRAPS) { 303 // The class is java.dyn.MethodHandle 304 resolved_klass = SystemDictionaryHandles::MethodHandle_klass(); 305 306 Symbol* method_name = vmSymbols::invokeExact_name(); 307 308 Symbol* method_signature = pool->signature_ref_at(index); 309 KlassHandle current_klass (THREAD, pool->pool_holder()); 310 311 resolve_method(resolved_method, resolved_klass, method_name, method_signature, current_klass, true, CHECK); 312 } 313 314 void LinkResolver::resolve_interface_method(methodHandle& resolved_method, KlassHandle& resolved_klass, constantPoolHandle pool, int index, TRAPS) { 315 316 // resolve klass 317 resolve_klass(resolved_klass, pool, index, CHECK); 318 Symbol* method_name = pool->name_ref_at(index); 319 Symbol* method_signature = pool->signature_ref_at(index); 320 KlassHandle current_klass(THREAD, pool->pool_holder()); 321 322 resolve_interface_method(resolved_method, resolved_klass, method_name, method_signature, current_klass, true, CHECK); 323 } 324 325 326 void LinkResolver::resolve_method(methodHandle& resolved_method, KlassHandle resolved_klass, 327 Symbol* method_name, Symbol* method_signature, 328 KlassHandle current_klass, bool check_access, TRAPS) { 329 330 // 1. check if klass is not interface 331 if (resolved_klass->is_interface()) { 332 char buf[200]; 333 jio_snprintf(buf, sizeof(buf), "Found interface %s, but class was expected", Klass::cast(resolved_klass())->external_name()); 334 THROW_MSG(vmSymbols::java_lang_IncompatibleClassChangeError(), buf); 335 } 336 337 // 2. lookup method in resolved klass and its super klasses 338 lookup_method_in_klasses(resolved_method, resolved_klass, method_name, method_signature, CHECK); 339 340 if (resolved_method.is_null()) { // not found in the class hierarchy 341 // 3. lookup method in all the interfaces implemented by the resolved klass 342 lookup_method_in_interfaces(resolved_method, resolved_klass, method_name, method_signature, CHECK); 343 344 if (resolved_method.is_null()) { 345 // JSR 292: see if this is an implicitly generated method MethodHandle.invoke(*...) 346 lookup_implicit_method(resolved_method, resolved_klass, method_name, method_signature, current_klass, CHECK); 347 } 348 349 if (resolved_method.is_null()) { 350 // 4. method lookup failed 351 ResourceMark rm(THREAD); 352 THROW_MSG(vmSymbols::java_lang_NoSuchMethodError(), 353 methodOopDesc::name_and_sig_as_C_string(Klass::cast(resolved_klass()), 354 method_name, 355 method_signature)); 356 } 357 } 358 359 // 5. check if method is concrete 360 if (resolved_method->is_abstract() && !resolved_klass->is_abstract()) { 361 ResourceMark rm(THREAD); 362 THROW_MSG(vmSymbols::java_lang_AbstractMethodError(), 363 methodOopDesc::name_and_sig_as_C_string(Klass::cast(resolved_klass()), 364 method_name, 365 method_signature)); 366 } 367 368 // 6. access checks, access checking may be turned off when calling from within the VM. 369 if (check_access) { 370 assert(current_klass.not_null() , "current_klass should not be null"); 371 372 // check if method can be accessed by the referring class 373 check_method_accessability(current_klass, 374 resolved_klass, 375 KlassHandle(THREAD, resolved_method->method_holder()), 376 resolved_method, 377 CHECK); 378 379 // check loader constraints 380 Handle loader (THREAD, instanceKlass::cast(current_klass())->class_loader()); 381 Handle class_loader (THREAD, instanceKlass::cast(resolved_method->method_holder())->class_loader()); 382 { 383 ResourceMark rm(THREAD); 384 char* failed_type_name = 385 SystemDictionary::check_signature_loaders(method_signature, loader, 386 class_loader, true, CHECK); 387 if (failed_type_name != NULL) { 388 const char* msg = "loader constraint violation: when resolving method" 389 " \"%s\" the class loader (instance of %s) of the current class, %s," 390 " and the class loader (instance of %s) for resolved class, %s, have" 391 " different Class objects for the type %s used in the signature"; 392 char* sig = methodOopDesc::name_and_sig_as_C_string(Klass::cast(resolved_klass()),method_name,method_signature); 393 const char* loader1 = SystemDictionary::loader_name(loader()); 394 char* current = instanceKlass::cast(current_klass())->name()->as_C_string(); 395 const char* loader2 = SystemDictionary::loader_name(class_loader()); 396 char* resolved = instanceKlass::cast(resolved_klass())->name()->as_C_string(); 397 size_t buflen = strlen(msg) + strlen(sig) + strlen(loader1) + 398 strlen(current) + strlen(loader2) + strlen(resolved) + 399 strlen(failed_type_name); 400 char* buf = NEW_RESOURCE_ARRAY_IN_THREAD(THREAD, char, buflen); 401 jio_snprintf(buf, buflen, msg, sig, loader1, current, loader2, 402 resolved, failed_type_name); 403 THROW_MSG(vmSymbols::java_lang_LinkageError(), buf); 404 } 405 } 406 } 407 } 408 409 void LinkResolver::resolve_interface_method(methodHandle& resolved_method, 410 KlassHandle resolved_klass, 411 Symbol* method_name, 412 Symbol* method_signature, 413 KlassHandle current_klass, 414 bool check_access, TRAPS) { 415 416 // check if klass is interface 417 if (!resolved_klass->is_interface()) { 418 char buf[200]; 419 jio_snprintf(buf, sizeof(buf), "Found class %s, but interface was expected", Klass::cast(resolved_klass())->external_name()); 420 THROW_MSG(vmSymbols::java_lang_IncompatibleClassChangeError(), buf); 421 } 422 423 // lookup method in this interface or its super, java.lang.Object 424 lookup_instance_method_in_klasses(resolved_method, resolved_klass, method_name, method_signature, CHECK); 425 426 if (resolved_method.is_null()) { 427 // lookup method in all the super-interfaces 428 lookup_method_in_interfaces(resolved_method, resolved_klass, method_name, method_signature, CHECK); 429 if (resolved_method.is_null()) { 430 // no method found 431 ResourceMark rm(THREAD); 432 THROW_MSG(vmSymbols::java_lang_NoSuchMethodError(), 433 methodOopDesc::name_and_sig_as_C_string(Klass::cast(resolved_klass()), 434 method_name, 435 method_signature)); 436 } 437 } 438 439 if (check_access) { 440 HandleMark hm(THREAD); 441 Handle loader (THREAD, instanceKlass::cast(current_klass())->class_loader()); 442 Handle class_loader (THREAD, instanceKlass::cast(resolved_method->method_holder())->class_loader()); 443 { 444 ResourceMark rm(THREAD); 445 char* failed_type_name = 446 SystemDictionary::check_signature_loaders(method_signature, loader, 447 class_loader, true, CHECK); 448 if (failed_type_name != NULL) { 449 const char* msg = "loader constraint violation: when resolving " 450 "interface method \"%s\" the class loader (instance of %s) of the " 451 "current class, %s, and the class loader (instance of %s) for " 452 "resolved class, %s, have different Class objects for the type %s " 453 "used in the signature"; 454 char* sig = methodOopDesc::name_and_sig_as_C_string(Klass::cast(resolved_klass()),method_name,method_signature); 455 const char* loader1 = SystemDictionary::loader_name(loader()); 456 char* current = instanceKlass::cast(current_klass())->name()->as_C_string(); 457 const char* loader2 = SystemDictionary::loader_name(class_loader()); 458 char* resolved = instanceKlass::cast(resolved_klass())->name()->as_C_string(); 459 size_t buflen = strlen(msg) + strlen(sig) + strlen(loader1) + 460 strlen(current) + strlen(loader2) + strlen(resolved) + 461 strlen(failed_type_name); 462 char* buf = NEW_RESOURCE_ARRAY_IN_THREAD(THREAD, char, buflen); 463 jio_snprintf(buf, buflen, msg, sig, loader1, current, loader2, 464 resolved, failed_type_name); 465 THROW_MSG(vmSymbols::java_lang_LinkageError(), buf); 466 } 467 } 468 } 469 } 470 471 //------------------------------------------------------------------------------------------------------------------------ 472 // Field resolution 473 474 void LinkResolver::check_field_accessability(KlassHandle ref_klass, 475 KlassHandle resolved_klass, 476 KlassHandle sel_klass, 477 fieldDescriptor& fd, 478 TRAPS) { 479 if (!Reflection::verify_field_access(ref_klass->as_klassOop(), 480 resolved_klass->as_klassOop(), 481 sel_klass->as_klassOop(), 482 fd.access_flags(), 483 true)) { 484 ResourceMark rm(THREAD); 485 Exceptions::fthrow( 486 THREAD_AND_LOCATION, 487 vmSymbols::java_lang_IllegalAccessError(), 488 "tried to access field %s.%s from class %s", 489 sel_klass->external_name(), 490 fd.name()->as_C_string(), 491 ref_klass->external_name() 492 ); 493 return; 494 } 495 } 496 497 void LinkResolver::resolve_field(FieldAccessInfo& result, constantPoolHandle pool, int index, Bytecodes::Code byte, bool check_only, TRAPS) { 498 resolve_field(result, pool, index, byte, check_only, true, CHECK); 499 } 500 501 void LinkResolver::resolve_field(FieldAccessInfo& result, constantPoolHandle pool, int index, Bytecodes::Code byte, bool check_only, bool update_pool, TRAPS) { 502 assert(byte == Bytecodes::_getstatic || byte == Bytecodes::_putstatic || 503 byte == Bytecodes::_getfield || byte == Bytecodes::_putfield, "bad bytecode"); 504 505 bool is_static = (byte == Bytecodes::_getstatic || byte == Bytecodes::_putstatic); 506 bool is_put = (byte == Bytecodes::_putfield || byte == Bytecodes::_putstatic); 507 508 // resolve specified klass 509 KlassHandle resolved_klass; 510 if (update_pool) { 511 resolve_klass(resolved_klass, pool, index, CHECK); 512 } else { 513 resolve_klass_no_update(resolved_klass, pool, index, CHECK); 514 } 515 // Load these early in case the resolve of the containing klass fails 516 Symbol* field = pool->name_ref_at(index); 517 Symbol* sig = pool->signature_ref_at(index); 518 // Check if there's a resolved klass containing the field 519 if( resolved_klass.is_null() ) { 520 ResourceMark rm(THREAD); 521 THROW_MSG(vmSymbols::java_lang_NoSuchFieldError(), field->as_C_string()); 522 } 523 524 // Resolve instance field 525 fieldDescriptor fd; // find_field initializes fd if found 526 KlassHandle sel_klass(THREAD, instanceKlass::cast(resolved_klass())->find_field(field, sig, &fd)); 527 // check if field exists; i.e., if a klass containing the field def has been selected 528 if (sel_klass.is_null()){ 529 ResourceMark rm(THREAD); 530 THROW_MSG(vmSymbols::java_lang_NoSuchFieldError(), field->as_C_string()); 531 } 532 533 // check access 534 KlassHandle ref_klass(THREAD, pool->pool_holder()); 535 check_field_accessability(ref_klass, resolved_klass, sel_klass, fd, CHECK); 536 537 // check for errors 538 if (is_static != fd.is_static()) { 539 char msg[200]; 540 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()); 541 THROW_MSG(vmSymbols::java_lang_IncompatibleClassChangeError(), msg); 542 } 543 544 // Final fields can only be accessed from its own class. 545 if (is_put && fd.access_flags().is_final() && sel_klass() != pool->pool_holder()) { 546 THROW(vmSymbols::java_lang_IllegalAccessError()); 547 } 548 549 // initialize resolved_klass if necessary 550 // note 1: the klass which declared the field must be initialized (i.e, sel_klass) 551 // according to the newest JVM spec (5.5, p.170) - was bug (gri 7/28/99) 552 // 553 // note 2: we don't want to force initialization if we are just checking 554 // if the field access is legal; e.g., during compilation 555 if (is_static && !check_only) { 556 sel_klass->initialize(CHECK); 557 } 558 559 { 560 HandleMark hm(THREAD); 561 Handle ref_loader (THREAD, instanceKlass::cast(ref_klass())->class_loader()); 562 Handle sel_loader (THREAD, instanceKlass::cast(sel_klass())->class_loader()); 563 Symbol* signature_ref = pool->signature_ref_at(index); 564 { 565 ResourceMark rm(THREAD); 566 char* failed_type_name = 567 SystemDictionary::check_signature_loaders(signature_ref, 568 ref_loader, sel_loader, 569 false, 570 CHECK); 571 if (failed_type_name != NULL) { 572 const char* msg = "loader constraint violation: when resolving field" 573 " \"%s\" the class loader (instance of %s) of the referring class, " 574 "%s, and the class loader (instance of %s) for the field's resolved " 575 "type, %s, have different Class objects for that type"; 576 char* field_name = field->as_C_string(); 577 const char* loader1 = SystemDictionary::loader_name(ref_loader()); 578 char* sel = instanceKlass::cast(sel_klass())->name()->as_C_string(); 579 const char* loader2 = SystemDictionary::loader_name(sel_loader()); 580 size_t buflen = strlen(msg) + strlen(field_name) + strlen(loader1) + 581 strlen(sel) + strlen(loader2) + strlen(failed_type_name); 582 char* buf = NEW_RESOURCE_ARRAY_IN_THREAD(THREAD, char, buflen); 583 jio_snprintf(buf, buflen, msg, field_name, loader1, sel, loader2, 584 failed_type_name); 585 THROW_MSG(vmSymbols::java_lang_LinkageError(), buf); 586 } 587 } 588 } 589 590 // return information. note that the klass is set to the actual klass containing the 591 // field, otherwise access of static fields in superclasses will not work. 592 KlassHandle holder (THREAD, fd.field_holder()); 593 Symbol* name = fd.name(); 594 result.set(holder, name, fd.index(), fd.offset(), fd.field_type(), fd.access_flags()); 595 } 596 597 598 //------------------------------------------------------------------------------------------------------------------------ 599 // Invoke resolution 600 // 601 // Naming conventions: 602 // 603 // resolved_method the specified method (i.e., static receiver specified via constant pool index) 604 // sel_method the selected method (selected via run-time lookup; e.g., based on dynamic receiver class) 605 // resolved_klass the specified klass (i.e., specified via constant pool index) 606 // recv_klass the receiver klass 607 608 609 void LinkResolver::resolve_static_call(CallInfo& result, KlassHandle& resolved_klass, Symbol* method_name, 610 Symbol* method_signature, KlassHandle current_klass, 611 bool check_access, bool initialize_class, TRAPS) { 612 methodHandle resolved_method; 613 linktime_resolve_static_method(resolved_method, resolved_klass, method_name, method_signature, current_klass, check_access, CHECK); 614 resolved_klass = KlassHandle(THREAD, Klass::cast(resolved_method->method_holder())); 615 616 // Initialize klass (this should only happen if everything is ok) 617 if (initialize_class && resolved_klass->should_be_initialized()) { 618 resolved_klass->initialize(CHECK); 619 linktime_resolve_static_method(resolved_method, resolved_klass, method_name, method_signature, current_klass, check_access, CHECK); 620 } 621 622 // setup result 623 result.set_static(resolved_klass, resolved_method, CHECK); 624 } 625 626 // throws linktime exceptions 627 void LinkResolver::linktime_resolve_static_method(methodHandle& resolved_method, KlassHandle resolved_klass, 628 Symbol* method_name, Symbol* method_signature, 629 KlassHandle current_klass, bool check_access, TRAPS) { 630 631 resolve_method(resolved_method, resolved_klass, method_name, method_signature, current_klass, check_access, CHECK); 632 assert(resolved_method->name() != vmSymbols::class_initializer_name(), "should have been checked in verifier"); 633 634 // check if static 635 if (!resolved_method->is_static()) { 636 char buf[200]; 637 jio_snprintf(buf, sizeof(buf), "Expected static method %s", methodOopDesc::name_and_sig_as_C_string(Klass::cast(resolved_klass()), 638 resolved_method->name(), 639 resolved_method->signature())); 640 THROW_MSG(vmSymbols::java_lang_IncompatibleClassChangeError(), buf); 641 } 642 } 643 644 645 void LinkResolver::resolve_special_call(CallInfo& result, KlassHandle resolved_klass, Symbol* method_name, 646 Symbol* method_signature, KlassHandle current_klass, bool check_access, TRAPS) { 647 methodHandle resolved_method; 648 linktime_resolve_special_method(resolved_method, resolved_klass, method_name, method_signature, current_klass, check_access, CHECK); 649 runtime_resolve_special_method(result, resolved_method, resolved_klass, current_klass, check_access, CHECK); 650 } 651 652 // throws linktime exceptions 653 void LinkResolver::linktime_resolve_special_method(methodHandle& resolved_method, KlassHandle resolved_klass, 654 Symbol* method_name, Symbol* method_signature, 655 KlassHandle current_klass, bool check_access, TRAPS) { 656 657 resolve_method(resolved_method, resolved_klass, method_name, method_signature, current_klass, check_access, CHECK); 658 659 // check if method name is <init>, that it is found in same klass as static type 660 if (resolved_method->name() == vmSymbols::object_initializer_name() && 661 resolved_method->method_holder() != resolved_klass()) { 662 ResourceMark rm(THREAD); 663 Exceptions::fthrow( 664 THREAD_AND_LOCATION, 665 vmSymbols::java_lang_NoSuchMethodError(), 666 "%s: method %s%s not found", 667 resolved_klass->external_name(), 668 resolved_method->name()->as_C_string(), 669 resolved_method->signature()->as_C_string() 670 ); 671 return; 672 } 673 674 // check if not static 675 if (resolved_method->is_static()) { 676 char buf[200]; 677 jio_snprintf(buf, sizeof(buf), 678 "Expecting non-static method %s", 679 methodOopDesc::name_and_sig_as_C_string(Klass::cast(resolved_klass()), 680 resolved_method->name(), 681 resolved_method->signature())); 682 THROW_MSG(vmSymbols::java_lang_IncompatibleClassChangeError(), buf); 683 } 684 } 685 686 // throws runtime exceptions 687 void LinkResolver::runtime_resolve_special_method(CallInfo& result, methodHandle resolved_method, KlassHandle resolved_klass, 688 KlassHandle current_klass, bool check_access, TRAPS) { 689 690 // resolved method is selected method unless we have an old-style lookup 691 methodHandle sel_method(THREAD, resolved_method()); 692 693 // check if this is an old-style super call and do a new lookup if so 694 { KlassHandle method_klass = KlassHandle(THREAD, 695 resolved_method->method_holder()); 696 697 if (check_access && 698 // a) check if ACC_SUPER flag is set for the current class 699 current_klass->is_super() && 700 // b) check if the method class is a superclass of the current class (superclass relation is not reflexive!) 701 current_klass->is_subtype_of(method_klass()) && current_klass() != method_klass() && 702 // c) check if the method is not <init> 703 resolved_method->name() != vmSymbols::object_initializer_name()) { 704 // Lookup super method 705 KlassHandle super_klass(THREAD, current_klass->super()); 706 lookup_instance_method_in_klasses(sel_method, super_klass, 707 resolved_method->name(), 708 resolved_method->signature(), CHECK); 709 // check if found 710 if (sel_method.is_null()) { 711 ResourceMark rm(THREAD); 712 THROW_MSG(vmSymbols::java_lang_AbstractMethodError(), 713 methodOopDesc::name_and_sig_as_C_string(Klass::cast(resolved_klass()), 714 resolved_method->name(), 715 resolved_method->signature())); 716 } 717 } 718 } 719 720 // check if not static 721 if (sel_method->is_static()) { 722 char buf[200]; 723 jio_snprintf(buf, sizeof(buf), "Expecting non-static method %s", methodOopDesc::name_and_sig_as_C_string(Klass::cast(resolved_klass()), 724 resolved_method->name(), 725 resolved_method->signature())); 726 THROW_MSG(vmSymbols::java_lang_IncompatibleClassChangeError(), buf); 727 } 728 729 // check if abstract 730 if (sel_method->is_abstract()) { 731 ResourceMark rm(THREAD); 732 THROW_MSG(vmSymbols::java_lang_AbstractMethodError(), 733 methodOopDesc::name_and_sig_as_C_string(Klass::cast(resolved_klass()), 734 sel_method->name(), 735 sel_method->signature())); 736 } 737 738 // setup result 739 result.set_static(resolved_klass, sel_method, CHECK); 740 } 741 742 void LinkResolver::resolve_virtual_call(CallInfo& result, Handle recv, KlassHandle receiver_klass, KlassHandle resolved_klass, 743 Symbol* method_name, Symbol* method_signature, KlassHandle current_klass, 744 bool check_access, bool check_null_and_abstract, TRAPS) { 745 methodHandle resolved_method; 746 linktime_resolve_virtual_method(resolved_method, resolved_klass, method_name, method_signature, current_klass, check_access, CHECK); 747 runtime_resolve_virtual_method(result, resolved_method, resolved_klass, recv, receiver_klass, check_null_and_abstract, CHECK); 748 } 749 750 // throws linktime exceptions 751 void LinkResolver::linktime_resolve_virtual_method(methodHandle &resolved_method, KlassHandle resolved_klass, 752 Symbol* method_name, Symbol* method_signature, 753 KlassHandle current_klass, bool check_access, TRAPS) { 754 // normal method resolution 755 resolve_method(resolved_method, resolved_klass, method_name, method_signature, current_klass, check_access, CHECK); 756 757 assert(resolved_method->name() != vmSymbols::object_initializer_name(), "should have been checked in verifier"); 758 assert(resolved_method->name() != vmSymbols::class_initializer_name (), "should have been checked in verifier"); 759 760 // check if not static 761 if (resolved_method->is_static()) { 762 char buf[200]; 763 jio_snprintf(buf, sizeof(buf), "Expecting non-static method %s", methodOopDesc::name_and_sig_as_C_string(Klass::cast(resolved_klass()), 764 resolved_method->name(), 765 resolved_method->signature())); 766 THROW_MSG(vmSymbols::java_lang_IncompatibleClassChangeError(), buf); 767 } 768 } 769 770 // throws runtime exceptions 771 void LinkResolver::runtime_resolve_virtual_method(CallInfo& result, 772 methodHandle resolved_method, 773 KlassHandle resolved_klass, 774 Handle recv, 775 KlassHandle recv_klass, 776 bool check_null_and_abstract, 777 TRAPS) { 778 779 // setup default return values 780 int vtable_index = methodOopDesc::invalid_vtable_index; 781 methodHandle selected_method; 782 783 assert(recv.is_null() || recv->is_oop(), "receiver is not an oop"); 784 785 // runtime method resolution 786 if (check_null_and_abstract && recv.is_null()) { // check if receiver exists 787 THROW(vmSymbols::java_lang_NullPointerException()); 788 } 789 790 // Virtual methods cannot be resolved before its klass has been linked, for otherwise the methodOop's 791 // has not been rewritten, and the vtable initialized. 792 assert(instanceKlass::cast(resolved_method->method_holder())->is_linked(), "must be linked"); 793 794 // Virtual methods cannot be resolved before its klass has been linked, for otherwise the methodOop's 795 // has not been rewritten, and the vtable initialized. Make sure to do this after the nullcheck, since 796 // a missing receiver might result in a bogus lookup. 797 assert(instanceKlass::cast(resolved_method->method_holder())->is_linked(), "must be linked"); 798 799 // do lookup based on receiver klass using the vtable index 800 if (resolved_method->method_holder()->klass_part()->is_interface()) { // miranda method 801 vtable_index = vtable_index_of_miranda_method(resolved_klass, 802 resolved_method->name(), 803 resolved_method->signature(), CHECK); 804 assert(vtable_index >= 0 , "we should have valid vtable index at this point"); 805 806 instanceKlass* inst = instanceKlass::cast(recv_klass()); 807 selected_method = methodHandle(THREAD, inst->method_at_vtable(vtable_index)); 808 } else { 809 // at this point we are sure that resolved_method is virtual and not 810 // a miranda method; therefore, it must have a valid vtable index. 811 vtable_index = resolved_method->vtable_index(); 812 // We could get a negative vtable_index for final methods, 813 // because as an optimization they are they are never put in the vtable, 814 // unless they override an existing method. 815 // If we do get a negative, it means the resolved method is the the selected 816 // method, and it can never be changed by an override. 817 if (vtable_index == methodOopDesc::nonvirtual_vtable_index) { 818 assert(resolved_method->can_be_statically_bound(), "cannot override this method"); 819 selected_method = resolved_method; 820 } else { 821 // recv_klass might be an arrayKlassOop but all vtables start at 822 // the same place. The cast is to avoid virtual call and assertion. 823 instanceKlass* inst = (instanceKlass*)recv_klass()->klass_part(); 824 selected_method = methodHandle(THREAD, inst->method_at_vtable(vtable_index)); 825 } 826 } 827 828 // check if method exists 829 if (selected_method.is_null()) { 830 ResourceMark rm(THREAD); 831 THROW_MSG(vmSymbols::java_lang_AbstractMethodError(), 832 methodOopDesc::name_and_sig_as_C_string(Klass::cast(resolved_klass()), 833 resolved_method->name(), 834 resolved_method->signature())); 835 } 836 837 // check if abstract 838 if (check_null_and_abstract && selected_method->is_abstract()) { 839 ResourceMark rm(THREAD); 840 THROW_MSG(vmSymbols::java_lang_AbstractMethodError(), 841 methodOopDesc::name_and_sig_as_C_string(Klass::cast(resolved_klass()), 842 selected_method->name(), 843 selected_method->signature())); 844 } 845 846 // setup result 847 result.set_virtual(resolved_klass, recv_klass, resolved_method, selected_method, vtable_index, CHECK); 848 } 849 850 void LinkResolver::resolve_interface_call(CallInfo& result, Handle recv, KlassHandle recv_klass, KlassHandle resolved_klass, 851 Symbol* method_name, Symbol* method_signature, KlassHandle current_klass, 852 bool check_access, bool check_null_and_abstract, TRAPS) { 853 methodHandle resolved_method; 854 linktime_resolve_interface_method(resolved_method, resolved_klass, method_name, method_signature, current_klass, check_access, CHECK); 855 runtime_resolve_interface_method(result, resolved_method, resolved_klass, recv, recv_klass, check_null_and_abstract, CHECK); 856 } 857 858 // throws linktime exceptions 859 void LinkResolver::linktime_resolve_interface_method(methodHandle& resolved_method, KlassHandle resolved_klass, Symbol* method_name, 860 Symbol* method_signature, KlassHandle current_klass, bool check_access, TRAPS) { 861 // normal interface method resolution 862 resolve_interface_method(resolved_method, resolved_klass, method_name, method_signature, current_klass, check_access, CHECK); 863 864 assert(resolved_method->name() != vmSymbols::object_initializer_name(), "should have been checked in verifier"); 865 assert(resolved_method->name() != vmSymbols::class_initializer_name (), "should have been checked in verifier"); 866 } 867 868 // throws runtime exceptions 869 void LinkResolver::runtime_resolve_interface_method(CallInfo& result, methodHandle resolved_method, KlassHandle resolved_klass, 870 Handle recv, KlassHandle recv_klass, bool check_null_and_abstract, TRAPS) { 871 // check if receiver exists 872 if (check_null_and_abstract && recv.is_null()) { 873 THROW(vmSymbols::java_lang_NullPointerException()); 874 } 875 876 // check if receiver klass implements the resolved interface 877 if (!recv_klass->is_subtype_of(resolved_klass())) { 878 char buf[200]; 879 jio_snprintf(buf, sizeof(buf), "Class %s does not implement the requested interface %s", 880 (Klass::cast(recv_klass()))->external_name(), 881 (Klass::cast(resolved_klass()))->external_name()); 882 THROW_MSG(vmSymbols::java_lang_IncompatibleClassChangeError(), buf); 883 } 884 // do lookup based on receiver klass 885 methodHandle sel_method; 886 lookup_instance_method_in_klasses(sel_method, recv_klass, 887 resolved_method->name(), 888 resolved_method->signature(), CHECK); 889 // check if method exists 890 if (sel_method.is_null()) { 891 ResourceMark rm(THREAD); 892 THROW_MSG(vmSymbols::java_lang_AbstractMethodError(), 893 methodOopDesc::name_and_sig_as_C_string(Klass::cast(recv_klass()), 894 resolved_method->name(), 895 resolved_method->signature())); 896 } 897 // check if public 898 if (!sel_method->is_public()) { 899 ResourceMark rm(THREAD); 900 THROW_MSG(vmSymbols::java_lang_IllegalAccessError(), 901 methodOopDesc::name_and_sig_as_C_string(Klass::cast(recv_klass()), 902 sel_method->name(), 903 sel_method->signature())); 904 } 905 // check if abstract 906 if (check_null_and_abstract && sel_method->is_abstract()) { 907 ResourceMark rm(THREAD); 908 THROW_MSG(vmSymbols::java_lang_AbstractMethodError(), 909 methodOopDesc::name_and_sig_as_C_string(Klass::cast(recv_klass()), 910 sel_method->name(), 911 sel_method->signature())); 912 } 913 // setup result 914 result.set_interface(resolved_klass, recv_klass, resolved_method, sel_method, CHECK); 915 } 916 917 918 methodHandle LinkResolver::linktime_resolve_interface_method_or_null( 919 KlassHandle resolved_klass, 920 Symbol* method_name, 921 Symbol* method_signature, 922 KlassHandle current_klass, 923 bool check_access) { 924 EXCEPTION_MARK; 925 methodHandle method_result; 926 linktime_resolve_interface_method(method_result, resolved_klass, method_name, method_signature, current_klass, check_access, THREAD); 927 if (HAS_PENDING_EXCEPTION) { 928 CLEAR_PENDING_EXCEPTION; 929 return methodHandle(); 930 } else { 931 return method_result; 932 } 933 } 934 935 methodHandle LinkResolver::linktime_resolve_virtual_method_or_null( 936 KlassHandle resolved_klass, 937 Symbol* method_name, 938 Symbol* method_signature, 939 KlassHandle current_klass, 940 bool check_access) { 941 EXCEPTION_MARK; 942 methodHandle method_result; 943 linktime_resolve_virtual_method(method_result, resolved_klass, method_name, method_signature, current_klass, check_access, THREAD); 944 if (HAS_PENDING_EXCEPTION) { 945 CLEAR_PENDING_EXCEPTION; 946 return methodHandle(); 947 } else { 948 return method_result; 949 } 950 } 951 952 methodHandle LinkResolver::resolve_virtual_call_or_null( 953 KlassHandle receiver_klass, 954 KlassHandle resolved_klass, 955 Symbol* name, 956 Symbol* signature, 957 KlassHandle current_klass) { 958 EXCEPTION_MARK; 959 CallInfo info; 960 resolve_virtual_call(info, Handle(), receiver_klass, resolved_klass, name, signature, current_klass, true, false, THREAD); 961 if (HAS_PENDING_EXCEPTION) { 962 CLEAR_PENDING_EXCEPTION; 963 return methodHandle(); 964 } 965 return info.selected_method(); 966 } 967 968 methodHandle LinkResolver::resolve_interface_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_interface_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 int LinkResolver::resolve_virtual_vtable_index( 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_virtual_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 methodOopDesc::invalid_vtable_index; 996 } 997 return info.vtable_index(); 998 } 999 1000 methodHandle LinkResolver::resolve_static_call_or_null( 1001 KlassHandle resolved_klass, 1002 Symbol* name, 1003 Symbol* signature, 1004 KlassHandle current_klass) { 1005 EXCEPTION_MARK; 1006 CallInfo info; 1007 resolve_static_call(info, resolved_klass, name, signature, current_klass, true, false, THREAD); 1008 if (HAS_PENDING_EXCEPTION) { 1009 CLEAR_PENDING_EXCEPTION; 1010 return methodHandle(); 1011 } 1012 return info.selected_method(); 1013 } 1014 1015 methodHandle LinkResolver::resolve_special_call_or_null(KlassHandle resolved_klass, Symbol* name, Symbol* signature, 1016 KlassHandle current_klass) { 1017 EXCEPTION_MARK; 1018 CallInfo info; 1019 resolve_special_call(info, resolved_klass, name, signature, current_klass, true, THREAD); 1020 if (HAS_PENDING_EXCEPTION) { 1021 CLEAR_PENDING_EXCEPTION; 1022 return methodHandle(); 1023 } 1024 return info.selected_method(); 1025 } 1026 1027 1028 1029 //------------------------------------------------------------------------------------------------------------------------ 1030 // ConstantPool entries 1031 1032 void LinkResolver::resolve_invoke(CallInfo& result, Handle recv, constantPoolHandle pool, int index, Bytecodes::Code byte, TRAPS) { 1033 switch (byte) { 1034 case Bytecodes::_invokestatic : resolve_invokestatic (result, pool, index, CHECK); break; 1035 case Bytecodes::_invokespecial : resolve_invokespecial (result, pool, index, CHECK); break; 1036 case Bytecodes::_invokevirtual : resolve_invokevirtual (result, recv, pool, index, CHECK); break; 1037 case Bytecodes::_invokedynamic : resolve_invokedynamic (result, pool, index, CHECK); break; 1038 case Bytecodes::_invokeinterface: resolve_invokeinterface(result, recv, pool, index, CHECK); break; 1039 } 1040 return; 1041 } 1042 1043 void LinkResolver::resolve_pool(KlassHandle& resolved_klass, Symbol*& method_name, Symbol*& method_signature, 1044 KlassHandle& current_klass, constantPoolHandle pool, int index, TRAPS) { 1045 // resolve klass 1046 resolve_klass(resolved_klass, pool, index, CHECK); 1047 1048 // Get name, signature, and static klass 1049 method_name = pool->name_ref_at(index); 1050 method_signature = pool->signature_ref_at(index); 1051 current_klass = KlassHandle(THREAD, pool->pool_holder()); 1052 } 1053 1054 1055 void LinkResolver::resolve_invokestatic(CallInfo& result, constantPoolHandle pool, int index, TRAPS) { 1056 KlassHandle resolved_klass; 1057 Symbol* method_name = NULL; 1058 Symbol* method_signature = NULL; 1059 KlassHandle current_klass; 1060 resolve_pool(resolved_klass, method_name, method_signature, current_klass, pool, index, CHECK); 1061 resolve_static_call(result, resolved_klass, method_name, method_signature, current_klass, true, true, CHECK); 1062 } 1063 1064 1065 void LinkResolver::resolve_invokespecial(CallInfo& result, constantPoolHandle pool, int index, TRAPS) { 1066 KlassHandle resolved_klass; 1067 Symbol* method_name = NULL; 1068 Symbol* method_signature = NULL; 1069 KlassHandle current_klass; 1070 resolve_pool(resolved_klass, method_name, method_signature, current_klass, pool, index, CHECK); 1071 resolve_special_call(result, resolved_klass, method_name, method_signature, current_klass, true, CHECK); 1072 } 1073 1074 1075 void LinkResolver::resolve_invokevirtual(CallInfo& result, Handle recv, 1076 constantPoolHandle pool, int index, 1077 TRAPS) { 1078 1079 KlassHandle resolved_klass; 1080 Symbol* method_name = NULL; 1081 Symbol* method_signature = NULL; 1082 KlassHandle current_klass; 1083 resolve_pool(resolved_klass, method_name, method_signature, current_klass, pool, index, CHECK); 1084 KlassHandle recvrKlass (THREAD, recv.is_null() ? (klassOop)NULL : recv->klass()); 1085 resolve_virtual_call(result, recv, recvrKlass, resolved_klass, method_name, method_signature, current_klass, true, true, CHECK); 1086 } 1087 1088 1089 void LinkResolver::resolve_invokeinterface(CallInfo& result, Handle recv, constantPoolHandle pool, int index, TRAPS) { 1090 KlassHandle resolved_klass; 1091 Symbol* method_name = NULL; 1092 Symbol* method_signature = NULL; 1093 KlassHandle current_klass; 1094 resolve_pool(resolved_klass, method_name, method_signature, current_klass, pool, index, CHECK); 1095 KlassHandle recvrKlass (THREAD, recv.is_null() ? (klassOop)NULL : recv->klass()); 1096 resolve_interface_call(result, recv, recvrKlass, resolved_klass, method_name, method_signature, current_klass, true, true, CHECK); 1097 } 1098 1099 1100 void LinkResolver::resolve_invokedynamic(CallInfo& result, constantPoolHandle pool, int raw_index, TRAPS) { 1101 assert(EnableInvokeDynamic, ""); 1102 1103 // This guy is reached from InterpreterRuntime::resolve_invokedynamic. 1104 1105 // At this point, we only need the signature, and can ignore the name. 1106 Symbol* method_signature = pool->signature_ref_at(raw_index); // raw_index works directly 1107 Symbol* method_name = vmSymbols::invokeExact_name(); 1108 KlassHandle resolved_klass = SystemDictionaryHandles::MethodHandle_klass(); 1109 1110 // JSR 292: this must be an implicitly generated method MethodHandle.invokeExact(*...) 1111 // The extra MH receiver will be inserted into the stack on every call. 1112 methodHandle resolved_method; 1113 KlassHandle current_klass(THREAD, pool->pool_holder()); 1114 lookup_implicit_method(resolved_method, resolved_klass, method_name, method_signature, current_klass, CHECK); 1115 if (resolved_method.is_null()) { 1116 THROW(vmSymbols::java_lang_InternalError()); 1117 } 1118 result.set_dynamic(resolved_method, CHECK); 1119 } 1120 1121 //------------------------------------------------------------------------------------------------------------------------ 1122 #ifndef PRODUCT 1123 1124 void FieldAccessInfo::print() { 1125 ResourceMark rm; 1126 tty->print_cr("Field %s@%d", name()->as_C_string(), field_offset()); 1127 } 1128 1129 #endif