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