Mercurial > hg > truffle
comparison src/share/vm/interpreter/linkResolver.cpp @ 2177:3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
Summary: move symbols from permgen into C heap and reference count them
Reviewed-by: never, acorn, jmasa, stefank
author | coleenp |
---|---|
date | Thu, 27 Jan 2011 16:11:27 -0800 |
parents | f95d63e2154a |
children | 72dee110246f |
comparison
equal
deleted
inserted
replaced
2176:27e4ea99855d | 2177:3582bf76420e |
---|---|
54 #endif | 54 #endif |
55 | 55 |
56 //------------------------------------------------------------------------------------------------------------------------ | 56 //------------------------------------------------------------------------------------------------------------------------ |
57 // Implementation of FieldAccessInfo | 57 // Implementation of FieldAccessInfo |
58 | 58 |
59 void FieldAccessInfo::set(KlassHandle klass, symbolHandle name, int field_index, int field_offset, | 59 void FieldAccessInfo::set(KlassHandle klass, Symbol* name, int field_index, int field_offset, |
60 BasicType field_type, AccessFlags access_flags) { | 60 BasicType field_type, AccessFlags access_flags) { |
61 _klass = klass; | 61 _klass = klass; |
62 _name = name; | 62 _name = name; |
63 _field_index = field_index; | 63 _field_index = field_index; |
64 _field_offset = field_offset; | 64 _field_offset = field_offset; |
146 sel_klass->as_klassOop(), | 146 sel_klass->as_klassOop(), |
147 true)) { | 147 true)) { |
148 ResourceMark rm(THREAD); | 148 ResourceMark rm(THREAD); |
149 Exceptions::fthrow( | 149 Exceptions::fthrow( |
150 THREAD_AND_LOCATION, | 150 THREAD_AND_LOCATION, |
151 vmSymbolHandles::java_lang_IllegalAccessError(), | 151 vmSymbols::java_lang_IllegalAccessError(), |
152 "tried to access class %s from class %s", | 152 "tried to access class %s from class %s", |
153 sel_klass->external_name(), | 153 sel_klass->external_name(), |
154 ref_klass->external_name() | 154 ref_klass->external_name() |
155 ); | 155 ); |
156 return; | 156 return; |
172 //------------------------------------------------------------------------------------------------------------------------ | 172 //------------------------------------------------------------------------------------------------------------------------ |
173 // Method resolution | 173 // Method resolution |
174 // | 174 // |
175 // According to JVM spec. $5.4.3c & $5.4.3d | 175 // According to JVM spec. $5.4.3c & $5.4.3d |
176 | 176 |
177 void LinkResolver::lookup_method_in_klasses(methodHandle& result, KlassHandle klass, symbolHandle name, symbolHandle signature, TRAPS) { | 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()); | 178 methodOop result_oop = klass->uncached_lookup_method(name, signature); |
179 if (EnableMethodHandles && result_oop != NULL) { | 179 if (EnableMethodHandles && result_oop != NULL) { |
180 switch (result_oop->intrinsic_id()) { | 180 switch (result_oop->intrinsic_id()) { |
181 case vmIntrinsics::_invokeExact: | 181 case vmIntrinsics::_invokeExact: |
182 case vmIntrinsics::_invokeGeneric: | 182 case vmIntrinsics::_invokeGeneric: |
183 case vmIntrinsics::_invokeDynamic: | 183 case vmIntrinsics::_invokeDynamic: |
187 } | 187 } |
188 result = methodHandle(THREAD, result_oop); | 188 result = methodHandle(THREAD, result_oop); |
189 } | 189 } |
190 | 190 |
191 // returns first instance method | 191 // returns first instance method |
192 void LinkResolver::lookup_instance_method_in_klasses(methodHandle& result, KlassHandle klass, symbolHandle name, symbolHandle signature, TRAPS) { | 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()); | 193 methodOop result_oop = klass->uncached_lookup_method(name, signature); |
194 result = methodHandle(THREAD, result_oop); | 194 result = methodHandle(THREAD, result_oop); |
195 while (!result.is_null() && result->is_static()) { | 195 while (!result.is_null() && result->is_static()) { |
196 klass = KlassHandle(THREAD, Klass::cast(result->method_holder())->super()); | 196 klass = KlassHandle(THREAD, Klass::cast(result->method_holder())->super()); |
197 result = methodHandle(THREAD, klass->uncached_lookup_method(name(), signature())); | 197 result = methodHandle(THREAD, klass->uncached_lookup_method(name, signature)); |
198 } | 198 } |
199 } | 199 } |
200 | 200 |
201 | 201 |
202 int LinkResolver::vtable_index_of_miranda_method(KlassHandle klass, symbolHandle name, symbolHandle signature, TRAPS) { | 202 int LinkResolver::vtable_index_of_miranda_method(KlassHandle klass, Symbol* name, Symbol* signature, TRAPS) { |
203 ResourceMark rm(THREAD); | 203 ResourceMark rm(THREAD); |
204 klassVtable *vt = instanceKlass::cast(klass())->vtable(); | 204 klassVtable *vt = instanceKlass::cast(klass())->vtable(); |
205 return vt->index_of_miranda(name(), signature()); | 205 return vt->index_of_miranda(name, signature); |
206 } | 206 } |
207 | 207 |
208 void LinkResolver::lookup_method_in_interfaces(methodHandle& result, KlassHandle klass, symbolHandle name, symbolHandle signature, TRAPS) { | 208 void LinkResolver::lookup_method_in_interfaces(methodHandle& result, KlassHandle klass, Symbol* name, Symbol* signature, TRAPS) { |
209 instanceKlass *ik = instanceKlass::cast(klass()); | 209 instanceKlass *ik = instanceKlass::cast(klass()); |
210 result = methodHandle(THREAD, ik->lookup_method_in_all_interfaces(name(), signature())); | 210 result = methodHandle(THREAD, ik->lookup_method_in_all_interfaces(name, signature)); |
211 } | 211 } |
212 | 212 |
213 void LinkResolver::lookup_implicit_method(methodHandle& result, | 213 void LinkResolver::lookup_implicit_method(methodHandle& result, |
214 KlassHandle klass, symbolHandle name, symbolHandle signature, | 214 KlassHandle klass, Symbol* name, Symbol* signature, |
215 KlassHandle current_klass, | 215 KlassHandle current_klass, |
216 TRAPS) { | 216 TRAPS) { |
217 if (EnableMethodHandles && | 217 if (EnableMethodHandles && |
218 klass() == SystemDictionary::MethodHandle_klass() && | 218 klass() == SystemDictionary::MethodHandle_klass() && |
219 methodOopDesc::is_method_handle_invoke_name(name())) { | 219 methodOopDesc::is_method_handle_invoke_name(name)) { |
220 if (!MethodHandles::enabled()) { | 220 if (!MethodHandles::enabled()) { |
221 // Make sure the Java part of the runtime has been booted up. | 221 // Make sure the Java part of the runtime has been booted up. |
222 klassOop natives = SystemDictionary::MethodHandleNatives_klass(); | 222 klassOop natives = SystemDictionary::MethodHandleNatives_klass(); |
223 if (natives == NULL || instanceKlass::cast(natives)->is_not_initialized()) { | 223 if (natives == NULL || instanceKlass::cast(natives)->is_not_initialized()) { |
224 SystemDictionary::resolve_or_fail(vmSymbolHandles::sun_dyn_MethodHandleNatives(), | 224 SystemDictionary::resolve_or_fail(vmSymbols::sun_dyn_MethodHandleNatives(), |
225 Handle(), | 225 Handle(), |
226 Handle(), | 226 Handle(), |
227 true, | 227 true, |
228 CHECK); | 228 CHECK); |
229 } | 229 } |
231 methodOop result_oop = SystemDictionary::find_method_handle_invoke(name, | 231 methodOop result_oop = SystemDictionary::find_method_handle_invoke(name, |
232 signature, | 232 signature, |
233 current_klass, | 233 current_klass, |
234 CHECK); | 234 CHECK); |
235 if (result_oop != NULL) { | 235 if (result_oop != NULL) { |
236 assert(result_oop->is_method_handle_invoke() && result_oop->signature() == signature(), "consistent"); | 236 assert(result_oop->is_method_handle_invoke() && result_oop->signature() == signature, "consistent"); |
237 result = methodHandle(THREAD, result_oop); | 237 result = methodHandle(THREAD, result_oop); |
238 } | 238 } |
239 } | 239 } |
240 } | 240 } |
241 | 241 |
271 flags, | 271 flags, |
272 true)) { | 272 true)) { |
273 ResourceMark rm(THREAD); | 273 ResourceMark rm(THREAD); |
274 Exceptions::fthrow( | 274 Exceptions::fthrow( |
275 THREAD_AND_LOCATION, | 275 THREAD_AND_LOCATION, |
276 vmSymbolHandles::java_lang_IllegalAccessError(), | 276 vmSymbols::java_lang_IllegalAccessError(), |
277 "tried to access method %s.%s%s from class %s", | 277 "tried to access method %s.%s%s from class %s", |
278 sel_klass->external_name(), | 278 sel_klass->external_name(), |
279 sel_method->name()->as_C_string(), | 279 sel_method->name()->as_C_string(), |
280 sel_method->signature()->as_C_string(), | 280 sel_method->signature()->as_C_string(), |
281 ref_klass->external_name() | 281 ref_klass->external_name() |
288 constantPoolHandle pool, int index, TRAPS) { | 288 constantPoolHandle pool, int index, TRAPS) { |
289 | 289 |
290 // resolve klass | 290 // resolve klass |
291 resolve_klass(resolved_klass, pool, index, CHECK); | 291 resolve_klass(resolved_klass, pool, index, CHECK); |
292 | 292 |
293 symbolHandle method_name (THREAD, pool->name_ref_at(index)); | 293 Symbol* method_name = pool->name_ref_at(index); |
294 symbolHandle method_signature (THREAD, pool->signature_ref_at(index)); | 294 Symbol* method_signature = pool->signature_ref_at(index); |
295 KlassHandle current_klass(THREAD, pool->pool_holder()); | 295 KlassHandle current_klass(THREAD, pool->pool_holder()); |
296 | 296 |
297 resolve_method(resolved_method, resolved_klass, method_name, method_signature, current_klass, true, CHECK); | 297 resolve_method(resolved_method, resolved_klass, method_name, method_signature, current_klass, true, CHECK); |
298 } | 298 } |
299 | 299 |
300 void LinkResolver::resolve_dynamic_method(methodHandle& resolved_method, KlassHandle& resolved_klass, constantPoolHandle pool, int index, TRAPS) { | 300 void LinkResolver::resolve_dynamic_method(methodHandle& resolved_method, KlassHandle& resolved_klass, constantPoolHandle pool, int index, TRAPS) { |
301 // The class is java.dyn.MethodHandle | 301 // The class is java.dyn.MethodHandle |
302 resolved_klass = SystemDictionaryHandles::MethodHandle_klass(); | 302 resolved_klass = SystemDictionaryHandles::MethodHandle_klass(); |
303 | 303 |
304 symbolHandle method_name = vmSymbolHandles::invokeExact_name(); | 304 Symbol* method_name = vmSymbols::invokeExact_name(); |
305 | 305 |
306 symbolHandle method_signature(THREAD, pool->signature_ref_at(index)); | 306 Symbol* method_signature = pool->signature_ref_at(index); |
307 KlassHandle current_klass (THREAD, pool->pool_holder()); | 307 KlassHandle current_klass (THREAD, pool->pool_holder()); |
308 | 308 |
309 resolve_method(resolved_method, resolved_klass, method_name, method_signature, current_klass, true, CHECK); | 309 resolve_method(resolved_method, resolved_klass, method_name, method_signature, current_klass, true, CHECK); |
310 } | 310 } |
311 | 311 |
312 void LinkResolver::resolve_interface_method(methodHandle& resolved_method, KlassHandle& resolved_klass, constantPoolHandle pool, int index, TRAPS) { | 312 void LinkResolver::resolve_interface_method(methodHandle& resolved_method, KlassHandle& resolved_klass, constantPoolHandle pool, int index, TRAPS) { |
313 | 313 |
314 // resolve klass | 314 // resolve klass |
315 resolve_klass(resolved_klass, pool, index, CHECK); | 315 resolve_klass(resolved_klass, pool, index, CHECK); |
316 symbolHandle method_name (THREAD, pool->name_ref_at(index)); | 316 Symbol* method_name = pool->name_ref_at(index); |
317 symbolHandle method_signature (THREAD, pool->signature_ref_at(index)); | 317 Symbol* method_signature = pool->signature_ref_at(index); |
318 KlassHandle current_klass(THREAD, pool->pool_holder()); | 318 KlassHandle current_klass(THREAD, pool->pool_holder()); |
319 | 319 |
320 resolve_interface_method(resolved_method, resolved_klass, method_name, method_signature, current_klass, true, CHECK); | 320 resolve_interface_method(resolved_method, resolved_klass, method_name, method_signature, current_klass, true, CHECK); |
321 } | 321 } |
322 | 322 |
323 | 323 |
324 void LinkResolver::resolve_method(methodHandle& resolved_method, KlassHandle resolved_klass, | 324 void LinkResolver::resolve_method(methodHandle& resolved_method, KlassHandle resolved_klass, |
325 symbolHandle method_name, symbolHandle method_signature, | 325 Symbol* method_name, Symbol* method_signature, |
326 KlassHandle current_klass, bool check_access, TRAPS) { | 326 KlassHandle current_klass, bool check_access, TRAPS) { |
327 | 327 |
328 // 1. check if klass is not interface | 328 // 1. check if klass is not interface |
329 if (resolved_klass->is_interface()) { | 329 if (resolved_klass->is_interface()) { |
330 char buf[200]; | 330 char buf[200]; |
347 if (resolved_method.is_null()) { | 347 if (resolved_method.is_null()) { |
348 // 4. method lookup failed | 348 // 4. method lookup failed |
349 ResourceMark rm(THREAD); | 349 ResourceMark rm(THREAD); |
350 THROW_MSG(vmSymbols::java_lang_NoSuchMethodError(), | 350 THROW_MSG(vmSymbols::java_lang_NoSuchMethodError(), |
351 methodOopDesc::name_and_sig_as_C_string(Klass::cast(resolved_klass()), | 351 methodOopDesc::name_and_sig_as_C_string(Klass::cast(resolved_klass()), |
352 method_name(), | 352 method_name, |
353 method_signature())); | 353 method_signature)); |
354 } | 354 } |
355 } | 355 } |
356 | 356 |
357 // 5. check if method is concrete | 357 // 5. check if method is concrete |
358 if (resolved_method->is_abstract() && !resolved_klass->is_abstract()) { | 358 if (resolved_method->is_abstract() && !resolved_klass->is_abstract()) { |
359 ResourceMark rm(THREAD); | 359 ResourceMark rm(THREAD); |
360 THROW_MSG(vmSymbols::java_lang_AbstractMethodError(), | 360 THROW_MSG(vmSymbols::java_lang_AbstractMethodError(), |
361 methodOopDesc::name_and_sig_as_C_string(Klass::cast(resolved_klass()), | 361 methodOopDesc::name_and_sig_as_C_string(Klass::cast(resolved_klass()), |
362 method_name(), | 362 method_name, |
363 method_signature())); | 363 method_signature)); |
364 } | 364 } |
365 | 365 |
366 // 6. access checks, access checking may be turned off when calling from within the VM. | 366 // 6. access checks, access checking may be turned off when calling from within the VM. |
367 if (check_access) { | 367 if (check_access) { |
368 assert(current_klass.not_null() , "current_klass should not be null"); | 368 assert(current_klass.not_null() , "current_klass should not be null"); |
385 if (failed_type_name != NULL) { | 385 if (failed_type_name != NULL) { |
386 const char* msg = "loader constraint violation: when resolving method" | 386 const char* msg = "loader constraint violation: when resolving method" |
387 " \"%s\" the class loader (instance of %s) of the current class, %s," | 387 " \"%s\" the class loader (instance of %s) of the current class, %s," |
388 " and the class loader (instance of %s) for resolved class, %s, have" | 388 " and the class loader (instance of %s) for resolved class, %s, have" |
389 " different Class objects for the type %s used in the signature"; | 389 " different Class objects for the type %s used in the signature"; |
390 char* sig = methodOopDesc::name_and_sig_as_C_string(Klass::cast(resolved_klass()),method_name(),method_signature()); | 390 char* sig = methodOopDesc::name_and_sig_as_C_string(Klass::cast(resolved_klass()),method_name,method_signature); |
391 const char* loader1 = SystemDictionary::loader_name(loader()); | 391 const char* loader1 = SystemDictionary::loader_name(loader()); |
392 char* current = instanceKlass::cast(current_klass())->name()->as_C_string(); | 392 char* current = instanceKlass::cast(current_klass())->name()->as_C_string(); |
393 const char* loader2 = SystemDictionary::loader_name(class_loader()); | 393 const char* loader2 = SystemDictionary::loader_name(class_loader()); |
394 char* resolved = instanceKlass::cast(resolved_klass())->name()->as_C_string(); | 394 char* resolved = instanceKlass::cast(resolved_klass())->name()->as_C_string(); |
395 size_t buflen = strlen(msg) + strlen(sig) + strlen(loader1) + | 395 size_t buflen = strlen(msg) + strlen(sig) + strlen(loader1) + |
404 } | 404 } |
405 } | 405 } |
406 | 406 |
407 void LinkResolver::resolve_interface_method(methodHandle& resolved_method, | 407 void LinkResolver::resolve_interface_method(methodHandle& resolved_method, |
408 KlassHandle resolved_klass, | 408 KlassHandle resolved_klass, |
409 symbolHandle method_name, | 409 Symbol* method_name, |
410 symbolHandle method_signature, | 410 Symbol* method_signature, |
411 KlassHandle current_klass, | 411 KlassHandle current_klass, |
412 bool check_access, TRAPS) { | 412 bool check_access, TRAPS) { |
413 | 413 |
414 // check if klass is interface | 414 // check if klass is interface |
415 if (!resolved_klass->is_interface()) { | 415 if (!resolved_klass->is_interface()) { |
427 if (resolved_method.is_null()) { | 427 if (resolved_method.is_null()) { |
428 // no method found | 428 // no method found |
429 ResourceMark rm(THREAD); | 429 ResourceMark rm(THREAD); |
430 THROW_MSG(vmSymbols::java_lang_NoSuchMethodError(), | 430 THROW_MSG(vmSymbols::java_lang_NoSuchMethodError(), |
431 methodOopDesc::name_and_sig_as_C_string(Klass::cast(resolved_klass()), | 431 methodOopDesc::name_and_sig_as_C_string(Klass::cast(resolved_klass()), |
432 method_name(), | 432 method_name, |
433 method_signature())); | 433 method_signature)); |
434 } | 434 } |
435 } | 435 } |
436 | 436 |
437 if (check_access) { | 437 if (check_access) { |
438 HandleMark hm(THREAD); | 438 HandleMark hm(THREAD); |
447 const char* msg = "loader constraint violation: when resolving " | 447 const char* msg = "loader constraint violation: when resolving " |
448 "interface method \"%s\" the class loader (instance of %s) of the " | 448 "interface method \"%s\" the class loader (instance of %s) of the " |
449 "current class, %s, and the class loader (instance of %s) for " | 449 "current class, %s, and the class loader (instance of %s) for " |
450 "resolved class, %s, have different Class objects for the type %s " | 450 "resolved class, %s, have different Class objects for the type %s " |
451 "used in the signature"; | 451 "used in the signature"; |
452 char* sig = methodOopDesc::name_and_sig_as_C_string(Klass::cast(resolved_klass()),method_name(),method_signature()); | 452 char* sig = methodOopDesc::name_and_sig_as_C_string(Klass::cast(resolved_klass()),method_name,method_signature); |
453 const char* loader1 = SystemDictionary::loader_name(loader()); | 453 const char* loader1 = SystemDictionary::loader_name(loader()); |
454 char* current = instanceKlass::cast(current_klass())->name()->as_C_string(); | 454 char* current = instanceKlass::cast(current_klass())->name()->as_C_string(); |
455 const char* loader2 = SystemDictionary::loader_name(class_loader()); | 455 const char* loader2 = SystemDictionary::loader_name(class_loader()); |
456 char* resolved = instanceKlass::cast(resolved_klass())->name()->as_C_string(); | 456 char* resolved = instanceKlass::cast(resolved_klass())->name()->as_C_string(); |
457 size_t buflen = strlen(msg) + strlen(sig) + strlen(loader1) + | 457 size_t buflen = strlen(msg) + strlen(sig) + strlen(loader1) + |
480 fd.access_flags(), | 480 fd.access_flags(), |
481 true)) { | 481 true)) { |
482 ResourceMark rm(THREAD); | 482 ResourceMark rm(THREAD); |
483 Exceptions::fthrow( | 483 Exceptions::fthrow( |
484 THREAD_AND_LOCATION, | 484 THREAD_AND_LOCATION, |
485 vmSymbolHandles::java_lang_IllegalAccessError(), | 485 vmSymbols::java_lang_IllegalAccessError(), |
486 "tried to access field %s.%s from class %s", | 486 "tried to access field %s.%s from class %s", |
487 sel_klass->external_name(), | 487 sel_klass->external_name(), |
488 fd.name()->as_C_string(), | 488 fd.name()->as_C_string(), |
489 ref_klass->external_name() | 489 ref_klass->external_name() |
490 ); | 490 ); |
509 resolve_klass(resolved_klass, pool, index, CHECK); | 509 resolve_klass(resolved_klass, pool, index, CHECK); |
510 } else { | 510 } else { |
511 resolve_klass_no_update(resolved_klass, pool, index, CHECK); | 511 resolve_klass_no_update(resolved_klass, pool, index, CHECK); |
512 } | 512 } |
513 // Load these early in case the resolve of the containing klass fails | 513 // Load these early in case the resolve of the containing klass fails |
514 symbolOop field = pool->name_ref_at(index); | 514 Symbol* field = pool->name_ref_at(index); |
515 symbolHandle field_h (THREAD, field); // preserve in case we need the name | 515 Symbol* sig = pool->signature_ref_at(index); |
516 symbolOop sig = pool->signature_ref_at(index); | |
517 // Check if there's a resolved klass containing the field | 516 // Check if there's a resolved klass containing the field |
518 if( resolved_klass.is_null() ) { | 517 if( resolved_klass.is_null() ) { |
519 ResourceMark rm(THREAD); | 518 ResourceMark rm(THREAD); |
520 THROW_MSG(vmSymbols::java_lang_NoSuchFieldError(), field->as_C_string()); | 519 THROW_MSG(vmSymbols::java_lang_NoSuchFieldError(), field->as_C_string()); |
521 } | 520 } |
557 | 556 |
558 { | 557 { |
559 HandleMark hm(THREAD); | 558 HandleMark hm(THREAD); |
560 Handle ref_loader (THREAD, instanceKlass::cast(ref_klass())->class_loader()); | 559 Handle ref_loader (THREAD, instanceKlass::cast(ref_klass())->class_loader()); |
561 Handle sel_loader (THREAD, instanceKlass::cast(sel_klass())->class_loader()); | 560 Handle sel_loader (THREAD, instanceKlass::cast(sel_klass())->class_loader()); |
562 symbolHandle signature_ref (THREAD, pool->signature_ref_at(index)); | 561 Symbol* signature_ref = pool->signature_ref_at(index); |
563 { | 562 { |
564 ResourceMark rm(THREAD); | 563 ResourceMark rm(THREAD); |
565 char* failed_type_name = | 564 char* failed_type_name = |
566 SystemDictionary::check_signature_loaders(signature_ref, | 565 SystemDictionary::check_signature_loaders(signature_ref, |
567 ref_loader, sel_loader, | 566 ref_loader, sel_loader, |
570 if (failed_type_name != NULL) { | 569 if (failed_type_name != NULL) { |
571 const char* msg = "loader constraint violation: when resolving field" | 570 const char* msg = "loader constraint violation: when resolving field" |
572 " \"%s\" the class loader (instance of %s) of the referring class, " | 571 " \"%s\" the class loader (instance of %s) of the referring class, " |
573 "%s, and the class loader (instance of %s) for the field's resolved " | 572 "%s, and the class loader (instance of %s) for the field's resolved " |
574 "type, %s, have different Class objects for that type"; | 573 "type, %s, have different Class objects for that type"; |
575 char* field_name = field_h()->as_C_string(); | 574 char* field_name = field->as_C_string(); |
576 const char* loader1 = SystemDictionary::loader_name(ref_loader()); | 575 const char* loader1 = SystemDictionary::loader_name(ref_loader()); |
577 char* sel = instanceKlass::cast(sel_klass())->name()->as_C_string(); | 576 char* sel = instanceKlass::cast(sel_klass())->name()->as_C_string(); |
578 const char* loader2 = SystemDictionary::loader_name(sel_loader()); | 577 const char* loader2 = SystemDictionary::loader_name(sel_loader()); |
579 size_t buflen = strlen(msg) + strlen(field_name) + strlen(loader1) + | 578 size_t buflen = strlen(msg) + strlen(field_name) + strlen(loader1) + |
580 strlen(sel) + strlen(loader2) + strlen(failed_type_name); | 579 strlen(sel) + strlen(loader2) + strlen(failed_type_name); |
587 } | 586 } |
588 | 587 |
589 // return information. note that the klass is set to the actual klass containing the | 588 // return information. note that the klass is set to the actual klass containing the |
590 // field, otherwise access of static fields in superclasses will not work. | 589 // field, otherwise access of static fields in superclasses will not work. |
591 KlassHandle holder (THREAD, fd.field_holder()); | 590 KlassHandle holder (THREAD, fd.field_holder()); |
592 symbolHandle name (THREAD, fd.name()); | 591 Symbol* name = fd.name(); |
593 result.set(holder, name, fd.index(), fd.offset(), fd.field_type(), fd.access_flags()); | 592 result.set(holder, name, fd.index(), fd.offset(), fd.field_type(), fd.access_flags()); |
594 } | 593 } |
595 | 594 |
596 | 595 |
597 //------------------------------------------------------------------------------------------------------------------------ | 596 //------------------------------------------------------------------------------------------------------------------------ |
603 // sel_method the selected method (selected via run-time lookup; e.g., based on dynamic receiver class) | 602 // sel_method the selected method (selected via run-time lookup; e.g., based on dynamic receiver class) |
604 // resolved_klass the specified klass (i.e., specified via constant pool index) | 603 // resolved_klass the specified klass (i.e., specified via constant pool index) |
605 // recv_klass the receiver klass | 604 // recv_klass the receiver klass |
606 | 605 |
607 | 606 |
608 void LinkResolver::resolve_static_call(CallInfo& result, KlassHandle& resolved_klass, symbolHandle method_name, | 607 void LinkResolver::resolve_static_call(CallInfo& result, KlassHandle& resolved_klass, Symbol* method_name, |
609 symbolHandle method_signature, KlassHandle current_klass, | 608 Symbol* method_signature, KlassHandle current_klass, |
610 bool check_access, bool initialize_class, TRAPS) { | 609 bool check_access, bool initialize_class, TRAPS) { |
611 methodHandle resolved_method; | 610 methodHandle resolved_method; |
612 linktime_resolve_static_method(resolved_method, resolved_klass, method_name, method_signature, current_klass, check_access, CHECK); | 611 linktime_resolve_static_method(resolved_method, resolved_klass, method_name, method_signature, current_klass, check_access, CHECK); |
613 resolved_klass = KlassHandle(THREAD, Klass::cast(resolved_method->method_holder())); | 612 resolved_klass = KlassHandle(THREAD, Klass::cast(resolved_method->method_holder())); |
614 | 613 |
622 result.set_static(resolved_klass, resolved_method, CHECK); | 621 result.set_static(resolved_klass, resolved_method, CHECK); |
623 } | 622 } |
624 | 623 |
625 // throws linktime exceptions | 624 // throws linktime exceptions |
626 void LinkResolver::linktime_resolve_static_method(methodHandle& resolved_method, KlassHandle resolved_klass, | 625 void LinkResolver::linktime_resolve_static_method(methodHandle& resolved_method, KlassHandle resolved_klass, |
627 symbolHandle method_name, symbolHandle method_signature, | 626 Symbol* method_name, Symbol* method_signature, |
628 KlassHandle current_klass, bool check_access, TRAPS) { | 627 KlassHandle current_klass, bool check_access, TRAPS) { |
629 | 628 |
630 resolve_method(resolved_method, resolved_klass, method_name, method_signature, current_klass, check_access, CHECK); | 629 resolve_method(resolved_method, resolved_klass, method_name, method_signature, current_klass, check_access, CHECK); |
631 assert(resolved_method->name() != vmSymbols::class_initializer_name(), "should have been checked in verifier"); | 630 assert(resolved_method->name() != vmSymbols::class_initializer_name(), "should have been checked in verifier"); |
632 | 631 |
639 THROW_MSG(vmSymbols::java_lang_IncompatibleClassChangeError(), buf); | 638 THROW_MSG(vmSymbols::java_lang_IncompatibleClassChangeError(), buf); |
640 } | 639 } |
641 } | 640 } |
642 | 641 |
643 | 642 |
644 void LinkResolver::resolve_special_call(CallInfo& result, KlassHandle resolved_klass, symbolHandle method_name, | 643 void LinkResolver::resolve_special_call(CallInfo& result, KlassHandle resolved_klass, Symbol* method_name, |
645 symbolHandle method_signature, KlassHandle current_klass, bool check_access, TRAPS) { | 644 Symbol* method_signature, KlassHandle current_klass, bool check_access, TRAPS) { |
646 methodHandle resolved_method; | 645 methodHandle resolved_method; |
647 linktime_resolve_special_method(resolved_method, resolved_klass, method_name, method_signature, current_klass, check_access, CHECK); | 646 linktime_resolve_special_method(resolved_method, resolved_klass, method_name, method_signature, current_klass, check_access, CHECK); |
648 runtime_resolve_special_method(result, resolved_method, resolved_klass, current_klass, check_access, CHECK); | 647 runtime_resolve_special_method(result, resolved_method, resolved_klass, current_klass, check_access, CHECK); |
649 } | 648 } |
650 | 649 |
651 // throws linktime exceptions | 650 // throws linktime exceptions |
652 void LinkResolver::linktime_resolve_special_method(methodHandle& resolved_method, KlassHandle resolved_klass, | 651 void LinkResolver::linktime_resolve_special_method(methodHandle& resolved_method, KlassHandle resolved_klass, |
653 symbolHandle method_name, symbolHandle method_signature, | 652 Symbol* method_name, Symbol* method_signature, |
654 KlassHandle current_klass, bool check_access, TRAPS) { | 653 KlassHandle current_klass, bool check_access, TRAPS) { |
655 | 654 |
656 resolve_method(resolved_method, resolved_klass, method_name, method_signature, current_klass, check_access, CHECK); | 655 resolve_method(resolved_method, resolved_klass, method_name, method_signature, current_klass, check_access, CHECK); |
657 | 656 |
658 // check if method name is <init>, that it is found in same klass as static type | 657 // check if method name is <init>, that it is found in same klass as static type |
659 if (resolved_method->name() == vmSymbols::object_initializer_name() && | 658 if (resolved_method->name() == vmSymbols::object_initializer_name() && |
660 resolved_method->method_holder() != resolved_klass()) { | 659 resolved_method->method_holder() != resolved_klass()) { |
661 ResourceMark rm(THREAD); | 660 ResourceMark rm(THREAD); |
662 Exceptions::fthrow( | 661 Exceptions::fthrow( |
663 THREAD_AND_LOCATION, | 662 THREAD_AND_LOCATION, |
664 vmSymbolHandles::java_lang_NoSuchMethodError(), | 663 vmSymbols::java_lang_NoSuchMethodError(), |
665 "%s: method %s%s not found", | 664 "%s: method %s%s not found", |
666 resolved_klass->external_name(), | 665 resolved_klass->external_name(), |
667 resolved_method->name()->as_C_string(), | 666 resolved_method->name()->as_C_string(), |
668 resolved_method->signature()->as_C_string() | 667 resolved_method->signature()->as_C_string() |
669 ); | 668 ); |
701 // c) check if the method is not <init> | 700 // c) check if the method is not <init> |
702 resolved_method->name() != vmSymbols::object_initializer_name()) { | 701 resolved_method->name() != vmSymbols::object_initializer_name()) { |
703 // Lookup super method | 702 // Lookup super method |
704 KlassHandle super_klass(THREAD, current_klass->super()); | 703 KlassHandle super_klass(THREAD, current_klass->super()); |
705 lookup_instance_method_in_klasses(sel_method, super_klass, | 704 lookup_instance_method_in_klasses(sel_method, super_klass, |
706 symbolHandle(THREAD, resolved_method->name()), | 705 resolved_method->name(), |
707 symbolHandle(THREAD, resolved_method->signature()), CHECK); | 706 resolved_method->signature(), CHECK); |
708 // check if found | 707 // check if found |
709 if (sel_method.is_null()) { | 708 if (sel_method.is_null()) { |
710 ResourceMark rm(THREAD); | 709 ResourceMark rm(THREAD); |
711 THROW_MSG(vmSymbols::java_lang_AbstractMethodError(), | 710 THROW_MSG(vmSymbols::java_lang_AbstractMethodError(), |
712 methodOopDesc::name_and_sig_as_C_string(Klass::cast(resolved_klass()), | 711 methodOopDesc::name_and_sig_as_C_string(Klass::cast(resolved_klass()), |
737 // setup result | 736 // setup result |
738 result.set_static(resolved_klass, sel_method, CHECK); | 737 result.set_static(resolved_klass, sel_method, CHECK); |
739 } | 738 } |
740 | 739 |
741 void LinkResolver::resolve_virtual_call(CallInfo& result, Handle recv, KlassHandle receiver_klass, KlassHandle resolved_klass, | 740 void LinkResolver::resolve_virtual_call(CallInfo& result, Handle recv, KlassHandle receiver_klass, KlassHandle resolved_klass, |
742 symbolHandle method_name, symbolHandle method_signature, KlassHandle current_klass, | 741 Symbol* method_name, Symbol* method_signature, KlassHandle current_klass, |
743 bool check_access, bool check_null_and_abstract, TRAPS) { | 742 bool check_access, bool check_null_and_abstract, TRAPS) { |
744 methodHandle resolved_method; | 743 methodHandle resolved_method; |
745 linktime_resolve_virtual_method(resolved_method, resolved_klass, method_name, method_signature, current_klass, check_access, CHECK); | 744 linktime_resolve_virtual_method(resolved_method, resolved_klass, method_name, method_signature, current_klass, check_access, CHECK); |
746 runtime_resolve_virtual_method(result, resolved_method, resolved_klass, recv, receiver_klass, check_null_and_abstract, CHECK); | 745 runtime_resolve_virtual_method(result, resolved_method, resolved_klass, recv, receiver_klass, check_null_and_abstract, CHECK); |
747 } | 746 } |
748 | 747 |
749 // throws linktime exceptions | 748 // throws linktime exceptions |
750 void LinkResolver::linktime_resolve_virtual_method(methodHandle &resolved_method, KlassHandle resolved_klass, | 749 void LinkResolver::linktime_resolve_virtual_method(methodHandle &resolved_method, KlassHandle resolved_klass, |
751 symbolHandle method_name, symbolHandle method_signature, | 750 Symbol* method_name, Symbol* method_signature, |
752 KlassHandle current_klass, bool check_access, TRAPS) { | 751 KlassHandle current_klass, bool check_access, TRAPS) { |
753 // normal method resolution | 752 // normal method resolution |
754 resolve_method(resolved_method, resolved_klass, method_name, method_signature, current_klass, check_access, CHECK); | 753 resolve_method(resolved_method, resolved_klass, method_name, method_signature, current_klass, check_access, CHECK); |
755 | 754 |
756 assert(resolved_method->name() != vmSymbols::object_initializer_name(), "should have been checked in verifier"); | 755 assert(resolved_method->name() != vmSymbols::object_initializer_name(), "should have been checked in verifier"); |
796 assert(instanceKlass::cast(resolved_method->method_holder())->is_linked(), "must be linked"); | 795 assert(instanceKlass::cast(resolved_method->method_holder())->is_linked(), "must be linked"); |
797 | 796 |
798 // do lookup based on receiver klass using the vtable index | 797 // do lookup based on receiver klass using the vtable index |
799 if (resolved_method->method_holder()->klass_part()->is_interface()) { // miranda method | 798 if (resolved_method->method_holder()->klass_part()->is_interface()) { // miranda method |
800 vtable_index = vtable_index_of_miranda_method(resolved_klass, | 799 vtable_index = vtable_index_of_miranda_method(resolved_klass, |
801 symbolHandle(THREAD, resolved_method->name()), | 800 resolved_method->name(), |
802 symbolHandle(THREAD, resolved_method->signature()), CHECK); | 801 resolved_method->signature(), CHECK); |
803 assert(vtable_index >= 0 , "we should have valid vtable index at this point"); | 802 assert(vtable_index >= 0 , "we should have valid vtable index at this point"); |
804 | 803 |
805 instanceKlass* inst = instanceKlass::cast(recv_klass()); | 804 instanceKlass* inst = instanceKlass::cast(recv_klass()); |
806 selected_method = methodHandle(THREAD, inst->method_at_vtable(vtable_index)); | 805 selected_method = methodHandle(THREAD, inst->method_at_vtable(vtable_index)); |
807 } else { | 806 } else { |
845 // setup result | 844 // setup result |
846 result.set_virtual(resolved_klass, recv_klass, resolved_method, selected_method, vtable_index, CHECK); | 845 result.set_virtual(resolved_klass, recv_klass, resolved_method, selected_method, vtable_index, CHECK); |
847 } | 846 } |
848 | 847 |
849 void LinkResolver::resolve_interface_call(CallInfo& result, Handle recv, KlassHandle recv_klass, KlassHandle resolved_klass, | 848 void LinkResolver::resolve_interface_call(CallInfo& result, Handle recv, KlassHandle recv_klass, KlassHandle resolved_klass, |
850 symbolHandle method_name, symbolHandle method_signature, KlassHandle current_klass, | 849 Symbol* method_name, Symbol* method_signature, KlassHandle current_klass, |
851 bool check_access, bool check_null_and_abstract, TRAPS) { | 850 bool check_access, bool check_null_and_abstract, TRAPS) { |
852 methodHandle resolved_method; | 851 methodHandle resolved_method; |
853 linktime_resolve_interface_method(resolved_method, resolved_klass, method_name, method_signature, current_klass, check_access, CHECK); | 852 linktime_resolve_interface_method(resolved_method, resolved_klass, method_name, method_signature, current_klass, check_access, CHECK); |
854 runtime_resolve_interface_method(result, resolved_method, resolved_klass, recv, recv_klass, check_null_and_abstract, CHECK); | 853 runtime_resolve_interface_method(result, resolved_method, resolved_klass, recv, recv_klass, check_null_and_abstract, CHECK); |
855 } | 854 } |
856 | 855 |
857 // throws linktime exceptions | 856 // throws linktime exceptions |
858 void LinkResolver::linktime_resolve_interface_method(methodHandle& resolved_method, KlassHandle resolved_klass, symbolHandle method_name, | 857 void LinkResolver::linktime_resolve_interface_method(methodHandle& resolved_method, KlassHandle resolved_klass, Symbol* method_name, |
859 symbolHandle method_signature, KlassHandle current_klass, bool check_access, TRAPS) { | 858 Symbol* method_signature, KlassHandle current_klass, bool check_access, TRAPS) { |
860 // normal interface method resolution | 859 // normal interface method resolution |
861 resolve_interface_method(resolved_method, resolved_klass, method_name, method_signature, current_klass, check_access, CHECK); | 860 resolve_interface_method(resolved_method, resolved_klass, method_name, method_signature, current_klass, check_access, CHECK); |
862 | 861 |
863 assert(resolved_method->name() != vmSymbols::object_initializer_name(), "should have been checked in verifier"); | 862 assert(resolved_method->name() != vmSymbols::object_initializer_name(), "should have been checked in verifier"); |
864 assert(resolved_method->name() != vmSymbols::class_initializer_name (), "should have been checked in verifier"); | 863 assert(resolved_method->name() != vmSymbols::class_initializer_name (), "should have been checked in verifier"); |
881 THROW_MSG(vmSymbols::java_lang_IncompatibleClassChangeError(), buf); | 880 THROW_MSG(vmSymbols::java_lang_IncompatibleClassChangeError(), buf); |
882 } | 881 } |
883 // do lookup based on receiver klass | 882 // do lookup based on receiver klass |
884 methodHandle sel_method; | 883 methodHandle sel_method; |
885 lookup_instance_method_in_klasses(sel_method, recv_klass, | 884 lookup_instance_method_in_klasses(sel_method, recv_klass, |
886 symbolHandle(THREAD, resolved_method->name()), | 885 resolved_method->name(), |
887 symbolHandle(THREAD, resolved_method->signature()), CHECK); | 886 resolved_method->signature(), CHECK); |
888 // check if method exists | 887 // check if method exists |
889 if (sel_method.is_null()) { | 888 if (sel_method.is_null()) { |
890 ResourceMark rm(THREAD); | 889 ResourceMark rm(THREAD); |
891 THROW_MSG(vmSymbols::java_lang_AbstractMethodError(), | 890 THROW_MSG(vmSymbols::java_lang_AbstractMethodError(), |
892 methodOopDesc::name_and_sig_as_C_string(Klass::cast(recv_klass()), | 891 methodOopDesc::name_and_sig_as_C_string(Klass::cast(recv_klass()), |
914 } | 913 } |
915 | 914 |
916 | 915 |
917 methodHandle LinkResolver::linktime_resolve_interface_method_or_null( | 916 methodHandle LinkResolver::linktime_resolve_interface_method_or_null( |
918 KlassHandle resolved_klass, | 917 KlassHandle resolved_klass, |
919 symbolHandle method_name, | 918 Symbol* method_name, |
920 symbolHandle method_signature, | 919 Symbol* method_signature, |
921 KlassHandle current_klass, | 920 KlassHandle current_klass, |
922 bool check_access) { | 921 bool check_access) { |
923 EXCEPTION_MARK; | 922 EXCEPTION_MARK; |
924 methodHandle method_result; | 923 methodHandle method_result; |
925 linktime_resolve_interface_method(method_result, resolved_klass, method_name, method_signature, current_klass, check_access, THREAD); | 924 linktime_resolve_interface_method(method_result, resolved_klass, method_name, method_signature, current_klass, check_access, THREAD); |
931 } | 930 } |
932 } | 931 } |
933 | 932 |
934 methodHandle LinkResolver::linktime_resolve_virtual_method_or_null( | 933 methodHandle LinkResolver::linktime_resolve_virtual_method_or_null( |
935 KlassHandle resolved_klass, | 934 KlassHandle resolved_klass, |
936 symbolHandle method_name, | 935 Symbol* method_name, |
937 symbolHandle method_signature, | 936 Symbol* method_signature, |
938 KlassHandle current_klass, | 937 KlassHandle current_klass, |
939 bool check_access) { | 938 bool check_access) { |
940 EXCEPTION_MARK; | 939 EXCEPTION_MARK; |
941 methodHandle method_result; | 940 methodHandle method_result; |
942 linktime_resolve_virtual_method(method_result, resolved_klass, method_name, method_signature, current_klass, check_access, THREAD); | 941 linktime_resolve_virtual_method(method_result, resolved_klass, method_name, method_signature, current_klass, check_access, THREAD); |
949 } | 948 } |
950 | 949 |
951 methodHandle LinkResolver::resolve_virtual_call_or_null( | 950 methodHandle LinkResolver::resolve_virtual_call_or_null( |
952 KlassHandle receiver_klass, | 951 KlassHandle receiver_klass, |
953 KlassHandle resolved_klass, | 952 KlassHandle resolved_klass, |
954 symbolHandle name, | 953 Symbol* name, |
955 symbolHandle signature, | 954 Symbol* signature, |
956 KlassHandle current_klass) { | 955 KlassHandle current_klass) { |
957 EXCEPTION_MARK; | 956 EXCEPTION_MARK; |
958 CallInfo info; | 957 CallInfo info; |
959 resolve_virtual_call(info, Handle(), receiver_klass, resolved_klass, name, signature, current_klass, true, false, THREAD); | 958 resolve_virtual_call(info, Handle(), receiver_klass, resolved_klass, name, signature, current_klass, true, false, THREAD); |
960 if (HAS_PENDING_EXCEPTION) { | 959 if (HAS_PENDING_EXCEPTION) { |
965 } | 964 } |
966 | 965 |
967 methodHandle LinkResolver::resolve_interface_call_or_null( | 966 methodHandle LinkResolver::resolve_interface_call_or_null( |
968 KlassHandle receiver_klass, | 967 KlassHandle receiver_klass, |
969 KlassHandle resolved_klass, | 968 KlassHandle resolved_klass, |
970 symbolHandle name, | 969 Symbol* name, |
971 symbolHandle signature, | 970 Symbol* signature, |
972 KlassHandle current_klass) { | 971 KlassHandle current_klass) { |
973 EXCEPTION_MARK; | 972 EXCEPTION_MARK; |
974 CallInfo info; | 973 CallInfo info; |
975 resolve_interface_call(info, Handle(), receiver_klass, resolved_klass, name, signature, current_klass, true, false, THREAD); | 974 resolve_interface_call(info, Handle(), receiver_klass, resolved_klass, name, signature, current_klass, true, false, THREAD); |
976 if (HAS_PENDING_EXCEPTION) { | 975 if (HAS_PENDING_EXCEPTION) { |
981 } | 980 } |
982 | 981 |
983 int LinkResolver::resolve_virtual_vtable_index( | 982 int LinkResolver::resolve_virtual_vtable_index( |
984 KlassHandle receiver_klass, | 983 KlassHandle receiver_klass, |
985 KlassHandle resolved_klass, | 984 KlassHandle resolved_klass, |
986 symbolHandle name, | 985 Symbol* name, |
987 symbolHandle signature, | 986 Symbol* signature, |
988 KlassHandle current_klass) { | 987 KlassHandle current_klass) { |
989 EXCEPTION_MARK; | 988 EXCEPTION_MARK; |
990 CallInfo info; | 989 CallInfo info; |
991 resolve_virtual_call(info, Handle(), receiver_klass, resolved_klass, name, signature, current_klass, true, false, THREAD); | 990 resolve_virtual_call(info, Handle(), receiver_klass, resolved_klass, name, signature, current_klass, true, false, THREAD); |
992 if (HAS_PENDING_EXCEPTION) { | 991 if (HAS_PENDING_EXCEPTION) { |
996 return info.vtable_index(); | 995 return info.vtable_index(); |
997 } | 996 } |
998 | 997 |
999 methodHandle LinkResolver::resolve_static_call_or_null( | 998 methodHandle LinkResolver::resolve_static_call_or_null( |
1000 KlassHandle resolved_klass, | 999 KlassHandle resolved_klass, |
1001 symbolHandle name, | 1000 Symbol* name, |
1002 symbolHandle signature, | 1001 Symbol* signature, |
1003 KlassHandle current_klass) { | 1002 KlassHandle current_klass) { |
1004 EXCEPTION_MARK; | 1003 EXCEPTION_MARK; |
1005 CallInfo info; | 1004 CallInfo info; |
1006 resolve_static_call(info, resolved_klass, name, signature, current_klass, true, false, THREAD); | 1005 resolve_static_call(info, resolved_klass, name, signature, current_klass, true, false, THREAD); |
1007 if (HAS_PENDING_EXCEPTION) { | 1006 if (HAS_PENDING_EXCEPTION) { |
1009 return methodHandle(); | 1008 return methodHandle(); |
1010 } | 1009 } |
1011 return info.selected_method(); | 1010 return info.selected_method(); |
1012 } | 1011 } |
1013 | 1012 |
1014 methodHandle LinkResolver::resolve_special_call_or_null(KlassHandle resolved_klass, symbolHandle name, symbolHandle signature, | 1013 methodHandle LinkResolver::resolve_special_call_or_null(KlassHandle resolved_klass, Symbol* name, Symbol* signature, |
1015 KlassHandle current_klass) { | 1014 KlassHandle current_klass) { |
1016 EXCEPTION_MARK; | 1015 EXCEPTION_MARK; |
1017 CallInfo info; | 1016 CallInfo info; |
1018 resolve_special_call(info, resolved_klass, name, signature, current_klass, true, THREAD); | 1017 resolve_special_call(info, resolved_klass, name, signature, current_klass, true, THREAD); |
1019 if (HAS_PENDING_EXCEPTION) { | 1018 if (HAS_PENDING_EXCEPTION) { |
1037 case Bytecodes::_invokeinterface: resolve_invokeinterface(result, recv, pool, index, CHECK); break; | 1036 case Bytecodes::_invokeinterface: resolve_invokeinterface(result, recv, pool, index, CHECK); break; |
1038 } | 1037 } |
1039 return; | 1038 return; |
1040 } | 1039 } |
1041 | 1040 |
1042 void LinkResolver::resolve_pool(KlassHandle& resolved_klass, symbolHandle& method_name, symbolHandle& method_signature, | 1041 void LinkResolver::resolve_pool(KlassHandle& resolved_klass, Symbol*& method_name, Symbol*& method_signature, |
1043 KlassHandle& current_klass, constantPoolHandle pool, int index, TRAPS) { | 1042 KlassHandle& current_klass, constantPoolHandle pool, int index, TRAPS) { |
1044 // resolve klass | 1043 // resolve klass |
1045 resolve_klass(resolved_klass, pool, index, CHECK); | 1044 resolve_klass(resolved_klass, pool, index, CHECK); |
1046 | 1045 |
1047 // Get name, signature, and static klass | 1046 // Get name, signature, and static klass |
1048 method_name = symbolHandle(THREAD, pool->name_ref_at(index)); | 1047 method_name = pool->name_ref_at(index); |
1049 method_signature = symbolHandle(THREAD, pool->signature_ref_at(index)); | 1048 method_signature = pool->signature_ref_at(index); |
1050 current_klass = KlassHandle(THREAD, pool->pool_holder()); | 1049 current_klass = KlassHandle(THREAD, pool->pool_holder()); |
1051 } | 1050 } |
1052 | 1051 |
1053 | 1052 |
1054 void LinkResolver::resolve_invokestatic(CallInfo& result, constantPoolHandle pool, int index, TRAPS) { | 1053 void LinkResolver::resolve_invokestatic(CallInfo& result, constantPoolHandle pool, int index, TRAPS) { |
1055 KlassHandle resolved_klass; | 1054 KlassHandle resolved_klass; |
1056 symbolHandle method_name; | 1055 Symbol* method_name = NULL; |
1057 symbolHandle method_signature; | 1056 Symbol* method_signature = NULL; |
1058 KlassHandle current_klass; | 1057 KlassHandle current_klass; |
1059 resolve_pool(resolved_klass, method_name, method_signature, current_klass, pool, index, CHECK); | 1058 resolve_pool(resolved_klass, method_name, method_signature, current_klass, pool, index, CHECK); |
1060 resolve_static_call(result, resolved_klass, method_name, method_signature, current_klass, true, true, CHECK); | 1059 resolve_static_call(result, resolved_klass, method_name, method_signature, current_klass, true, true, CHECK); |
1061 } | 1060 } |
1062 | 1061 |
1063 | 1062 |
1064 void LinkResolver::resolve_invokespecial(CallInfo& result, constantPoolHandle pool, int index, TRAPS) { | 1063 void LinkResolver::resolve_invokespecial(CallInfo& result, constantPoolHandle pool, int index, TRAPS) { |
1065 KlassHandle resolved_klass; | 1064 KlassHandle resolved_klass; |
1066 symbolHandle method_name; | 1065 Symbol* method_name = NULL; |
1067 symbolHandle method_signature; | 1066 Symbol* method_signature = NULL; |
1068 KlassHandle current_klass; | 1067 KlassHandle current_klass; |
1069 resolve_pool(resolved_klass, method_name, method_signature, current_klass, pool, index, CHECK); | 1068 resolve_pool(resolved_klass, method_name, method_signature, current_klass, pool, index, CHECK); |
1070 resolve_special_call(result, resolved_klass, method_name, method_signature, current_klass, true, CHECK); | 1069 resolve_special_call(result, resolved_klass, method_name, method_signature, current_klass, true, CHECK); |
1071 } | 1070 } |
1072 | 1071 |
1074 void LinkResolver::resolve_invokevirtual(CallInfo& result, Handle recv, | 1073 void LinkResolver::resolve_invokevirtual(CallInfo& result, Handle recv, |
1075 constantPoolHandle pool, int index, | 1074 constantPoolHandle pool, int index, |
1076 TRAPS) { | 1075 TRAPS) { |
1077 | 1076 |
1078 KlassHandle resolved_klass; | 1077 KlassHandle resolved_klass; |
1079 symbolHandle method_name; | 1078 Symbol* method_name = NULL; |
1080 symbolHandle method_signature; | 1079 Symbol* method_signature = NULL; |
1081 KlassHandle current_klass; | 1080 KlassHandle current_klass; |
1082 resolve_pool(resolved_klass, method_name, method_signature, current_klass, pool, index, CHECK); | 1081 resolve_pool(resolved_klass, method_name, method_signature, current_klass, pool, index, CHECK); |
1083 KlassHandle recvrKlass (THREAD, recv.is_null() ? (klassOop)NULL : recv->klass()); | 1082 KlassHandle recvrKlass (THREAD, recv.is_null() ? (klassOop)NULL : recv->klass()); |
1084 resolve_virtual_call(result, recv, recvrKlass, resolved_klass, method_name, method_signature, current_klass, true, true, CHECK); | 1083 resolve_virtual_call(result, recv, recvrKlass, resolved_klass, method_name, method_signature, current_klass, true, true, CHECK); |
1085 } | 1084 } |
1086 | 1085 |
1087 | 1086 |
1088 void LinkResolver::resolve_invokeinterface(CallInfo& result, Handle recv, constantPoolHandle pool, int index, TRAPS) { | 1087 void LinkResolver::resolve_invokeinterface(CallInfo& result, Handle recv, constantPoolHandle pool, int index, TRAPS) { |
1089 KlassHandle resolved_klass; | 1088 KlassHandle resolved_klass; |
1090 symbolHandle method_name; | 1089 Symbol* method_name = NULL; |
1091 symbolHandle method_signature; | 1090 Symbol* method_signature = NULL; |
1092 KlassHandle current_klass; | 1091 KlassHandle current_klass; |
1093 resolve_pool(resolved_klass, method_name, method_signature, current_klass, pool, index, CHECK); | 1092 resolve_pool(resolved_klass, method_name, method_signature, current_klass, pool, index, CHECK); |
1094 KlassHandle recvrKlass (THREAD, recv.is_null() ? (klassOop)NULL : recv->klass()); | 1093 KlassHandle recvrKlass (THREAD, recv.is_null() ? (klassOop)NULL : recv->klass()); |
1095 resolve_interface_call(result, recv, recvrKlass, resolved_klass, method_name, method_signature, current_klass, true, true, CHECK); | 1094 resolve_interface_call(result, recv, recvrKlass, resolved_klass, method_name, method_signature, current_klass, true, true, CHECK); |
1096 } | 1095 } |
1100 assert(EnableInvokeDynamic, ""); | 1099 assert(EnableInvokeDynamic, ""); |
1101 | 1100 |
1102 // This guy is reached from InterpreterRuntime::resolve_invokedynamic. | 1101 // This guy is reached from InterpreterRuntime::resolve_invokedynamic. |
1103 | 1102 |
1104 // At this point, we only need the signature, and can ignore the name. | 1103 // At this point, we only need the signature, and can ignore the name. |
1105 symbolHandle method_signature(THREAD, pool->signature_ref_at(raw_index)); // raw_index works directly | 1104 Symbol* method_signature = pool->signature_ref_at(raw_index); // raw_index works directly |
1106 symbolHandle method_name = vmSymbolHandles::invokeExact_name(); | 1105 Symbol* method_name = vmSymbols::invokeExact_name(); |
1107 KlassHandle resolved_klass = SystemDictionaryHandles::MethodHandle_klass(); | 1106 KlassHandle resolved_klass = SystemDictionaryHandles::MethodHandle_klass(); |
1108 | 1107 |
1109 // JSR 292: this must be an implicitly generated method MethodHandle.invokeExact(*...) | 1108 // JSR 292: this must be an implicitly generated method MethodHandle.invokeExact(*...) |
1110 // The extra MH receiver will be inserted into the stack on every call. | 1109 // The extra MH receiver will be inserted into the stack on every call. |
1111 methodHandle resolved_method; | 1110 methodHandle resolved_method; |