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