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