1 /* 2 * Copyright (c) 2016, 2017, Oracle and/or its affiliates. All rights reserved. 3 * Copyright (c) 2016, 2017, SAP SE. All rights reserved. 4 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 5 * 6 * This code is free software; you can redistribute it and/or modify it 7 * under the terms of the GNU General Public License version 2 only, as 8 * published by the Free Software Foundation. 9 * 10 * This code is distributed in the hope that it will be useful, but WITHOUT 11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 13 * version 2 for more details (a copy is included in the LICENSE file that 14 * accompanied this code). 15 * 16 * You should have received a copy of the GNU General Public License version 17 * 2 along with this work; if not, write to the Free Software Foundation, 18 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 19 * 20 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 21 * or visit www.oracle.com if you need additional information or have any 22 * questions. 23 * 24 */ 25 26 #include "precompiled.hpp" 27 #include "asm/macroAssembler.inline.hpp" 28 #include "classfile/javaClasses.inline.hpp" 29 #include "interpreter/interpreter.hpp" 30 #include "memory/allocation.inline.hpp" 31 #include "memory/resourceArea.hpp" 32 #include "prims/jvm.h" 33 #include "prims/methodHandles.hpp" 34 35 #ifdef PRODUCT 36 #define __ _masm-> 37 #define BLOCK_COMMENT(str) /* nothing */ 38 #else 39 #define __ (Verbose ? (_masm->block_comment(FILE_AND_LINE),_masm):_masm)-> 40 #define BLOCK_COMMENT(str) __ block_comment(str) 41 #endif 42 43 #define BIND(label) bind(label); BLOCK_COMMENT(#label ":") 44 45 // Workaround for C++ overloading nastiness on '0' for RegisterOrConstant. 46 static RegisterOrConstant constant(int value) { 47 return RegisterOrConstant(value); 48 } 49 50 void MethodHandles::load_klass_from_Class(MacroAssembler* _masm, Register klass_reg, 51 Register temp_reg, Register temp2_reg) { 52 if (VerifyMethodHandles) { 53 verify_klass(_masm, klass_reg, SystemDictionary::WK_KLASS_ENUM_NAME(java_lang_Class), 54 temp_reg, temp2_reg, "MH argument is a Class"); 55 } 56 __ z_lg(klass_reg, Address(klass_reg, java_lang_Class::klass_offset_in_bytes())); 57 } 58 59 60 #ifdef ASSERT 61 static int check_nonzero(const char* xname, int x) { 62 assert(x != 0, "%s should be nonzero", xname); 63 return x; 64 } 65 #define NONZERO(x) check_nonzero(#x, x) 66 #else 67 #define NONZERO(x) (x) 68 #endif 69 70 #ifdef ASSERT 71 void MethodHandles::verify_klass(MacroAssembler* _masm, 72 Register obj_reg, SystemDictionary::WKID klass_id, 73 Register temp_reg, Register temp2_reg, 74 const char* error_message) { 75 76 InstanceKlass** klass_addr = SystemDictionary::well_known_klass_addr(klass_id); 77 Klass* klass = SystemDictionary::well_known_klass(klass_id); 78 79 assert(temp_reg != Z_R0 && // Is used as base register! 80 temp_reg != noreg && temp2_reg != noreg, "need valid registers!"); 81 82 NearLabel L_ok, L_bad; 83 84 BLOCK_COMMENT("verify_klass {"); 85 86 __ verify_oop(obj_reg); 87 __ compareU64_and_branch(obj_reg, (intptr_t)0L, Assembler::bcondEqual, L_bad); 88 __ load_klass(temp_reg, obj_reg); 89 // klass_addr is a klass in allstatic SystemDictionaryHandles. Can't get GCed. 90 __ load_const_optimized(temp2_reg, (address)klass_addr); 91 __ z_lg(temp2_reg, Address(temp2_reg)); 92 __ compareU64_and_branch(temp_reg, temp2_reg, Assembler::bcondEqual, L_ok); 93 94 intptr_t super_check_offset = klass->super_check_offset(); 95 __ z_lg(temp_reg, Address(temp_reg, super_check_offset)); 96 __ compareU64_and_branch(temp_reg, temp2_reg, Assembler::bcondEqual, L_ok); 97 __ BIND(L_bad); 98 __ stop(error_message); 99 __ BIND(L_ok); 100 101 BLOCK_COMMENT("} verify_klass"); 102 } 103 104 void MethodHandles::verify_ref_kind(MacroAssembler* _masm, int ref_kind, 105 Register member_reg, Register temp ) { 106 NearLabel L; 107 BLOCK_COMMENT("verify_ref_kind {"); 108 109 __ z_llgf(temp, 110 Address(member_reg, 111 NONZERO(java_lang_invoke_MemberName::flags_offset_in_bytes()))); 112 __ z_srl(temp, java_lang_invoke_MemberName::MN_REFERENCE_KIND_SHIFT); 113 __ z_nilf(temp, java_lang_invoke_MemberName::MN_REFERENCE_KIND_MASK); 114 __ compare32_and_branch(temp, constant(ref_kind), Assembler::bcondEqual, L); 115 116 { 117 char *buf = NEW_C_HEAP_ARRAY(char, 100, mtInternal); 118 119 jio_snprintf(buf, 100, "verify_ref_kind expected %x", ref_kind); 120 if (ref_kind == JVM_REF_invokeVirtual || ref_kind == JVM_REF_invokeSpecial) { 121 // Could do this for all ref_kinds, but would explode assembly code size. 122 trace_method_handle(_masm, buf); 123 } 124 __ stop(buf); 125 } 126 127 BLOCK_COMMENT("} verify_ref_kind"); 128 129 __ bind(L); 130 } 131 #endif // ASSERT 132 133 void MethodHandles::jump_from_method_handle(MacroAssembler* _masm, Register method, Register target, 134 Register temp, bool for_compiler_entry) { 135 assert(method == Z_method, "interpreter calling convention"); 136 __ verify_method_ptr(method); 137 138 assert(target != method, "don 't you kill the method reg!"); 139 140 Label L_no_such_method; 141 142 if (!for_compiler_entry && JvmtiExport::can_post_interpreter_events()) { 143 // JVMTI events, such as single-stepping, are implemented partly 144 // by avoiding running compiled code in threads for which the 145 // event is enabled. Check here for interp_only_mode if these 146 // events CAN be enabled. 147 __ verify_thread(); 148 149 Label run_compiled_code; 150 151 __ load_and_test_int(temp, Address(Z_thread, JavaThread::interp_only_mode_offset())); 152 __ z_bre(run_compiled_code); 153 154 // Null method test is replicated below in compiled case, 155 // it might be able to address across the verify_thread(). 156 __ z_ltgr(temp, method); 157 __ z_bre(L_no_such_method); 158 159 __ z_lg(target, Address(method, Method::interpreter_entry_offset())); 160 __ z_br(target); 161 162 __ bind(run_compiled_code); 163 } 164 165 // Compiled case, either static or fall-through from runtime conditional. 166 __ z_ltgr(temp, method); 167 __ z_bre(L_no_such_method); 168 169 ByteSize offset = for_compiler_entry ? 170 Method::from_compiled_offset() : Method::from_interpreted_offset(); 171 Address method_from(method, offset); 172 173 __ z_lg(target, method_from); 174 __ z_br(target); 175 176 __ bind(L_no_such_method); 177 assert(StubRoutines::throw_AbstractMethodError_entry() != NULL, "not yet generated!"); 178 __ load_const_optimized(target, StubRoutines::throw_AbstractMethodError_entry()); 179 __ z_br(target); 180 } 181 182 void MethodHandles::jump_to_lambda_form(MacroAssembler* _masm, 183 Register recv, Register method_temp, 184 Register temp2, Register temp3, 185 bool for_compiler_entry) { 186 187 // This is the initial entry point of a lazy method handle. 188 // After type checking, it picks up the invoker from the LambdaForm. 189 assert_different_registers(recv, method_temp, temp2, temp3); 190 assert(method_temp == Z_method, "required register for loading method"); 191 192 BLOCK_COMMENT("jump_to_lambda_form {"); 193 194 // Load the invoker, as MH -> MH.form -> LF.vmentry 195 __ verify_oop(recv); 196 __ load_heap_oop(method_temp, 197 Address(recv, 198 NONZERO(java_lang_invoke_MethodHandle::form_offset_in_bytes()))); 199 __ verify_oop(method_temp); 200 __ load_heap_oop(method_temp, 201 Address(method_temp, 202 NONZERO(java_lang_invoke_LambdaForm::vmentry_offset_in_bytes()))); 203 __ verify_oop(method_temp); 204 __ load_heap_oop(method_temp, 205 Address(method_temp, 206 NONZERO(java_lang_invoke_MemberName::method_offset_in_bytes()))); 207 __ verify_oop(method_temp); 208 __ z_lg(method_temp, 209 Address(method_temp, 210 NONZERO(java_lang_invoke_ResolvedMethodName::vmtarget_offset_in_bytes()))); 211 212 if (VerifyMethodHandles && !for_compiler_entry) { 213 // Make sure recv is already on stack. 214 NearLabel L; 215 Address paramSize(temp2, ConstMethod::size_of_parameters_offset()); 216 217 __ z_lg(temp2, Address(method_temp, Method::const_offset())); 218 __ load_sized_value(temp2, paramSize, sizeof(u2), /*is_signed*/ false); 219 // if (temp2 != recv) stop 220 __ z_lg(temp2, __ argument_address(temp2, temp2, 0)); 221 __ compare64_and_branch(temp2, recv, Assembler::bcondEqual, L); 222 __ stop("receiver not on stack"); 223 __ BIND(L); 224 } 225 226 jump_from_method_handle(_masm, method_temp, temp2, Z_R0, for_compiler_entry); 227 228 BLOCK_COMMENT("} jump_to_lambda_form"); 229 } 230 231 // code generation 232 address MethodHandles::generate_method_handle_interpreter_entry(MacroAssembler* _masm, 233 vmIntrinsics::ID iid) { 234 const bool not_for_compiler_entry = false; // This is the interpreter entry. 235 assert(is_signature_polymorphic(iid), "expected invoke iid"); 236 237 if (iid == vmIntrinsics::_invokeGeneric || iid == vmIntrinsics::_compiledLambdaForm) { 238 // Perhaps surprisingly, the symbolic references visible to Java 239 // are not directly used. They are linked to Java-generated 240 // adapters via MethodHandleNatives.linkMethod. They all allow an 241 // appendix argument. 242 __ should_not_reach_here(); // Empty stubs make SG sick. 243 return NULL; 244 } 245 246 // Z_R10: sender SP (must preserve; see prepare_to_jump_from_interprted) 247 // Z_method: method 248 // Z_ARG1 (Gargs): incoming argument list (must preserve) 249 Register Z_R4_param_size = Z_R4; // size of parameters 250 address code_start = __ pc(); 251 252 // Here is where control starts out: 253 __ align(CodeEntryAlignment); 254 255 address entry_point = __ pc(); 256 257 if (VerifyMethodHandles) { 258 Label L; 259 BLOCK_COMMENT("verify_intrinsic_id {"); 260 261 // Supplement to 8139891: _intrinsic_id exceeded 1-byte size limit. 262 if (Method::intrinsic_id_size_in_bytes() == 1) { 263 __ z_cli(Address(Z_method, Method::intrinsic_id_offset_in_bytes()), (int)iid); 264 } else { 265 assert(Method::intrinsic_id_size_in_bytes() == 2, "size error: check Method::_intrinsic_id"); 266 __ z_lh(Z_R0_scratch, Address(Z_method, Method::intrinsic_id_offset_in_bytes())); 267 __ z_chi(Z_R0_scratch, (int)iid); 268 } 269 __ z_bre(L); 270 271 if (iid == vmIntrinsics::_linkToVirtual || iid == vmIntrinsics::_linkToSpecial) { 272 // Could do this for all kinds, but would explode assembly code size. 273 trace_method_handle(_masm, "bad Method::intrinsic_id"); 274 } 275 276 __ stop("bad Method::intrinsic_id"); 277 __ bind(L); 278 279 BLOCK_COMMENT("} verify_intrinsic_id"); 280 } 281 282 // First task: Find out how big the argument list is. 283 Address Z_R4_first_arg_addr; 284 int ref_kind = signature_polymorphic_intrinsic_ref_kind(iid); 285 286 assert(ref_kind != 0 || iid == vmIntrinsics::_invokeBasic, 287 "must be _invokeBasic or a linkTo intrinsic"); 288 289 if (ref_kind == 0 || MethodHandles::ref_kind_has_receiver(ref_kind)) { 290 Address paramSize(Z_R1_scratch, ConstMethod::size_of_parameters_offset()); 291 292 __ z_lg(Z_R1_scratch, Address(Z_method, Method::const_offset())); 293 __ load_sized_value(Z_R4_param_size, paramSize, sizeof(u2), /*is_signed*/ false); 294 Z_R4_first_arg_addr = __ argument_address(Z_R4_param_size, Z_R4_param_size, 0); 295 } else { 296 DEBUG_ONLY(Z_R4_param_size = noreg); 297 } 298 299 Register Z_mh = noreg; 300 if (!is_signature_polymorphic_static(iid)) { 301 Z_mh = Z_ARG4; 302 __ z_lg(Z_mh, Z_R4_first_arg_addr); 303 DEBUG_ONLY(Z_R4_param_size = noreg); 304 } 305 306 // Z_R4_first_arg_addr is live! 307 308 trace_method_handle_interpreter_entry(_masm, iid); 309 310 if (iid == vmIntrinsics::_invokeBasic) { 311 __ pc(); // just for the block comment 312 generate_method_handle_dispatch(_masm, iid, Z_mh, noreg, not_for_compiler_entry); 313 } else { 314 // Adjust argument list by popping the trailing MemberName argument. 315 Register Z_recv = noreg; 316 317 if (MethodHandles::ref_kind_has_receiver(ref_kind)) { 318 // Load the receiver (not the MH; the actual MemberName's receiver) 319 // up from the interpreter stack. 320 __ z_lg(Z_recv = Z_R5, Z_R4_first_arg_addr); 321 DEBUG_ONLY(Z_R4_param_size = noreg); 322 } 323 324 Register Z_member = Z_method; // MemberName ptr; incoming method ptr is dead now 325 326 __ z_lg(Z_member, __ argument_address(constant(1))); 327 __ add2reg(Z_esp, Interpreter::stackElementSize); 328 generate_method_handle_dispatch(_masm, iid, Z_recv, Z_member, not_for_compiler_entry); 329 } 330 331 return entry_point; 332 } 333 334 void MethodHandles::generate_method_handle_dispatch(MacroAssembler* _masm, 335 vmIntrinsics::ID iid, 336 Register receiver_reg, 337 Register member_reg, 338 bool for_compiler_entry) { 339 assert(is_signature_polymorphic(iid), "expected invoke iid"); 340 341 Register temp1 = for_compiler_entry ? Z_R10 : Z_R6; 342 Register temp2 = Z_R12; 343 Register temp3 = Z_R11; 344 Register temp4 = Z_R13; 345 346 if (for_compiler_entry) { 347 assert(receiver_reg == (iid == vmIntrinsics::_linkToStatic ? noreg : Z_ARG1), 348 "only valid assignment"); 349 } 350 if (receiver_reg != noreg) { 351 assert_different_registers(temp1, temp2, temp3, temp4, receiver_reg); 352 } 353 if (member_reg != noreg) { 354 assert_different_registers(temp1, temp2, temp3, temp4, member_reg); 355 } 356 if (!for_compiler_entry) { // Don't trash last SP. 357 assert_different_registers(temp1, temp2, temp3, temp4, Z_R10); 358 } 359 360 if (iid == vmIntrinsics::_invokeBasic) { 361 __ pc(); // Just for the block comment. 362 // Indirect through MH.form.vmentry.vmtarget. 363 jump_to_lambda_form(_masm, receiver_reg, Z_method, Z_R1, temp3, for_compiler_entry); 364 return; 365 } 366 367 // The method is a member invoker used by direct method handles. 368 if (VerifyMethodHandles) { 369 // Make sure the trailing argument really is a MemberName (caller responsibility). 370 verify_klass(_masm, member_reg, 371 SystemDictionary::WK_KLASS_ENUM_NAME(MemberName_klass), 372 temp1, temp2, 373 "MemberName required for invokeVirtual etc."); 374 } 375 376 Address member_clazz( member_reg, NONZERO(java_lang_invoke_MemberName::clazz_offset_in_bytes())); 377 Address member_vmindex( member_reg, NONZERO(java_lang_invoke_MemberName::vmindex_offset_in_bytes())); 378 Address member_vmtarget(member_reg, NONZERO(java_lang_invoke_MemberName::method_offset_in_bytes())); 379 Address vmtarget_method(Z_method, NONZERO(java_lang_invoke_ResolvedMethodName::vmtarget_offset_in_bytes())); 380 Register temp1_recv_klass = temp1; 381 382 if (iid != vmIntrinsics::_linkToStatic) { 383 __ verify_oop(receiver_reg); 384 if (iid == vmIntrinsics::_linkToSpecial) { 385 // Don't actually load the klass; just null-check the receiver. 386 __ null_check(receiver_reg); 387 } else { 388 // Load receiver klass itself. 389 __ null_check(receiver_reg, Z_R0, oopDesc::klass_offset_in_bytes()); 390 __ load_klass(temp1_recv_klass, receiver_reg); 391 __ verify_klass_ptr(temp1_recv_klass); 392 } 393 BLOCK_COMMENT("check_receiver {"); 394 // The receiver for the MemberName must be in receiver_reg. 395 // Check the receiver against the MemberName.clazz. 396 if (VerifyMethodHandles && iid == vmIntrinsics::_linkToSpecial) { 397 // Did not load it above... 398 __ load_klass(temp1_recv_klass, receiver_reg); 399 __ verify_klass_ptr(temp1_recv_klass); 400 } 401 402 if (VerifyMethodHandles && iid != vmIntrinsics::_linkToInterface) { 403 NearLabel L_ok; 404 Register temp2_defc = temp2; 405 406 __ load_heap_oop(temp2_defc, member_clazz); 407 load_klass_from_Class(_masm, temp2_defc, temp3, temp4); 408 __ verify_klass_ptr(temp2_defc); 409 __ check_klass_subtype(temp1_recv_klass, temp2_defc, temp3, temp4, L_ok); 410 // If we get here, the type check failed! 411 __ stop("receiver class disagrees with MemberName.clazz"); 412 __ bind(L_ok); 413 } 414 BLOCK_COMMENT("} check_receiver"); 415 } 416 if (iid == vmIntrinsics::_linkToSpecial || iid == vmIntrinsics::_linkToStatic) { 417 DEBUG_ONLY(temp1_recv_klass = noreg); // These guys didn't load the recv_klass. 418 } 419 420 // Live registers at this point: 421 // member_reg - MemberName that was the trailing argument. 422 // temp1_recv_klass - Klass of stacked receiver, if needed. 423 // Z_R10 - Interpreter linkage if interpreted. 424 425 bool method_is_live = false; 426 427 switch (iid) { 428 case vmIntrinsics::_linkToSpecial: 429 if (VerifyMethodHandles) { 430 verify_ref_kind(_masm, JVM_REF_invokeSpecial, member_reg, temp3); 431 } 432 __ load_heap_oop(Z_method, member_vmtarget); 433 __ z_lg(Z_method, vmtarget_method); 434 method_is_live = true; 435 break; 436 437 case vmIntrinsics::_linkToStatic: 438 if (VerifyMethodHandles) { 439 verify_ref_kind(_masm, JVM_REF_invokeStatic, member_reg, temp3); 440 } 441 __ load_heap_oop(Z_method, member_vmtarget); 442 __ z_lg(Z_method, vmtarget_method); 443 method_is_live = true; 444 break; 445 446 case vmIntrinsics::_linkToVirtual: { 447 // Same as TemplateTable::invokevirtual, minus the CP setup and profiling. 448 if (VerifyMethodHandles) { 449 verify_ref_kind(_masm, JVM_REF_invokeVirtual, member_reg, temp3); 450 } 451 452 // Pick out the vtable index from the MemberName, and then we can discard it. 453 Register temp2_index = temp2; 454 __ z_lg(temp2_index, member_vmindex); 455 456 if (VerifyMethodHandles) { 457 // if (member_vmindex < 0) stop 458 NearLabel L_index_ok; 459 __ compare32_and_branch(temp2_index, constant(0), Assembler::bcondNotLow, L_index_ok); 460 __ stop("no virtual index"); 461 __ BIND(L_index_ok); 462 } 463 464 // Note: The verifier invariants allow us to ignore MemberName.clazz and vmtarget 465 // at this point. And VerifyMethodHandles has already checked clazz, if needed. 466 467 // Get target method and entry point. 468 __ lookup_virtual_method(temp1_recv_klass, temp2_index, Z_method); 469 method_is_live = true; 470 break; 471 } 472 473 case vmIntrinsics::_linkToInterface: { 474 // Same as TemplateTable::invokeinterface, minus the CP setup 475 // and profiling, with different argument motion. 476 if (VerifyMethodHandles) { 477 verify_ref_kind(_masm, JVM_REF_invokeInterface, member_reg, temp3); 478 } 479 480 Register temp3_intf = temp3; 481 482 __ load_heap_oop(temp3_intf, member_clazz); 483 load_klass_from_Class(_masm, temp3_intf, temp2, temp4); 484 485 Register Z_index = Z_method; 486 487 __ z_lg(Z_index, member_vmindex); 488 489 if (VerifyMethodHandles) { 490 NearLabel L; 491 // if (member_vmindex < 0) stop 492 __ compare32_and_branch(Z_index, constant(0), Assembler::bcondNotLow, L); 493 __ stop("invalid vtable index for MH.invokeInterface"); 494 __ bind(L); 495 } 496 497 // Given interface, index, and recv klass, dispatch to the implementation method. 498 Label L_no_such_interface; 499 __ lookup_interface_method(temp1_recv_klass, temp3_intf, 500 // Note: next two args must be the same: 501 Z_index, Z_method, temp2, noreg, 502 L_no_such_interface); 503 jump_from_method_handle(_masm, Z_method, temp2, Z_R0, for_compiler_entry); 504 505 __ bind(L_no_such_interface); 506 507 // Throw exception. 508 __ load_const_optimized(Z_R1, StubRoutines::throw_IncompatibleClassChangeError_entry()); 509 __ z_br(Z_R1); 510 break; 511 } 512 513 default: 514 fatal("unexpected intrinsic %d: %s", iid, vmIntrinsics::name_at(iid)); 515 break; 516 } 517 518 if (method_is_live) { 519 // Live at this point: Z_method, O5_savedSP (if interpreted). 520 521 // After figuring out which concrete method to call, jump into it. 522 // Note that this works in the interpreter with no data motion. 523 // But the compiled version will require that rcx_recv be shifted out. 524 jump_from_method_handle(_masm, Z_method, temp1, Z_R0, for_compiler_entry); 525 } 526 } 527 528 #ifndef PRODUCT 529 void trace_method_handle_stub(const char* adaptername, 530 oopDesc* mh, 531 intptr_t* sender_sp, 532 intptr_t* args, 533 intptr_t* tracing_fp) { 534 bool has_mh = (strstr(adaptername, "/static") == NULL && 535 strstr(adaptername, "linkTo") == NULL); // Static linkers don't have MH. 536 const char* mh_reg_name = has_mh ? "Z_R4_mh" : "Z_R4"; 537 tty->print_cr("MH %s %s=" INTPTR_FORMAT " sender_sp=" INTPTR_FORMAT " args=" INTPTR_FORMAT, 538 adaptername, mh_reg_name, 539 p2i(mh), p2i(sender_sp), p2i(args)); 540 541 if (Verbose) { 542 // Dumping last frame with frame::describe. 543 544 JavaThread* p = JavaThread::active(); 545 546 ResourceMark rm; 547 PRESERVE_EXCEPTION_MARK; // May not be needed by safer and unexpensive here. 548 FrameValues values; 549 550 // Note: We want to allow trace_method_handle from any call site. 551 // While trace_method_handle creates a frame, it may be entered 552 // without a valid return PC in Z_R14 (e.g. not just after a call). 553 // Walking that frame could lead to failures due to that invalid PC. 554 // => carefully detect that frame when doing the stack walking. 555 556 // Walk up to the right frame using the "tracing_fp" argument. 557 frame cur_frame = os::current_frame(); // Current C frame. 558 559 while (cur_frame.fp() != tracing_fp) { 560 cur_frame = os::get_sender_for_C_frame(&cur_frame); 561 } 562 563 // Safely create a frame and call frame::describe. 564 intptr_t *dump_sp = cur_frame.sender_sp(); 565 intptr_t *dump_fp = cur_frame.link(); 566 567 bool walkable = has_mh; // Whether the traced frame shoud be walkable. 568 569 // The sender for cur_frame is the caller of trace_method_handle. 570 if (walkable) { 571 // The previous definition of walkable may have to be refined 572 // if new call sites cause the next frame constructor to start 573 // failing. Alternatively, frame constructors could be 574 // modified to support the current or future non walkable 575 // frames (but this is more intrusive and is not considered as 576 // part of this RFE, which will instead use a simpler output). 577 frame dump_frame = frame(dump_sp); 578 dump_frame.describe(values, 1); 579 } else { 580 // Robust dump for frames which cannot be constructed from sp/younger_sp 581 // Add descriptions without building a Java frame to avoid issues. 582 values.describe(-1, dump_fp, "fp for #1 <not parsed, cannot trust pc>"); 583 values.describe(-1, dump_sp, "sp"); 584 } 585 586 bool has_args = has_mh; // Whether Z_esp is meaningful. 587 588 // Mark args, if seems valid (may not be valid for some adapters). 589 if (has_args) { 590 if ((args >= dump_sp) && (args < dump_fp)) { 591 values.describe(-1, args, "*Z_esp"); 592 } 593 } 594 595 // Note: the unextended_sp may not be correct. 596 tty->print_cr(" stack layout:"); 597 values.print(p); 598 if (has_mh && oopDesc::is_oop(mh)) { 599 mh->print(); 600 if (java_lang_invoke_MethodHandle::is_instance(mh)) { 601 if (java_lang_invoke_MethodHandle::form_offset_in_bytes() != 0) { 602 java_lang_invoke_MethodHandle::form(mh)->print(); 603 } 604 } 605 } 606 } 607 } 608 609 void MethodHandles::trace_method_handle(MacroAssembler* _masm, const char* adaptername) { 610 if (!TraceMethodHandles) { return; } 611 612 // If arg registers are contiguous, we can use STMG/LMG. 613 assert((Z_ARG5->encoding() - Z_ARG1->encoding() + 1) == RegisterImpl::number_of_arg_registers, "Oops"); 614 615 BLOCK_COMMENT("trace_method_handle {"); 616 617 // Save argument registers (they are used in raise exception stub). 618 // Argument registers have contiguous register numbers -> we can use stmg/lmg. 619 __ z_stmg(Z_ARG1, Z_ARG5, 16, Z_SP); 620 621 // Setup arguments. 622 __ z_lgr(Z_ARG2, Z_ARG4); // mh, see generate_method_handle_interpreter_entry() 623 __ z_lgr(Z_ARG3, Z_R10); // sender_sp 624 __ z_lgr(Z_ARG4, Z_esp); 625 __ load_const_optimized(Z_ARG1, (void *)adaptername); 626 __ z_lgr(Z_ARG5, Z_SP); // tracing_fp 627 __ save_return_pc(); // saves Z_R14 628 __ push_frame_abi160(0); 629 __ call_VM_leaf(CAST_FROM_FN_PTR(address, trace_method_handle_stub)); 630 __ pop_frame(); 631 __ restore_return_pc(); // restores to Z_R14 632 633 // Restore argument registers 634 __ z_lmg(Z_ARG1, Z_ARG5, 16, Z_SP); 635 __ zap_from_to(Z_SP, Z_SP, Z_R0, Z_R1, 50, -1); 636 __ zap_from_to(Z_SP, Z_SP, Z_R0, Z_R1, -1, 5); 637 638 BLOCK_COMMENT("} trace_method_handle"); 639 } 640 #endif // !PRODUCT