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 "cds/archiveUtils.hpp"
27 #include "classfile/defaultMethods.hpp"
28 #include "classfile/javaClasses.hpp"
29 #include "classfile/systemDictionary.hpp"
30 #include "classfile/vmClasses.hpp"
31 #include "classfile/vmSymbols.hpp"
32 #include "compiler/compilationPolicy.hpp"
33 #include "compiler/compileBroker.hpp"
34 #include "gc/shared/collectedHeap.inline.hpp"
35 #include "interpreter/bootstrapInfo.hpp"
36 #include "interpreter/bytecode.hpp"
37 #include "interpreter/interpreterRuntime.hpp"
38 #include "interpreter/linkResolver.hpp"
39 #include "jvm.h"
40 #include "logging/log.hpp"
41 #include "logging/logStream.hpp"
42 #include "memory/resourceArea.hpp"
43 #include "oops/constantPool.inline.hpp"
44 #include "oops/cpCache.inline.hpp"
45 #include "oops/instanceKlass.inline.hpp"
46 #include "oops/klass.inline.hpp"
47 #include "oops/method.inline.hpp"
48 #include "oops/objArrayKlass.hpp"
49 #include "oops/objArrayOop.hpp"
50 #include "oops/oop.inline.hpp"
51 #include "oops/resolvedIndyEntry.hpp"
52 #include "oops/symbolHandle.hpp"
53 #include "prims/jvmtiExport.hpp"
54 #include "prims/methodHandles.hpp"
55 #include "runtime/fieldDescriptor.inline.hpp"
56 #include "runtime/frame.inline.hpp"
57 #include "runtime/handles.inline.hpp"
58 #include "runtime/javaThread.hpp"
59 #include "runtime/reflection.hpp"
60 #include "runtime/safepointVerifiers.hpp"
61 #include "runtime/sharedRuntime.hpp"
62 #include "runtime/signature.hpp"
63 #include "runtime/vmThread.hpp"
64 #include "utilities/macros.hpp"
65 #if INCLUDE_JFR
66 #include "jfr/jfr.hpp"
67 #endif
68
69 //------------------------------------------------------------------------------------------------------------------------
70 // Implementation of CallInfo
71
72
73 void CallInfo::set_static(Klass* resolved_klass, const methodHandle& resolved_method, TRAPS) {
74 int vtable_index = Method::nonvirtual_vtable_index;
75 set_common(resolved_klass, resolved_method, resolved_method, CallInfo::direct_call, vtable_index, CHECK);
76 }
77
78
123 return _resolved_method->get_new_method();
124 } else {
125 return _resolved_method();
126 }
127 }
128
129 Method* CallInfo::selected_method() const {
130 if (JvmtiExport::can_hotswap_or_post_breakpoint() && _selected_method->is_old()) {
131 return _selected_method->get_new_method();
132 } else {
133 return _selected_method();
134 }
135 }
136
137 void CallInfo::set_common(Klass* resolved_klass,
138 const methodHandle& resolved_method,
139 const methodHandle& selected_method,
140 CallKind kind,
141 int index,
142 TRAPS) {
143 assert(resolved_method->signature() == selected_method->signature(), "signatures must correspond");
144 _resolved_klass = resolved_klass;
145 _resolved_method = resolved_method;
146 _selected_method = selected_method;
147 _call_kind = kind;
148 _call_index = index;
149 _resolved_appendix = Handle();
150 DEBUG_ONLY(verify()); // verify before making side effects
151
152 CompilationPolicy::compile_if_required(selected_method, THREAD);
153 }
154
155 // utility query for unreflecting a method
156 CallInfo::CallInfo(Method* resolved_method, Klass* resolved_klass, TRAPS) {
157 Klass* resolved_method_holder = resolved_method->method_holder();
158 if (resolved_klass == nullptr) { // 2nd argument defaults to holder of 1st
159 resolved_klass = resolved_method_holder;
160 }
161 _resolved_klass = resolved_klass;
162 _resolved_method = methodHandle(THREAD, resolved_method);
163 _selected_method = methodHandle(THREAD, resolved_method);
164 // classify:
165 CallKind kind = CallInfo::unknown_kind;
166 int index = resolved_method->vtable_index();
167 if (resolved_method->can_be_statically_bound()) {
168 kind = CallInfo::direct_call;
169 } else if (!resolved_method_holder->is_interface()) {
170 // Could be an Object method inherited into an interface, but still a vtable call.
171 kind = CallInfo::vtable_call;
172 } else if (!resolved_klass->is_interface()) {
955 sel_klass->external_name(),
956 fd.name()->as_C_string(),
957 (same_module) ? ref_klass->joint_in_module_of_loader(sel_klass) : ref_klass->class_in_module_of_loader(),
958 (same_module) ? "" : "; ",
959 (same_module) ? "" : sel_klass->class_in_module_of_loader()
960 );
961 // For private access see if there was a problem with nest host
962 // resolution, and if so report that as part of the message.
963 if (fd.is_private()) {
964 print_nest_host_error_on(&ss, ref_klass, sel_klass);
965 }
966 Exceptions::fthrow(THREAD_AND_LOCATION,
967 vmSymbols::java_lang_IllegalAccessError(),
968 "%s",
969 ss.as_string()
970 );
971 return;
972 }
973 }
974
975 void LinkResolver::resolve_field_access(fieldDescriptor& fd, const constantPoolHandle& pool, int index, const methodHandle& method, Bytecodes::Code byte, TRAPS) {
976 LinkInfo link_info(pool, index, method, byte, CHECK);
977 resolve_field(fd, link_info, byte, true, CHECK);
978 }
979
980 void LinkResolver::resolve_field(fieldDescriptor& fd,
981 const LinkInfo& link_info,
982 Bytecodes::Code byte, bool initialize_class,
983 TRAPS) {
984 assert(byte == Bytecodes::_getstatic || byte == Bytecodes::_putstatic ||
985 byte == Bytecodes::_getfield || byte == Bytecodes::_putfield ||
986 byte == Bytecodes::_nofast_getfield || byte == Bytecodes::_nofast_putfield ||
987 (byte == Bytecodes::_nop && !link_info.check_access()), "bad field access bytecode");
988
989 bool is_static = (byte == Bytecodes::_getstatic || byte == Bytecodes::_putstatic);
990 bool is_put = (byte == Bytecodes::_putfield || byte == Bytecodes::_putstatic || byte == Bytecodes::_nofast_putfield);
991 // Check if there's a resolved klass containing the field
992 Klass* resolved_klass = link_info.resolved_klass();
993 Symbol* field = link_info.name();
994 Symbol* sig = link_info.signature();
995
996 // Resolve instance field
997 Klass* sel_klass = resolved_klass->find_field(field, sig, &fd);
998 // check if field exists; i.e., if a klass containing the field def has been selected
999 if (sel_klass == nullptr) {
1000 ResourceMark rm(THREAD);
1001 stringStream ss;
1002 ss.print("Class %s does not have member field '", resolved_klass->external_name());
1095
1096 // The resolved class can change as a result of this resolution.
1097 Klass* resolved_klass = resolved_method->method_holder();
1098
1099 // Initialize klass (this should only happen if everything is ok)
1100 if (initialize_class && resolved_klass->should_be_initialized()) {
1101 resolved_klass->initialize(CHECK);
1102 // Use updated LinkInfo to reresolve with resolved method holder
1103 LinkInfo new_info(resolved_klass, link_info.name(), link_info.signature(),
1104 link_info.current_klass(),
1105 link_info.check_access() ? LinkInfo::AccessCheck::required : LinkInfo::AccessCheck::skip,
1106 link_info.check_loader_constraints() ? LinkInfo::LoaderConstraintCheck::required : LinkInfo::LoaderConstraintCheck::skip);
1107 resolved_method = linktime_resolve_static_method(new_info, CHECK);
1108 }
1109
1110 // setup result
1111 result.set_static(resolved_klass, methodHandle(THREAD, resolved_method), CHECK);
1112 JFR_ONLY(Jfr::on_resolution(result, CHECK);)
1113 }
1114
1115 // throws linktime exceptions
1116 Method* LinkResolver::linktime_resolve_static_method(const LinkInfo& link_info, TRAPS) {
1117
1118 Klass* resolved_klass = link_info.resolved_klass();
1119 Method* resolved_method;
1120 if (!resolved_klass->is_interface()) {
1121 resolved_method = resolve_method(link_info, Bytecodes::_invokestatic, CHECK_NULL);
1122 } else {
1123 resolved_method = resolve_interface_method(link_info, Bytecodes::_invokestatic, CHECK_NULL);
1124 }
1125 assert(resolved_method->name() != vmSymbols::class_initializer_name(), "should have been checked in verifier");
1126
1127 // check if static
1128 if (!resolved_method->is_static()) {
1129 ResourceMark rm(THREAD);
1130 stringStream ss;
1131 ss.print("Expected static method '");
1132 resolved_method->print_external_name(&ss);
1133 ss.print("'");
1134 THROW_MSG_NULL(vmSymbols::java_lang_IncompatibleClassChangeError(), ss.as_string());
1135 }
1136 return resolved_method;
1137 }
1138
1139
1140 void LinkResolver::resolve_special_call(CallInfo& result,
1141 Handle recv,
1142 const LinkInfo& link_info,
1143 TRAPS) {
1144 Method* resolved_method = linktime_resolve_special_method(link_info, CHECK);
1145 runtime_resolve_special_method(result, link_info, methodHandle(THREAD, resolved_method), recv, CHECK);
1146 }
1147
1148 // throws linktime exceptions
1149 Method* LinkResolver::linktime_resolve_special_method(const LinkInfo& link_info, TRAPS) {
1150
1151 // Invokespecial is called for multiple special reasons:
1152 // <init>
1153 // local private method invocation, for classes and interfaces
1154 // superclass.method, which can also resolve to a default method
1155 // and the selected method is recalculated relative to the direct superclass
1156 // superinterface.method, which explicitly does not check shadowing
1157 Klass* resolved_klass = link_info.resolved_klass();
1158 Method* resolved_method = nullptr;
1159
1160 if (!resolved_klass->is_interface()) {
1161 resolved_method = resolve_method(link_info, Bytecodes::_invokespecial, CHECK_NULL);
1162 } else {
1163 resolved_method = resolve_interface_method(link_info, Bytecodes::_invokespecial, CHECK_NULL);
1164 }
1165
1166 // check if method name is <init>, that it is found in same klass as static type
1167 if (resolved_method->name() == vmSymbols::object_initializer_name() &&
1309 THROW_MSG(vmSymbols::java_lang_AbstractMethodError(), ss.as_string());
1310 }
1311
1312 if (log_develop_is_enabled(Trace, itables)) {
1313 trace_method_resolution("invokespecial selected method: resolved-class:",
1314 resolved_klass, resolved_klass, sel_method(), true);
1315 }
1316
1317 // setup result
1318 result.set_static(resolved_klass, sel_method, CHECK);
1319 JFR_ONLY(Jfr::on_resolution(result, CHECK);)
1320 }
1321
1322 void LinkResolver::resolve_virtual_call(CallInfo& result, Handle recv, Klass* receiver_klass,
1323 const LinkInfo& link_info,
1324 bool check_null_and_abstract, TRAPS) {
1325 Method* resolved_method = linktime_resolve_virtual_method(link_info, CHECK);
1326 runtime_resolve_virtual_method(result, methodHandle(THREAD, resolved_method),
1327 link_info.resolved_klass(),
1328 recv, receiver_klass,
1329 check_null_and_abstract, CHECK);
1330 }
1331
1332 // throws linktime exceptions
1333 Method* LinkResolver::linktime_resolve_virtual_method(const LinkInfo& link_info,
1334 TRAPS) {
1335 // normal method resolution
1336 Method* resolved_method = resolve_method(link_info, Bytecodes::_invokevirtual, CHECK_NULL);
1337
1338 assert(resolved_method->name() != vmSymbols::object_initializer_name(), "should have been checked in verifier");
1339 assert(resolved_method->name() != vmSymbols::class_initializer_name (), "should have been checked in verifier");
1340
1341 // check if private interface method
1342 Klass* resolved_klass = link_info.resolved_klass();
1343 Klass* current_klass = link_info.current_klass();
1344
1345 // This is impossible, if resolve_klass is an interface, we've thrown icce in resolve_method
1346 if (resolved_klass->is_interface() && resolved_method->is_private()) {
1347 ResourceMark rm(THREAD);
1348 stringStream ss;
1349 ss.print("private interface method requires invokespecial, not invokevirtual: method '");
1361 resolved_method->print_external_name(&ss);
1362 ss.print("'");
1363 THROW_MSG_NULL(vmSymbols::java_lang_IncompatibleClassChangeError(), ss.as_string());
1364 }
1365
1366 if (log_develop_is_enabled(Trace, vtables)) {
1367 trace_method_resolution("invokevirtual resolved method: caller-class:",
1368 current_klass, resolved_klass, resolved_method, false);
1369 }
1370
1371 return resolved_method;
1372 }
1373
1374 // throws runtime exceptions
1375 void LinkResolver::runtime_resolve_virtual_method(CallInfo& result,
1376 const methodHandle& resolved_method,
1377 Klass* resolved_klass,
1378 Handle recv,
1379 Klass* recv_klass,
1380 bool check_null_and_abstract,
1381 TRAPS) {
1382
1383 // setup default return values
1384 int vtable_index = Method::invalid_vtable_index;
1385 methodHandle selected_method;
1386
1387 // runtime method resolution
1388 if (check_null_and_abstract && recv.is_null()) { // check if receiver exists
1389 THROW(vmSymbols::java_lang_NullPointerException());
1390 }
1391
1392 // Virtual methods cannot be resolved before its klass has been linked, for otherwise the Method*'s
1393 // has not been rewritten, and the vtable initialized. Make sure to do this after the nullcheck, since
1394 // a missing receiver might result in a bogus lookup.
1395 assert(resolved_method->method_holder()->is_linked(), "must be linked");
1396
1397 // do lookup based on receiver klass using the vtable index
1398 if (resolved_method->method_holder()->is_interface()) { // default or miranda method
1399 vtable_index = vtable_index_of_interface_method(resolved_klass, resolved_method);
1400 assert(vtable_index >= 0 , "we should have valid vtable index at this point");
1401
1402 selected_method = methodHandle(THREAD, recv_klass->method_at_vtable(vtable_index));
1403 } else {
1404 // at this point we are sure that resolved_method is virtual and not
1405 // a default or miranda method; therefore, it must have a valid vtable index.
1406 assert(!resolved_method->has_itable_index(), "");
1407 vtable_index = resolved_method->vtable_index();
1408 // We could get a negative vtable_index of nonvirtual_vtable_index for private
1409 // methods, or for final methods. Private methods never appear in the vtable
1410 // and never override other methods. As an optimization, final methods are
1411 // never put in the vtable, unless they override an existing method.
1412 // So if we do get nonvirtual_vtable_index, it means the selected method is the
1413 // resolved method, and it can never be changed by an override.
1414 if (vtable_index == Method::nonvirtual_vtable_index) {
1415 assert(resolved_method->can_be_statically_bound(), "cannot override this method");
1416 selected_method = resolved_method;
1417 } else {
1418 selected_method = methodHandle(THREAD, recv_klass->method_at_vtable(vtable_index));
1419 }
1420 }
1421
1422 // check if method exists
1423 if (selected_method.is_null()) {
1424 throw_abstract_method_error(resolved_method, recv_klass, CHECK);
1425 }
1426
1427 // check if abstract
1428 if (check_null_and_abstract && selected_method->is_abstract()) {
1429 // Pass arguments for generating a verbose error message.
1430 throw_abstract_method_error(resolved_method, selected_method, recv_klass, CHECK);
1431 }
1432
1433 if (log_develop_is_enabled(Trace, vtables)) {
1434 trace_method_resolution("invokevirtual selected method: receiver-class:",
1435 recv_klass, resolved_klass, selected_method(),
1436 false, vtable_index);
1437 }
1438 // setup result
1439 result.set_virtual(resolved_klass, resolved_method, selected_method, vtable_index, CHECK);
1440 JFR_ONLY(Jfr::on_resolution(result, CHECK);)
1441 }
1442
1443 void LinkResolver::resolve_interface_call(CallInfo& result, Handle recv, Klass* recv_klass,
1444 const LinkInfo& link_info,
1445 bool check_null_and_abstract, TRAPS) {
1446 // throws linktime exceptions
1447 Method* resolved_method = linktime_resolve_interface_method(link_info, CHECK);
1448 methodHandle mh(THREAD, resolved_method);
1449 runtime_resolve_interface_method(result, mh, link_info.resolved_klass(),
1450 recv, recv_klass, check_null_and_abstract, CHECK);
1451 }
1452
1453 Method* LinkResolver::linktime_resolve_interface_method(const LinkInfo& link_info,
1454 TRAPS) {
1455 // normal interface method resolution
1456 Method* resolved_method = resolve_interface_method(link_info, Bytecodes::_invokeinterface, CHECK_NULL);
1457 assert(resolved_method->name() != vmSymbols::object_initializer_name(), "should have been checked in verifier");
1458 assert(resolved_method->name() != vmSymbols::class_initializer_name (), "should have been checked in verifier");
1459
1460 return resolved_method;
1461 }
1462
1463 // throws runtime exceptions
1464 void LinkResolver::runtime_resolve_interface_method(CallInfo& result,
1465 const methodHandle& resolved_method,
1466 Klass* resolved_klass,
1467 Handle recv,
1468 Klass* recv_klass,
1469 bool check_null_and_abstract, TRAPS) {
1470
1471 // check if receiver exists
1472 if (check_null_and_abstract && recv.is_null()) {
1473 THROW(vmSymbols::java_lang_NullPointerException());
1474 }
1475
1476 // check if receiver klass implements the resolved interface
1477 if (!recv_klass->is_subtype_of(resolved_klass)) {
1478 ResourceMark rm(THREAD);
1479 char buf[200];
1480 jio_snprintf(buf, sizeof(buf), "Class %s does not implement the requested interface %s",
1481 recv_klass->external_name(),
1482 resolved_klass->external_name());
1483 THROW_MSG(vmSymbols::java_lang_IncompatibleClassChangeError(), buf);
1484 }
1485
1486 methodHandle selected_method = resolved_method;
1487
1488 // resolve the method in the receiver class, unless it is private
1489 if (!resolved_method()->is_private()) {
1490 // do lookup based on receiver klass
1491 // This search must match the linktime preparation search for itable initialization
1492 // to correctly enforce loader constraints for interface method inheritance.
1493 // Private methods are skipped as the resolved method was not private.
1494 Method* method = lookup_instance_method_in_klasses(recv_klass,
1495 resolved_method->name(),
1496 resolved_method->signature(),
1497 Klass::PrivateLookupMode::skip);
1498 selected_method = methodHandle(THREAD, method);
1499
1500 if (selected_method.is_null() && !check_null_and_abstract) {
1501 // In theory this is a harmless placeholder value, but
1502 // in practice leaving in null affects the nsk default method tests.
1503 // This needs further study.
1504 selected_method = resolved_method;
1505 }
1506 // check if method exists
1507 if (selected_method.is_null()) {
1508 // Pass arguments for generating a verbose error message.
1509 throw_abstract_method_error(resolved_method, recv_klass, CHECK);
1515 stringStream ss;
1516 ss.print("'");
1517 Method::print_external_name(&ss, recv_klass, selected_method->name(), selected_method->signature());
1518 ss.print("'");
1519 THROW_MSG(vmSymbols::java_lang_IllegalAccessError(), ss.as_string());
1520 }
1521 // check if abstract
1522 if (check_null_and_abstract && selected_method->is_abstract()) {
1523 throw_abstract_method_error(resolved_method, selected_method, recv_klass, CHECK);
1524 }
1525 }
1526
1527 if (log_develop_is_enabled(Trace, itables)) {
1528 trace_method_resolution("invokeinterface selected method: receiver-class:",
1529 recv_klass, resolved_klass, selected_method(), true);
1530 }
1531 // setup result
1532 if (resolved_method->has_vtable_index()) {
1533 int vtable_index = resolved_method->vtable_index();
1534 log_develop_trace(itables)(" -- vtable index: %d", vtable_index);
1535 assert(vtable_index == selected_method->vtable_index(), "sanity check");
1536 result.set_virtual(resolved_klass, resolved_method, selected_method, vtable_index, CHECK);
1537 } else if (resolved_method->has_itable_index()) {
1538 int itable_index = resolved_method()->itable_index();
1539 log_develop_trace(itables)(" -- itable index: %d", itable_index);
1540 result.set_interface(resolved_klass, resolved_method, selected_method, itable_index, CHECK);
1541 } else {
1542 int index = resolved_method->vtable_index();
1543 log_develop_trace(itables)(" -- non itable/vtable index: %d", index);
1544 assert(index == Method::nonvirtual_vtable_index, "Oops hit another case!");
1545 assert(resolved_method()->is_private() ||
1546 (resolved_method()->is_final() && resolved_method->method_holder() == vmClasses::Object_klass()),
1547 "Should only have non-virtual invokeinterface for private or final-Object methods!");
1548 assert(resolved_method()->can_be_statically_bound(), "Should only have non-virtual invokeinterface for statically bound methods!");
1549 // This sets up the nonvirtual form of "virtual" call (as needed for final and private methods)
1550 result.set_virtual(resolved_klass, resolved_method, resolved_method, index, CHECK);
1551 }
1552 JFR_ONLY(Jfr::on_resolution(result, CHECK);)
1553 }
1554
1555
1556 Method* LinkResolver::linktime_resolve_interface_method_or_null(
1557 const LinkInfo& link_info) {
1558 EXCEPTION_MARK;
1559 Method* method_result = linktime_resolve_interface_method(link_info, THREAD);
1560 if (HAS_PENDING_EXCEPTION) {
1561 CLEAR_PENDING_EXCEPTION;
1562 return nullptr;
1563 } else {
1564 return method_result;
1565 }
1566 }
1567
1568 Method* LinkResolver::linktime_resolve_virtual_method_or_null(
1569 const LinkInfo& link_info) {
1570 EXCEPTION_MARK;
1571 Method* method_result = linktime_resolve_virtual_method(link_info, THREAD);
1572 if (HAS_PENDING_EXCEPTION) {
1711 LinkInfo link_info(pool, index, Bytecodes::_invokeinterface, CHECK);
1712 Klass* recvrKlass = recv.is_null() ? (Klass*)nullptr : recv->klass();
1713 resolve_interface_call(result, recv, recvrKlass, link_info, true, CHECK);
1714 }
1715
1716 bool LinkResolver::resolve_previously_linked_invokehandle(CallInfo& result, const LinkInfo& link_info, const constantPoolHandle& pool, int index, TRAPS) {
1717 ResolvedMethodEntry* method_entry = pool->cache()->resolved_method_entry_at(index);
1718 if (method_entry->method() != nullptr) {
1719 Klass* resolved_klass = link_info.resolved_klass();
1720 methodHandle method(THREAD, method_entry->method());
1721 Handle appendix(THREAD, pool->cache()->appendix_if_resolved(method_entry));
1722 result.set_handle(resolved_klass, method, appendix, CHECK_false);
1723 JFR_ONLY(Jfr::on_resolution(result, CHECK_false);)
1724 return true;
1725 } else {
1726 return false;
1727 }
1728 }
1729
1730 void LinkResolver::resolve_invokehandle(CallInfo& result, const constantPoolHandle& pool, int index, TRAPS) {
1731 LinkInfo link_info(pool, index, Bytecodes::_invokehandle, CHECK);
1732 if (log_is_enabled(Info, methodhandles)) {
1733 ResourceMark rm(THREAD);
1734 log_info(methodhandles)("resolve_invokehandle %s %s", link_info.name()->as_C_string(),
1735 link_info.signature()->as_C_string());
1736 }
1737 { // Check if the call site has been bound already, and short circuit:
1738 bool is_done = resolve_previously_linked_invokehandle(result, link_info, pool, index, CHECK);
1739 if (is_done) return;
1740 }
1741 resolve_handle_call(result, link_info, CHECK);
1742 }
1743
1744 void LinkResolver::resolve_handle_call(CallInfo& result,
1745 const LinkInfo& link_info,
1746 TRAPS) {
1747 // JSR 292: this must be an implicitly generated method MethodHandle.invokeExact(*...) or similar
1748 Klass* resolved_klass = link_info.resolved_klass();
1749 assert(resolved_klass == vmClasses::MethodHandle_klass() ||
1750 resolved_klass == vmClasses::VarHandle_klass(), "");
1751 assert(MethodHandles::is_signature_polymorphic_name(link_info.name()), "");
1752 Handle resolved_appendix;
1753 Method* m = lookup_polymorphic_method(link_info, &resolved_appendix, CHECK);
1754 methodHandle resolved_method(THREAD, m);
1755
1756 if (link_info.check_access()) {
1757 Symbol* name = link_info.name();
1758 vmIntrinsics::ID iid = MethodHandles::signature_polymorphic_name_id(name);
1759 if (MethodHandles::is_signature_polymorphic_intrinsic(iid)) {
1760 // Check if method can be accessed by the referring class.
1762 assert(iid == vmIntrinsicID::_invokeBasic, "%s", vmIntrinsics::name_at(iid));
1763
1764 Klass* current_klass = link_info.current_klass();
1765 assert(current_klass != nullptr , "current_klass should not be null");
1766 check_method_accessability(current_klass,
1767 resolved_klass,
1768 resolved_method->method_holder(),
1769 resolved_method,
1770 CHECK);
1771 } else {
1772 // Java code is free to arbitrarily link signature-polymorphic invokers.
1773 assert(iid == vmIntrinsics::_invokeGeneric, "not an invoker: %s", vmIntrinsics::name_at(iid));
1774 assert(MethodHandles::is_signature_polymorphic_public_name(resolved_klass, name), "not public");
1775 }
1776 }
1777 result.set_handle(resolved_klass, resolved_method, resolved_appendix, CHECK);
1778 JFR_ONLY(Jfr::on_resolution(result, CHECK);)
1779 }
1780
1781 void LinkResolver::resolve_invokedynamic(CallInfo& result, const constantPoolHandle& pool, int indy_index, TRAPS) {
1782 int pool_index = pool->resolved_indy_entry_at(indy_index)->constant_pool_index();
1783
1784 // Resolve the bootstrap specifier (BSM + optional arguments).
1785 BootstrapInfo bootstrap_specifier(pool, pool_index, indy_index);
1786
1787 // Check if CallSite has been bound already or failed already, and short circuit:
1788 {
1789 bool is_done = bootstrap_specifier.resolve_previously_linked_invokedynamic(result, CHECK);
1790 if (is_done) return;
1791 }
1792
1793 // The initial step in Call Site Specifier Resolution is to resolve the symbolic
1794 // reference to a method handle which will be the bootstrap method for a dynamic
1795 // call site. If resolution for the java.lang.invoke.MethodHandle for the bootstrap
1796 // method fails, then a MethodHandleInError is stored at the corresponding bootstrap
1797 // method's CP index for the CONSTANT_MethodHandle_info.
1798 // Any subsequent invokedynamic instruction which shares
1799 // this bootstrap method will encounter the resolution of MethodHandleInError.
1800
1801 resolve_dynamic_call(result, bootstrap_specifier, CHECK);
|
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 "cds/archiveUtils.hpp"
27 #include "classfile/classLoader.hpp"
28 #include "classfile/defaultMethods.hpp"
29 #include "classfile/javaClasses.hpp"
30 #include "classfile/systemDictionary.hpp"
31 #include "classfile/vmClasses.hpp"
32 #include "classfile/vmSymbols.hpp"
33 #include "compiler/compilationPolicy.hpp"
34 #include "compiler/compileBroker.hpp"
35 #include "gc/shared/collectedHeap.inline.hpp"
36 #include "interpreter/bootstrapInfo.hpp"
37 #include "interpreter/bytecode.hpp"
38 #include "interpreter/interpreterRuntime.hpp"
39 #include "interpreter/linkResolver.hpp"
40 #include "jvm.h"
41 #include "logging/log.hpp"
42 #include "logging/logStream.hpp"
43 #include "memory/resourceArea.hpp"
44 #include "oops/constantPool.inline.hpp"
45 #include "oops/cpCache.inline.hpp"
46 #include "oops/instanceKlass.inline.hpp"
47 #include "oops/klass.inline.hpp"
48 #include "oops/method.inline.hpp"
49 #include "oops/objArrayKlass.hpp"
50 #include "oops/objArrayOop.hpp"
51 #include "oops/oop.inline.hpp"
52 #include "oops/resolvedIndyEntry.hpp"
53 #include "oops/symbolHandle.hpp"
54 #include "prims/jvmtiExport.hpp"
55 #include "prims/methodHandles.hpp"
56 #include "runtime/fieldDescriptor.inline.hpp"
57 #include "runtime/frame.inline.hpp"
58 #include "runtime/handles.inline.hpp"
59 #include "runtime/javaThread.inline.hpp"
60 #include "runtime/perfData.hpp"
61 #include "runtime/reflection.hpp"
62 #include "runtime/safepointVerifiers.hpp"
63 #include "runtime/sharedRuntime.hpp"
64 #include "runtime/signature.hpp"
65 #include "runtime/vmThread.hpp"
66 #include "utilities/macros.hpp"
67 #if INCLUDE_JFR
68 #include "jfr/jfr.hpp"
69 #endif
70
71 //------------------------------------------------------------------------------------------------------------------------
72 // Implementation of CallInfo
73
74
75 void CallInfo::set_static(Klass* resolved_klass, const methodHandle& resolved_method, TRAPS) {
76 int vtable_index = Method::nonvirtual_vtable_index;
77 set_common(resolved_klass, resolved_method, resolved_method, CallInfo::direct_call, vtable_index, CHECK);
78 }
79
80
125 return _resolved_method->get_new_method();
126 } else {
127 return _resolved_method();
128 }
129 }
130
131 Method* CallInfo::selected_method() const {
132 if (JvmtiExport::can_hotswap_or_post_breakpoint() && _selected_method->is_old()) {
133 return _selected_method->get_new_method();
134 } else {
135 return _selected_method();
136 }
137 }
138
139 void CallInfo::set_common(Klass* resolved_klass,
140 const methodHandle& resolved_method,
141 const methodHandle& selected_method,
142 CallKind kind,
143 int index,
144 TRAPS) {
145 if (selected_method.not_null()) {
146 assert(resolved_method->signature() == selected_method->signature(), "signatures must correspond");
147 }
148 _resolved_klass = resolved_klass;
149 _resolved_method = resolved_method;
150 _selected_method = selected_method;
151 _call_kind = kind;
152 _call_index = index;
153 _resolved_appendix = Handle();
154 DEBUG_ONLY(verify()); // verify before making side effects
155
156 if (selected_method.not_null()) {
157 CompilationPolicy::compile_if_required(selected_method, THREAD);
158 }
159 }
160
161 // utility query for unreflecting a method
162 CallInfo::CallInfo(Method* resolved_method, Klass* resolved_klass, TRAPS) {
163 Klass* resolved_method_holder = resolved_method->method_holder();
164 if (resolved_klass == nullptr) { // 2nd argument defaults to holder of 1st
165 resolved_klass = resolved_method_holder;
166 }
167 _resolved_klass = resolved_klass;
168 _resolved_method = methodHandle(THREAD, resolved_method);
169 _selected_method = methodHandle(THREAD, resolved_method);
170 // classify:
171 CallKind kind = CallInfo::unknown_kind;
172 int index = resolved_method->vtable_index();
173 if (resolved_method->can_be_statically_bound()) {
174 kind = CallInfo::direct_call;
175 } else if (!resolved_method_holder->is_interface()) {
176 // Could be an Object method inherited into an interface, but still a vtable call.
177 kind = CallInfo::vtable_call;
178 } else if (!resolved_klass->is_interface()) {
961 sel_klass->external_name(),
962 fd.name()->as_C_string(),
963 (same_module) ? ref_klass->joint_in_module_of_loader(sel_klass) : ref_klass->class_in_module_of_loader(),
964 (same_module) ? "" : "; ",
965 (same_module) ? "" : sel_klass->class_in_module_of_loader()
966 );
967 // For private access see if there was a problem with nest host
968 // resolution, and if so report that as part of the message.
969 if (fd.is_private()) {
970 print_nest_host_error_on(&ss, ref_klass, sel_klass);
971 }
972 Exceptions::fthrow(THREAD_AND_LOCATION,
973 vmSymbols::java_lang_IllegalAccessError(),
974 "%s",
975 ss.as_string()
976 );
977 return;
978 }
979 }
980
981 void LinkResolver::resolve_field_access(fieldDescriptor& fd,
982 const constantPoolHandle& pool,
983 int index,
984 const methodHandle& method,
985 Bytecodes::Code byte,
986 bool initialize_class, TRAPS) {
987 LinkInfo link_info(pool, index, method, byte, CHECK);
988 resolve_field(fd, link_info, byte, initialize_class, CHECK);
989 }
990
991 void LinkResolver::resolve_field(fieldDescriptor& fd,
992 const LinkInfo& link_info,
993 Bytecodes::Code byte,
994 bool initialize_class,
995 TRAPS) {
996 assert(byte == Bytecodes::_getstatic || byte == Bytecodes::_putstatic ||
997 byte == Bytecodes::_getfield || byte == Bytecodes::_putfield ||
998 byte == Bytecodes::_nofast_getfield || byte == Bytecodes::_nofast_putfield ||
999 (byte == Bytecodes::_nop && !link_info.check_access()), "bad field access bytecode");
1000
1001 bool is_static = (byte == Bytecodes::_getstatic || byte == Bytecodes::_putstatic);
1002 bool is_put = (byte == Bytecodes::_putfield || byte == Bytecodes::_putstatic || byte == Bytecodes::_nofast_putfield);
1003 // Check if there's a resolved klass containing the field
1004 Klass* resolved_klass = link_info.resolved_klass();
1005 Symbol* field = link_info.name();
1006 Symbol* sig = link_info.signature();
1007
1008 // Resolve instance field
1009 Klass* sel_klass = resolved_klass->find_field(field, sig, &fd);
1010 // check if field exists; i.e., if a klass containing the field def has been selected
1011 if (sel_klass == nullptr) {
1012 ResourceMark rm(THREAD);
1013 stringStream ss;
1014 ss.print("Class %s does not have member field '", resolved_klass->external_name());
1107
1108 // The resolved class can change as a result of this resolution.
1109 Klass* resolved_klass = resolved_method->method_holder();
1110
1111 // Initialize klass (this should only happen if everything is ok)
1112 if (initialize_class && resolved_klass->should_be_initialized()) {
1113 resolved_klass->initialize(CHECK);
1114 // Use updated LinkInfo to reresolve with resolved method holder
1115 LinkInfo new_info(resolved_klass, link_info.name(), link_info.signature(),
1116 link_info.current_klass(),
1117 link_info.check_access() ? LinkInfo::AccessCheck::required : LinkInfo::AccessCheck::skip,
1118 link_info.check_loader_constraints() ? LinkInfo::LoaderConstraintCheck::required : LinkInfo::LoaderConstraintCheck::skip);
1119 resolved_method = linktime_resolve_static_method(new_info, CHECK);
1120 }
1121
1122 // setup result
1123 result.set_static(resolved_klass, methodHandle(THREAD, resolved_method), CHECK);
1124 JFR_ONLY(Jfr::on_resolution(result, CHECK);)
1125 }
1126
1127 void LinkResolver::cds_resolve_static_call(CallInfo& result, const LinkInfo& link_info, TRAPS) {
1128 resolve_static_call(result, link_info, /*initialize_class*/false, CHECK);
1129 }
1130
1131 // throws linktime exceptions
1132 Method* LinkResolver::linktime_resolve_static_method(const LinkInfo& link_info, TRAPS) {
1133
1134 Klass* resolved_klass = link_info.resolved_klass();
1135 Method* resolved_method;
1136 if (!resolved_klass->is_interface()) {
1137 resolved_method = resolve_method(link_info, Bytecodes::_invokestatic, CHECK_NULL);
1138 } else {
1139 resolved_method = resolve_interface_method(link_info, Bytecodes::_invokestatic, CHECK_NULL);
1140 }
1141 assert(resolved_method->name() != vmSymbols::class_initializer_name(), "should have been checked in verifier");
1142
1143 // check if static
1144 if (!resolved_method->is_static()) {
1145 ResourceMark rm(THREAD);
1146 stringStream ss;
1147 ss.print("Expected static method '");
1148 resolved_method->print_external_name(&ss);
1149 ss.print("'");
1150 THROW_MSG_NULL(vmSymbols::java_lang_IncompatibleClassChangeError(), ss.as_string());
1151 }
1152 return resolved_method;
1153 }
1154
1155
1156 void LinkResolver::resolve_special_call(CallInfo& result,
1157 Handle recv,
1158 const LinkInfo& link_info,
1159 TRAPS) {
1160 Method* resolved_method = linktime_resolve_special_method(link_info, CHECK);
1161 runtime_resolve_special_method(result, link_info, methodHandle(THREAD, resolved_method), recv, CHECK);
1162 }
1163
1164 void LinkResolver::cds_resolve_special_call(CallInfo& result, const LinkInfo& link_info, TRAPS) {
1165 resolve_special_call(result, Handle(), link_info, CHECK);
1166 }
1167
1168 // throws linktime exceptions
1169 Method* LinkResolver::linktime_resolve_special_method(const LinkInfo& link_info, TRAPS) {
1170
1171 // Invokespecial is called for multiple special reasons:
1172 // <init>
1173 // local private method invocation, for classes and interfaces
1174 // superclass.method, which can also resolve to a default method
1175 // and the selected method is recalculated relative to the direct superclass
1176 // superinterface.method, which explicitly does not check shadowing
1177 Klass* resolved_klass = link_info.resolved_klass();
1178 Method* resolved_method = nullptr;
1179
1180 if (!resolved_klass->is_interface()) {
1181 resolved_method = resolve_method(link_info, Bytecodes::_invokespecial, CHECK_NULL);
1182 } else {
1183 resolved_method = resolve_interface_method(link_info, Bytecodes::_invokespecial, CHECK_NULL);
1184 }
1185
1186 // check if method name is <init>, that it is found in same klass as static type
1187 if (resolved_method->name() == vmSymbols::object_initializer_name() &&
1329 THROW_MSG(vmSymbols::java_lang_AbstractMethodError(), ss.as_string());
1330 }
1331
1332 if (log_develop_is_enabled(Trace, itables)) {
1333 trace_method_resolution("invokespecial selected method: resolved-class:",
1334 resolved_klass, resolved_klass, sel_method(), true);
1335 }
1336
1337 // setup result
1338 result.set_static(resolved_klass, sel_method, CHECK);
1339 JFR_ONLY(Jfr::on_resolution(result, CHECK);)
1340 }
1341
1342 void LinkResolver::resolve_virtual_call(CallInfo& result, Handle recv, Klass* receiver_klass,
1343 const LinkInfo& link_info,
1344 bool check_null_and_abstract, TRAPS) {
1345 Method* resolved_method = linktime_resolve_virtual_method(link_info, CHECK);
1346 runtime_resolve_virtual_method(result, methodHandle(THREAD, resolved_method),
1347 link_info.resolved_klass(),
1348 recv, receiver_klass,
1349 check_null_and_abstract,
1350 /*need_selected_method*/true, CHECK);
1351 }
1352
1353 void LinkResolver::cds_resolve_virtual_call(CallInfo& result, const LinkInfo& link_info, TRAPS) {
1354 Method* resolved_method = linktime_resolve_virtual_method(link_info, CHECK);
1355 runtime_resolve_virtual_method(result, methodHandle(THREAD, resolved_method),
1356 link_info.resolved_klass(),
1357 Handle(), nullptr,
1358 /*check_null_and_abstract*/false,
1359 /*need_selected_method*/false, CHECK);
1360 }
1361
1362 // throws linktime exceptions
1363 Method* LinkResolver::linktime_resolve_virtual_method(const LinkInfo& link_info,
1364 TRAPS) {
1365 // normal method resolution
1366 Method* resolved_method = resolve_method(link_info, Bytecodes::_invokevirtual, CHECK_NULL);
1367
1368 assert(resolved_method->name() != vmSymbols::object_initializer_name(), "should have been checked in verifier");
1369 assert(resolved_method->name() != vmSymbols::class_initializer_name (), "should have been checked in verifier");
1370
1371 // check if private interface method
1372 Klass* resolved_klass = link_info.resolved_klass();
1373 Klass* current_klass = link_info.current_klass();
1374
1375 // This is impossible, if resolve_klass is an interface, we've thrown icce in resolve_method
1376 if (resolved_klass->is_interface() && resolved_method->is_private()) {
1377 ResourceMark rm(THREAD);
1378 stringStream ss;
1379 ss.print("private interface method requires invokespecial, not invokevirtual: method '");
1391 resolved_method->print_external_name(&ss);
1392 ss.print("'");
1393 THROW_MSG_NULL(vmSymbols::java_lang_IncompatibleClassChangeError(), ss.as_string());
1394 }
1395
1396 if (log_develop_is_enabled(Trace, vtables)) {
1397 trace_method_resolution("invokevirtual resolved method: caller-class:",
1398 current_klass, resolved_klass, resolved_method, false);
1399 }
1400
1401 return resolved_method;
1402 }
1403
1404 // throws runtime exceptions
1405 void LinkResolver::runtime_resolve_virtual_method(CallInfo& result,
1406 const methodHandle& resolved_method,
1407 Klass* resolved_klass,
1408 Handle recv,
1409 Klass* recv_klass,
1410 bool check_null_and_abstract,
1411 bool need_selected_method,
1412 TRAPS) {
1413
1414 // setup default return values
1415 int vtable_index = Method::invalid_vtable_index;
1416 methodHandle selected_method;
1417
1418 // runtime method resolution
1419 if (check_null_and_abstract && recv.is_null()) { // check if receiver exists
1420 THROW(vmSymbols::java_lang_NullPointerException());
1421 }
1422
1423 // Virtual methods cannot be resolved before its klass has been linked, for otherwise the Method*'s
1424 // has not been rewritten, and the vtable initialized. Make sure to do this after the nullcheck, since
1425 // a missing receiver might result in a bogus lookup.
1426 assert(resolved_method->method_holder()->is_linked(), "must be linked");
1427
1428 // do lookup based on receiver klass using the vtable index
1429 if (resolved_method->method_holder()->is_interface()) { // default or miranda method
1430 vtable_index = vtable_index_of_interface_method(resolved_klass, resolved_method);
1431 assert(vtable_index >= 0 , "we should have valid vtable index at this point");
1432
1433 if (need_selected_method) {
1434 selected_method = methodHandle(THREAD, recv_klass->method_at_vtable(vtable_index));
1435 }
1436 } else {
1437 // at this point we are sure that resolved_method is virtual and not
1438 // a default or miranda method; therefore, it must have a valid vtable index.
1439 assert(!resolved_method->has_itable_index(), "");
1440 vtable_index = resolved_method->vtable_index();
1441 // We could get a negative vtable_index of nonvirtual_vtable_index for private
1442 // methods, or for final methods. Private methods never appear in the vtable
1443 // and never override other methods. As an optimization, final methods are
1444 // never put in the vtable, unless they override an existing method.
1445 // So if we do get nonvirtual_vtable_index, it means the selected method is the
1446 // resolved method, and it can never be changed by an override.
1447 if (vtable_index == Method::nonvirtual_vtable_index) {
1448 assert(resolved_method->can_be_statically_bound(), "cannot override this method");
1449 if (need_selected_method) {
1450 selected_method = resolved_method;
1451 }
1452 } else {
1453 if (need_selected_method) {
1454 selected_method = methodHandle(THREAD, recv_klass->method_at_vtable(vtable_index));
1455 }
1456 }
1457 }
1458
1459 if (need_selected_method) {
1460 // check if method exists
1461 if (selected_method.is_null()) {
1462 throw_abstract_method_error(resolved_method, recv_klass, CHECK);
1463 }
1464
1465 // check if abstract
1466 if (check_null_and_abstract && selected_method->is_abstract()) {
1467 // Pass arguments for generating a verbose error message.
1468 throw_abstract_method_error(resolved_method, selected_method, recv_klass, CHECK);
1469 }
1470 }
1471
1472 if (log_develop_is_enabled(Trace, vtables)) {
1473 trace_method_resolution("invokevirtual selected method: receiver-class:",
1474 recv_klass, resolved_klass, selected_method(),
1475 false, vtable_index);
1476 }
1477 // setup result
1478 result.set_virtual(resolved_klass, resolved_method, selected_method, vtable_index, CHECK);
1479 if (selected_method.not_null()) {
1480 JFR_ONLY(Jfr::on_resolution(result, CHECK);)
1481 }
1482 }
1483
1484 void LinkResolver::resolve_interface_call(CallInfo& result, Handle recv, Klass* recv_klass,
1485 const LinkInfo& link_info,
1486 bool check_null_and_abstract, TRAPS) {
1487 // throws linktime exceptions
1488 Method* resolved_method = linktime_resolve_interface_method(link_info, CHECK);
1489 methodHandle mh(THREAD, resolved_method);
1490 runtime_resolve_interface_method(result, mh, link_info.resolved_klass(),
1491 recv, recv_klass, check_null_and_abstract,
1492 /*need_selected_method*/ true, CHECK);
1493 }
1494
1495 void LinkResolver::cds_resolve_interface_call(CallInfo& result, const LinkInfo& link_info, TRAPS) {
1496 Method* resolved_method = linktime_resolve_interface_method(link_info, CHECK);
1497 runtime_resolve_interface_method(result, methodHandle(THREAD, resolved_method), link_info.resolved_klass(),
1498 Handle(), nullptr,
1499 /*check_null_and_abstract*/ false,
1500 /*need_selected_method*/ false, CHECK);
1501 }
1502
1503 Method* LinkResolver::linktime_resolve_interface_method(const LinkInfo& link_info,
1504 TRAPS) {
1505 // normal interface method resolution
1506 Method* resolved_method = resolve_interface_method(link_info, Bytecodes::_invokeinterface, CHECK_NULL);
1507 assert(resolved_method->name() != vmSymbols::object_initializer_name(), "should have been checked in verifier");
1508 assert(resolved_method->name() != vmSymbols::class_initializer_name (), "should have been checked in verifier");
1509
1510 return resolved_method;
1511 }
1512
1513 // throws runtime exceptions
1514 void LinkResolver::runtime_resolve_interface_method(CallInfo& result,
1515 const methodHandle& resolved_method,
1516 Klass* resolved_klass,
1517 Handle recv,
1518 Klass* recv_klass,
1519 bool check_null_and_abstract,
1520 bool need_selected_method, TRAPS) {
1521
1522 // check if receiver exists
1523 if (check_null_and_abstract && recv.is_null()) {
1524 THROW(vmSymbols::java_lang_NullPointerException());
1525 }
1526
1527 // check if receiver klass implements the resolved interface
1528 if (need_selected_method && !recv_klass->is_subtype_of(resolved_klass)) {
1529 ResourceMark rm(THREAD);
1530 char buf[200];
1531 jio_snprintf(buf, sizeof(buf), "Class %s does not implement the requested interface %s",
1532 recv_klass->external_name(),
1533 resolved_klass->external_name());
1534 THROW_MSG(vmSymbols::java_lang_IncompatibleClassChangeError(), buf);
1535 }
1536
1537 methodHandle selected_method;
1538
1539 if (need_selected_method) {
1540 selected_method = resolved_method;
1541 }
1542
1543 // resolve the method in the receiver class, unless it is private
1544 if (need_selected_method && !resolved_method()->is_private()) {
1545 // do lookup based on receiver klass
1546 // This search must match the linktime preparation search for itable initialization
1547 // to correctly enforce loader constraints for interface method inheritance.
1548 // Private methods are skipped as the resolved method was not private.
1549 Method* method = lookup_instance_method_in_klasses(recv_klass,
1550 resolved_method->name(),
1551 resolved_method->signature(),
1552 Klass::PrivateLookupMode::skip);
1553 selected_method = methodHandle(THREAD, method);
1554
1555 if (selected_method.is_null() && !check_null_and_abstract) {
1556 // In theory this is a harmless placeholder value, but
1557 // in practice leaving in null affects the nsk default method tests.
1558 // This needs further study.
1559 selected_method = resolved_method;
1560 }
1561 // check if method exists
1562 if (selected_method.is_null()) {
1563 // Pass arguments for generating a verbose error message.
1564 throw_abstract_method_error(resolved_method, recv_klass, CHECK);
1570 stringStream ss;
1571 ss.print("'");
1572 Method::print_external_name(&ss, recv_klass, selected_method->name(), selected_method->signature());
1573 ss.print("'");
1574 THROW_MSG(vmSymbols::java_lang_IllegalAccessError(), ss.as_string());
1575 }
1576 // check if abstract
1577 if (check_null_and_abstract && selected_method->is_abstract()) {
1578 throw_abstract_method_error(resolved_method, selected_method, recv_klass, CHECK);
1579 }
1580 }
1581
1582 if (log_develop_is_enabled(Trace, itables)) {
1583 trace_method_resolution("invokeinterface selected method: receiver-class:",
1584 recv_klass, resolved_klass, selected_method(), true);
1585 }
1586 // setup result
1587 if (resolved_method->has_vtable_index()) {
1588 int vtable_index = resolved_method->vtable_index();
1589 log_develop_trace(itables)(" -- vtable index: %d", vtable_index);
1590 assert(!need_selected_method || vtable_index == selected_method->vtable_index(), "sanity check");
1591 result.set_virtual(resolved_klass, resolved_method, selected_method, vtable_index, CHECK);
1592 } else if (resolved_method->has_itable_index()) {
1593 int itable_index = resolved_method()->itable_index();
1594 log_develop_trace(itables)(" -- itable index: %d", itable_index);
1595 result.set_interface(resolved_klass, resolved_method, selected_method, itable_index, CHECK);
1596 } else {
1597 int index = resolved_method->vtable_index();
1598 log_develop_trace(itables)(" -- non itable/vtable index: %d", index);
1599 assert(index == Method::nonvirtual_vtable_index, "Oops hit another case!");
1600 assert(resolved_method()->is_private() ||
1601 (resolved_method()->is_final() && resolved_method->method_holder() == vmClasses::Object_klass()),
1602 "Should only have non-virtual invokeinterface for private or final-Object methods!");
1603 assert(resolved_method()->can_be_statically_bound(), "Should only have non-virtual invokeinterface for statically bound methods!");
1604 // This sets up the nonvirtual form of "virtual" call (as needed for final and private methods)
1605 result.set_virtual(resolved_klass, resolved_method, resolved_method, index, CHECK);
1606 }
1607 if (need_selected_method) {
1608 JFR_ONLY(Jfr::on_resolution(result, CHECK);)
1609 }
1610 }
1611
1612
1613 Method* LinkResolver::linktime_resolve_interface_method_or_null(
1614 const LinkInfo& link_info) {
1615 EXCEPTION_MARK;
1616 Method* method_result = linktime_resolve_interface_method(link_info, THREAD);
1617 if (HAS_PENDING_EXCEPTION) {
1618 CLEAR_PENDING_EXCEPTION;
1619 return nullptr;
1620 } else {
1621 return method_result;
1622 }
1623 }
1624
1625 Method* LinkResolver::linktime_resolve_virtual_method_or_null(
1626 const LinkInfo& link_info) {
1627 EXCEPTION_MARK;
1628 Method* method_result = linktime_resolve_virtual_method(link_info, THREAD);
1629 if (HAS_PENDING_EXCEPTION) {
1768 LinkInfo link_info(pool, index, Bytecodes::_invokeinterface, CHECK);
1769 Klass* recvrKlass = recv.is_null() ? (Klass*)nullptr : recv->klass();
1770 resolve_interface_call(result, recv, recvrKlass, link_info, true, CHECK);
1771 }
1772
1773 bool LinkResolver::resolve_previously_linked_invokehandle(CallInfo& result, const LinkInfo& link_info, const constantPoolHandle& pool, int index, TRAPS) {
1774 ResolvedMethodEntry* method_entry = pool->cache()->resolved_method_entry_at(index);
1775 if (method_entry->method() != nullptr) {
1776 Klass* resolved_klass = link_info.resolved_klass();
1777 methodHandle method(THREAD, method_entry->method());
1778 Handle appendix(THREAD, pool->cache()->appendix_if_resolved(method_entry));
1779 result.set_handle(resolved_klass, method, appendix, CHECK_false);
1780 JFR_ONLY(Jfr::on_resolution(result, CHECK_false);)
1781 return true;
1782 } else {
1783 return false;
1784 }
1785 }
1786
1787 void LinkResolver::resolve_invokehandle(CallInfo& result, const constantPoolHandle& pool, int index, TRAPS) {
1788 PerfTraceTimedEvent timer(ClassLoader::perf_resolve_invokehandle_time(),
1789 ClassLoader::perf_resolve_invokehandle_count(),
1790 THREAD->class_being_initialized() == nullptr);
1791
1792 LinkInfo link_info(pool, index, Bytecodes::_invokehandle, CHECK);
1793 { // Check if the call site has been bound already, and short circuit:
1794 bool is_done = resolve_previously_linked_invokehandle(result, link_info, pool, index, CHECK);
1795 if (is_done) return;
1796 }
1797 if (log_is_enabled(Info, methodhandles)) {
1798 ResourceMark rm(THREAD);
1799 log_info(methodhandles)("resolve_invokehandle %s %s", link_info.name()->as_C_string(),
1800 link_info.signature()->as_C_string());
1801 }
1802 resolve_handle_call(result, link_info, CHECK);
1803 }
1804
1805 void LinkResolver::resolve_handle_call(CallInfo& result,
1806 const LinkInfo& link_info,
1807 TRAPS) {
1808 // JSR 292: this must be an implicitly generated method MethodHandle.invokeExact(*...) or similar
1809 Klass* resolved_klass = link_info.resolved_klass();
1810 assert(resolved_klass == vmClasses::MethodHandle_klass() ||
1811 resolved_klass == vmClasses::VarHandle_klass(), "");
1812 assert(MethodHandles::is_signature_polymorphic_name(link_info.name()), "");
1813 Handle resolved_appendix;
1814 Method* m = lookup_polymorphic_method(link_info, &resolved_appendix, CHECK);
1815 methodHandle resolved_method(THREAD, m);
1816
1817 if (link_info.check_access()) {
1818 Symbol* name = link_info.name();
1819 vmIntrinsics::ID iid = MethodHandles::signature_polymorphic_name_id(name);
1820 if (MethodHandles::is_signature_polymorphic_intrinsic(iid)) {
1821 // Check if method can be accessed by the referring class.
1823 assert(iid == vmIntrinsicID::_invokeBasic, "%s", vmIntrinsics::name_at(iid));
1824
1825 Klass* current_klass = link_info.current_klass();
1826 assert(current_klass != nullptr , "current_klass should not be null");
1827 check_method_accessability(current_klass,
1828 resolved_klass,
1829 resolved_method->method_holder(),
1830 resolved_method,
1831 CHECK);
1832 } else {
1833 // Java code is free to arbitrarily link signature-polymorphic invokers.
1834 assert(iid == vmIntrinsics::_invokeGeneric, "not an invoker: %s", vmIntrinsics::name_at(iid));
1835 assert(MethodHandles::is_signature_polymorphic_public_name(resolved_klass, name), "not public");
1836 }
1837 }
1838 result.set_handle(resolved_klass, resolved_method, resolved_appendix, CHECK);
1839 JFR_ONLY(Jfr::on_resolution(result, CHECK);)
1840 }
1841
1842 void LinkResolver::resolve_invokedynamic(CallInfo& result, const constantPoolHandle& pool, int indy_index, TRAPS) {
1843 PerfTraceTimedEvent timer(ClassLoader::perf_resolve_invokedynamic_time(),
1844 ClassLoader::perf_resolve_invokedynamic_count(),
1845 THREAD->class_being_initialized() == nullptr);
1846 int pool_index = pool->resolved_indy_entry_at(indy_index)->constant_pool_index();
1847
1848 // Resolve the bootstrap specifier (BSM + optional arguments).
1849 BootstrapInfo bootstrap_specifier(pool, pool_index, indy_index);
1850
1851 // Check if CallSite has been bound already or failed already, and short circuit:
1852 {
1853 bool is_done = bootstrap_specifier.resolve_previously_linked_invokedynamic(result, CHECK);
1854 if (is_done) return;
1855 }
1856
1857 // The initial step in Call Site Specifier Resolution is to resolve the symbolic
1858 // reference to a method handle which will be the bootstrap method for a dynamic
1859 // call site. If resolution for the java.lang.invoke.MethodHandle for the bootstrap
1860 // method fails, then a MethodHandleInError is stored at the corresponding bootstrap
1861 // method's CP index for the CONSTANT_MethodHandle_info.
1862 // Any subsequent invokedynamic instruction which shares
1863 // this bootstrap method will encounter the resolution of MethodHandleInError.
1864
1865 resolve_dynamic_call(result, bootstrap_specifier, CHECK);
|