47 #include "oops/objArrayKlass.hpp"
48 #include "oops/objArrayOop.hpp"
49 #include "oops/oop.inline.hpp"
50 #include "prims/methodHandles.hpp"
51 #include "prims/nativeLookup.hpp"
52 #include "runtime/fieldDescriptor.inline.hpp"
53 #include "runtime/frame.inline.hpp"
54 #include "runtime/handles.inline.hpp"
55 #include "runtime/reflection.hpp"
56 #include "runtime/safepointVerifiers.hpp"
57 #include "runtime/signature.hpp"
58 #include "runtime/thread.inline.hpp"
59 #include "runtime/vmThread.hpp"
60
61 //------------------------------------------------------------------------------------------------------------------------
62 // Implementation of CallInfo
63
64
65 void CallInfo::set_static(Klass* resolved_klass, const methodHandle& resolved_method, TRAPS) {
66 int vtable_index = Method::nonvirtual_vtable_index;
67 set_common(resolved_klass, resolved_klass, resolved_method, resolved_method, CallInfo::direct_call, vtable_index, CHECK);
68 }
69
70
71 void CallInfo::set_interface(Klass* resolved_klass,
72 Klass* selected_klass,
73 const methodHandle& resolved_method,
74 const methodHandle& selected_method,
75 int itable_index, TRAPS) {
76 // This is only called for interface methods. If the resolved_method
77 // comes from java/lang/Object, it can be the subject of a virtual call, so
78 // we should pick the vtable index from the resolved method.
79 // In that case, the caller must call set_virtual instead of set_interface.
80 assert(resolved_method->method_holder()->is_interface(), "");
81 assert(itable_index == resolved_method()->itable_index(), "");
82 set_common(resolved_klass, selected_klass, resolved_method, selected_method, CallInfo::itable_call, itable_index, CHECK);
83 }
84
85 void CallInfo::set_virtual(Klass* resolved_klass,
86 Klass* selected_klass,
87 const methodHandle& resolved_method,
88 const methodHandle& selected_method,
89 int vtable_index, TRAPS) {
90 assert(vtable_index >= 0 || vtable_index == Method::nonvirtual_vtable_index, "valid index");
91 assert(vtable_index < 0 || !resolved_method->has_vtable_index() || vtable_index == resolved_method->vtable_index(), "");
92 CallKind kind = (vtable_index >= 0 && !resolved_method->can_be_statically_bound() ? CallInfo::vtable_call : CallInfo::direct_call);
93 set_common(resolved_klass, selected_klass, resolved_method, selected_method, kind, vtable_index, CHECK);
94 assert(!resolved_method->is_compiled_lambda_form(), "these must be handled via an invokehandle call");
95 }
96
97 void CallInfo::set_handle(const methodHandle& resolved_method,
98 Handle resolved_appendix, TRAPS) {
99 set_handle(SystemDictionary::MethodHandle_klass(), resolved_method, resolved_appendix, CHECK);
100 }
101
102 void CallInfo::set_handle(Klass* resolved_klass,
103 const methodHandle& resolved_method,
104 Handle resolved_appendix, TRAPS) {
105 guarantee(resolved_method.not_null(), "resolved method is null");
106 assert(resolved_method->intrinsic_id() == vmIntrinsics::_invokeBasic ||
107 resolved_method->is_compiled_lambda_form(),
108 "linkMethod must return one of these");
109 int vtable_index = Method::nonvirtual_vtable_index;
110 assert(!resolved_method->has_vtable_index(), "");
111 set_common(resolved_klass, resolved_klass, resolved_method, resolved_method, CallInfo::direct_call, vtable_index, CHECK);
112 _resolved_appendix = resolved_appendix;
113 }
114
115 void CallInfo::set_common(Klass* resolved_klass,
116 Klass* selected_klass,
117 const methodHandle& resolved_method,
118 const methodHandle& selected_method,
119 CallKind kind,
120 int index,
121 TRAPS) {
122 assert(resolved_method->signature() == selected_method->signature(), "signatures must correspond");
123 _resolved_klass = resolved_klass;
124 _selected_klass = selected_klass;
125 _resolved_method = resolved_method;
126 _selected_method = selected_method;
127 _call_kind = kind;
128 _call_index = index;
129 _resolved_appendix = Handle();
130 DEBUG_ONLY(verify()); // verify before making side effects
131
132 CompilationPolicy::compile_if_required(selected_method, THREAD);
133 }
134
135 // utility query for unreflecting a method
136 CallInfo::CallInfo(Method* resolved_method, Klass* resolved_klass, TRAPS) {
137 Klass* resolved_method_holder = resolved_method->method_holder();
138 if (resolved_klass == NULL) { // 2nd argument defaults to holder of 1st
139 resolved_klass = resolved_method_holder;
140 }
141 _resolved_klass = resolved_klass;
142 _selected_klass = resolved_klass;
143 _resolved_method = methodHandle(THREAD, resolved_method);
144 _selected_method = methodHandle(THREAD, resolved_method);
145 // classify:
146 CallKind kind = CallInfo::unknown_kind;
147 int index = resolved_method->vtable_index();
148 if (resolved_method->can_be_statically_bound()) {
149 kind = CallInfo::direct_call;
150 } else if (!resolved_method_holder->is_interface()) {
151 // Could be an Object method inherited into an interface, but still a vtable call.
152 kind = CallInfo::vtable_call;
153 } else if (!resolved_klass->is_interface()) {
154 // A default or miranda method. Compute the vtable index.
155 index = LinkResolver::vtable_index_of_interface_method(resolved_klass,
156 _resolved_method);
157 assert(index >= 0 , "we should have valid vtable index at this point");
158
159 kind = CallInfo::vtable_call;
160 } else if (resolved_method->has_vtable_index()) {
161 // Can occur if an interface redeclares a method of Object.
162
1380 }
1381 }
1382
1383 // check if method exists
1384 if (selected_method.is_null()) {
1385 throw_abstract_method_error(resolved_method, recv_klass, CHECK);
1386 }
1387
1388 // check if abstract
1389 if (check_null_and_abstract && selected_method->is_abstract()) {
1390 // Pass arguments for generating a verbose error message.
1391 throw_abstract_method_error(resolved_method, selected_method, recv_klass, CHECK);
1392 }
1393
1394 if (log_develop_is_enabled(Trace, vtables)) {
1395 trace_method_resolution("invokevirtual selected method: receiver-class:",
1396 recv_klass, resolved_klass, selected_method(),
1397 false, vtable_index);
1398 }
1399 // setup result
1400 result.set_virtual(resolved_klass, recv_klass, resolved_method, selected_method, vtable_index, CHECK);
1401 }
1402
1403 void LinkResolver::resolve_interface_call(CallInfo& result, Handle recv, Klass* recv_klass,
1404 const LinkInfo& link_info,
1405 bool check_null_and_abstract, TRAPS) {
1406 // throws linktime exceptions
1407 Method* resolved_method = linktime_resolve_interface_method(link_info, CHECK);
1408 methodHandle mh(THREAD, resolved_method);
1409 runtime_resolve_interface_method(result, mh, link_info.resolved_klass(),
1410 recv, recv_klass, check_null_and_abstract, CHECK);
1411 }
1412
1413 Method* LinkResolver::linktime_resolve_interface_method(const LinkInfo& link_info,
1414 TRAPS) {
1415 // normal interface method resolution
1416 Method* resolved_method = resolve_interface_method(link_info, Bytecodes::_invokeinterface, CHECK_NULL);
1417 assert(resolved_method->name() != vmSymbols::object_initializer_name(), "should have been checked in verifier");
1418 assert(resolved_method->name() != vmSymbols::class_initializer_name (), "should have been checked in verifier");
1419
1420 return resolved_method;
1476 ss.print("'");
1477 Method::print_external_name(&ss, recv_klass, selected_method->name(), selected_method->signature());
1478 ss.print("'");
1479 THROW_MSG(vmSymbols::java_lang_IllegalAccessError(), ss.as_string());
1480 }
1481 // check if abstract
1482 if (check_null_and_abstract && selected_method->is_abstract()) {
1483 throw_abstract_method_error(resolved_method, selected_method, recv_klass, CHECK);
1484 }
1485 }
1486
1487 if (log_develop_is_enabled(Trace, itables)) {
1488 trace_method_resolution("invokeinterface selected method: receiver-class:",
1489 recv_klass, resolved_klass, selected_method(), true);
1490 }
1491 // setup result
1492 if (resolved_method->has_vtable_index()) {
1493 int vtable_index = resolved_method->vtable_index();
1494 log_develop_trace(itables)(" -- vtable index: %d", vtable_index);
1495 assert(vtable_index == selected_method->vtable_index(), "sanity check");
1496 result.set_virtual(resolved_klass, recv_klass, resolved_method, selected_method, vtable_index, CHECK);
1497 } else if (resolved_method->has_itable_index()) {
1498 int itable_index = resolved_method()->itable_index();
1499 log_develop_trace(itables)(" -- itable index: %d", itable_index);
1500 result.set_interface(resolved_klass, recv_klass, resolved_method, selected_method, itable_index, CHECK);
1501 } else {
1502 int index = resolved_method->vtable_index();
1503 log_develop_trace(itables)(" -- non itable/vtable index: %d", index);
1504 assert(index == Method::nonvirtual_vtable_index, "Oops hit another case!");
1505 assert(resolved_method()->is_private() ||
1506 (resolved_method()->is_final() && resolved_method->method_holder() == SystemDictionary::Object_klass()),
1507 "Should only have non-virtual invokeinterface for private or final-Object methods!");
1508 assert(resolved_method()->can_be_statically_bound(), "Should only have non-virtual invokeinterface for statically bound methods!");
1509 // This sets up the nonvirtual form of "virtual" call (as needed for final and private methods)
1510 result.set_virtual(resolved_klass, resolved_klass, resolved_method, resolved_method, index, CHECK);
1511 }
1512 }
1513
1514
1515 Method* LinkResolver::linktime_resolve_interface_method_or_null(
1516 const LinkInfo& link_info) {
1517 EXCEPTION_MARK;
1518 Method* method_result = linktime_resolve_interface_method(link_info, THREAD);
1519 if (HAS_PENDING_EXCEPTION) {
1520 CLEAR_PENDING_EXCEPTION;
1521 return NULL;
1522 } else {
1523 return method_result;
1524 }
1525 }
1526
1527 Method* LinkResolver::linktime_resolve_virtual_method_or_null(
1528 const LinkInfo& link_info) {
1529 EXCEPTION_MARK;
1530 Method* method_result = linktime_resolve_virtual_method(link_info, THREAD);
|
47 #include "oops/objArrayKlass.hpp"
48 #include "oops/objArrayOop.hpp"
49 #include "oops/oop.inline.hpp"
50 #include "prims/methodHandles.hpp"
51 #include "prims/nativeLookup.hpp"
52 #include "runtime/fieldDescriptor.inline.hpp"
53 #include "runtime/frame.inline.hpp"
54 #include "runtime/handles.inline.hpp"
55 #include "runtime/reflection.hpp"
56 #include "runtime/safepointVerifiers.hpp"
57 #include "runtime/signature.hpp"
58 #include "runtime/thread.inline.hpp"
59 #include "runtime/vmThread.hpp"
60
61 //------------------------------------------------------------------------------------------------------------------------
62 // Implementation of CallInfo
63
64
65 void CallInfo::set_static(Klass* resolved_klass, const methodHandle& resolved_method, TRAPS) {
66 int vtable_index = Method::nonvirtual_vtable_index;
67 set_common(resolved_klass, resolved_method, resolved_method, CallInfo::direct_call, vtable_index, CHECK);
68 }
69
70
71 void CallInfo::set_interface(Klass* resolved_klass,
72 const methodHandle& resolved_method,
73 const methodHandle& selected_method,
74 int itable_index, TRAPS) {
75 // This is only called for interface methods. If the resolved_method
76 // comes from java/lang/Object, it can be the subject of a virtual call, so
77 // we should pick the vtable index from the resolved method.
78 // In that case, the caller must call set_virtual instead of set_interface.
79 assert(resolved_method->method_holder()->is_interface(), "");
80 assert(itable_index == resolved_method()->itable_index(), "");
81 set_common(resolved_klass, resolved_method, selected_method, CallInfo::itable_call, itable_index, CHECK);
82 }
83
84 void CallInfo::set_virtual(Klass* resolved_klass,
85 const methodHandle& resolved_method,
86 const methodHandle& selected_method,
87 int vtable_index, TRAPS) {
88 assert(vtable_index >= 0 || vtable_index == Method::nonvirtual_vtable_index, "valid index");
89 assert(vtable_index < 0 || !resolved_method->has_vtable_index() || vtable_index == resolved_method->vtable_index(), "");
90 CallKind kind = (vtable_index >= 0 && !resolved_method->can_be_statically_bound() ? CallInfo::vtable_call : CallInfo::direct_call);
91 set_common(resolved_klass, resolved_method, selected_method, kind, vtable_index, CHECK);
92 assert(!resolved_method->is_compiled_lambda_form(), "these must be handled via an invokehandle call");
93 }
94
95 void CallInfo::set_handle(const methodHandle& resolved_method,
96 Handle resolved_appendix, TRAPS) {
97 set_handle(SystemDictionary::MethodHandle_klass(), resolved_method, resolved_appendix, CHECK);
98 }
99
100 void CallInfo::set_handle(Klass* resolved_klass,
101 const methodHandle& resolved_method,
102 Handle resolved_appendix, TRAPS) {
103 guarantee(resolved_method.not_null(), "resolved method is null");
104 assert(resolved_method->intrinsic_id() == vmIntrinsics::_invokeBasic ||
105 resolved_method->is_compiled_lambda_form(),
106 "linkMethod must return one of these");
107 int vtable_index = Method::nonvirtual_vtable_index;
108 assert(!resolved_method->has_vtable_index(), "");
109 set_common(resolved_klass, resolved_method, resolved_method, CallInfo::direct_call, vtable_index, CHECK);
110 _resolved_appendix = resolved_appendix;
111 }
112
113 void CallInfo::set_common(Klass* resolved_klass,
114 const methodHandle& resolved_method,
115 const methodHandle& selected_method,
116 CallKind kind,
117 int index,
118 TRAPS) {
119 assert(resolved_method->signature() == selected_method->signature(), "signatures must correspond");
120 _resolved_klass = resolved_klass;
121 _resolved_method = resolved_method;
122 _selected_method = selected_method;
123 _call_kind = kind;
124 _call_index = index;
125 _resolved_appendix = Handle();
126 DEBUG_ONLY(verify()); // verify before making side effects
127
128 CompilationPolicy::compile_if_required(selected_method, THREAD);
129 }
130
131 // utility query for unreflecting a method
132 CallInfo::CallInfo(Method* resolved_method, Klass* resolved_klass, TRAPS) {
133 Klass* resolved_method_holder = resolved_method->method_holder();
134 if (resolved_klass == NULL) { // 2nd argument defaults to holder of 1st
135 resolved_klass = resolved_method_holder;
136 }
137 _resolved_klass = resolved_klass;
138 _resolved_method = methodHandle(THREAD, resolved_method);
139 _selected_method = methodHandle(THREAD, resolved_method);
140 // classify:
141 CallKind kind = CallInfo::unknown_kind;
142 int index = resolved_method->vtable_index();
143 if (resolved_method->can_be_statically_bound()) {
144 kind = CallInfo::direct_call;
145 } else if (!resolved_method_holder->is_interface()) {
146 // Could be an Object method inherited into an interface, but still a vtable call.
147 kind = CallInfo::vtable_call;
148 } else if (!resolved_klass->is_interface()) {
149 // A default or miranda method. Compute the vtable index.
150 index = LinkResolver::vtable_index_of_interface_method(resolved_klass,
151 _resolved_method);
152 assert(index >= 0 , "we should have valid vtable index at this point");
153
154 kind = CallInfo::vtable_call;
155 } else if (resolved_method->has_vtable_index()) {
156 // Can occur if an interface redeclares a method of Object.
157
1375 }
1376 }
1377
1378 // check if method exists
1379 if (selected_method.is_null()) {
1380 throw_abstract_method_error(resolved_method, recv_klass, CHECK);
1381 }
1382
1383 // check if abstract
1384 if (check_null_and_abstract && selected_method->is_abstract()) {
1385 // Pass arguments for generating a verbose error message.
1386 throw_abstract_method_error(resolved_method, selected_method, recv_klass, CHECK);
1387 }
1388
1389 if (log_develop_is_enabled(Trace, vtables)) {
1390 trace_method_resolution("invokevirtual selected method: receiver-class:",
1391 recv_klass, resolved_klass, selected_method(),
1392 false, vtable_index);
1393 }
1394 // setup result
1395 result.set_virtual(resolved_klass, resolved_method, selected_method, vtable_index, CHECK);
1396 }
1397
1398 void LinkResolver::resolve_interface_call(CallInfo& result, Handle recv, Klass* recv_klass,
1399 const LinkInfo& link_info,
1400 bool check_null_and_abstract, TRAPS) {
1401 // throws linktime exceptions
1402 Method* resolved_method = linktime_resolve_interface_method(link_info, CHECK);
1403 methodHandle mh(THREAD, resolved_method);
1404 runtime_resolve_interface_method(result, mh, link_info.resolved_klass(),
1405 recv, recv_klass, check_null_and_abstract, CHECK);
1406 }
1407
1408 Method* LinkResolver::linktime_resolve_interface_method(const LinkInfo& link_info,
1409 TRAPS) {
1410 // normal interface method resolution
1411 Method* resolved_method = resolve_interface_method(link_info, Bytecodes::_invokeinterface, CHECK_NULL);
1412 assert(resolved_method->name() != vmSymbols::object_initializer_name(), "should have been checked in verifier");
1413 assert(resolved_method->name() != vmSymbols::class_initializer_name (), "should have been checked in verifier");
1414
1415 return resolved_method;
1471 ss.print("'");
1472 Method::print_external_name(&ss, recv_klass, selected_method->name(), selected_method->signature());
1473 ss.print("'");
1474 THROW_MSG(vmSymbols::java_lang_IllegalAccessError(), ss.as_string());
1475 }
1476 // check if abstract
1477 if (check_null_and_abstract && selected_method->is_abstract()) {
1478 throw_abstract_method_error(resolved_method, selected_method, recv_klass, CHECK);
1479 }
1480 }
1481
1482 if (log_develop_is_enabled(Trace, itables)) {
1483 trace_method_resolution("invokeinterface selected method: receiver-class:",
1484 recv_klass, resolved_klass, selected_method(), true);
1485 }
1486 // setup result
1487 if (resolved_method->has_vtable_index()) {
1488 int vtable_index = resolved_method->vtable_index();
1489 log_develop_trace(itables)(" -- vtable index: %d", vtable_index);
1490 assert(vtable_index == selected_method->vtable_index(), "sanity check");
1491 result.set_virtual(resolved_klass, resolved_method, selected_method, vtable_index, CHECK);
1492 } else if (resolved_method->has_itable_index()) {
1493 int itable_index = resolved_method()->itable_index();
1494 log_develop_trace(itables)(" -- itable index: %d", itable_index);
1495 result.set_interface(resolved_klass, resolved_method, selected_method, itable_index, CHECK);
1496 } else {
1497 int index = resolved_method->vtable_index();
1498 log_develop_trace(itables)(" -- non itable/vtable index: %d", index);
1499 assert(index == Method::nonvirtual_vtable_index, "Oops hit another case!");
1500 assert(resolved_method()->is_private() ||
1501 (resolved_method()->is_final() && resolved_method->method_holder() == SystemDictionary::Object_klass()),
1502 "Should only have non-virtual invokeinterface for private or final-Object methods!");
1503 assert(resolved_method()->can_be_statically_bound(), "Should only have non-virtual invokeinterface for statically bound methods!");
1504 // This sets up the nonvirtual form of "virtual" call (as needed for final and private methods)
1505 result.set_virtual(resolved_klass, resolved_method, resolved_method, index, CHECK);
1506 }
1507 }
1508
1509
1510 Method* LinkResolver::linktime_resolve_interface_method_or_null(
1511 const LinkInfo& link_info) {
1512 EXCEPTION_MARK;
1513 Method* method_result = linktime_resolve_interface_method(link_info, THREAD);
1514 if (HAS_PENDING_EXCEPTION) {
1515 CLEAR_PENDING_EXCEPTION;
1516 return NULL;
1517 } else {
1518 return method_result;
1519 }
1520 }
1521
1522 Method* LinkResolver::linktime_resolve_virtual_method_or_null(
1523 const LinkInfo& link_info) {
1524 EXCEPTION_MARK;
1525 Method* method_result = linktime_resolve_virtual_method(link_info, THREAD);
|