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