1 /* 2 * Copyright (c) 2008, 2011, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. 8 * 9 * This code is distributed in the hope that it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 12 * version 2 for more details (a copy is included in the LICENSE file that 13 * accompanied this code). 14 * 15 * You should have received a copy of the GNU General Public License version 16 * 2 along with this work; if not, write to the Free Software Foundation, 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 18 * 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 20 * or visit www.oracle.com if you need additional information or have any 21 * questions. 22 * 23 */ 24 25 #include "precompiled.hpp" 26 #include "interpreter/interpreter.hpp" 27 #include "memory/allocation.inline.hpp" 28 #include "prims/methodHandles.hpp" 29 30 #define __ _masm-> 31 32 #ifdef PRODUCT 33 #define BLOCK_COMMENT(str) /* nothing */ 34 #else 35 #define BLOCK_COMMENT(str) __ block_comment(str) 36 #endif 37 38 #define BIND(label) bind(label); BLOCK_COMMENT(#label ":") 39 40 address MethodHandleEntry::start_compiled_entry(MacroAssembler* _masm, 41 address interpreted_entry) { 42 // Just before the actual machine code entry point, allocate space 43 // for a MethodHandleEntry::Data record, so that we can manage everything 44 // from one base pointer. 45 __ align(wordSize); 46 address target = __ pc() + sizeof(Data); 47 while (__ pc() < target) { 48 __ nop(); 49 __ align(wordSize); 50 } 51 52 MethodHandleEntry* me = (MethodHandleEntry*) __ pc(); 53 me->set_end_address(__ pc()); // set a temporary end_address 54 me->set_from_interpreted_entry(interpreted_entry); 55 me->set_type_checking_entry(NULL); 56 57 return (address) me; 58 } 59 60 MethodHandleEntry* MethodHandleEntry::finish_compiled_entry(MacroAssembler* _masm, 61 address start_addr) { 62 MethodHandleEntry* me = (MethodHandleEntry*) start_addr; 63 assert(me->end_address() == start_addr, "valid ME"); 64 65 // Fill in the real end_address: 66 __ align(wordSize); 67 me->set_end_address(__ pc()); 68 69 return me; 70 } 71 72 // stack walking support 73 74 frame MethodHandles::ricochet_frame_sender(const frame& fr, RegisterMap *map) { 75 //RicochetFrame* f = RicochetFrame::from_frame(fr); 76 // Cf. is_interpreted_frame path of frame::sender 77 intptr_t* younger_sp = fr.sp(); 78 intptr_t* sp = fr.sender_sp(); 79 map->make_integer_regs_unsaved(); 80 map->shift_window(sp, younger_sp); 81 bool this_frame_adjusted_stack = true; // I5_savedSP is live in this RF 82 return frame(sp, younger_sp, this_frame_adjusted_stack); 83 } 84 85 void MethodHandles::ricochet_frame_oops_do(const frame& fr, OopClosure* blk, const RegisterMap* reg_map) { 86 ResourceMark rm; 87 RicochetFrame* f = RicochetFrame::from_frame(fr); 88 89 // pick up the argument type descriptor: 90 Thread* thread = Thread::current(); 91 Handle cookie(thread, f->compute_saved_args_layout(true, true)); 92 93 // process fixed part 94 blk->do_oop((oop*)f->saved_target_addr()); 95 blk->do_oop((oop*)f->saved_args_layout_addr()); 96 97 // process variable arguments: 98 if (cookie.is_null()) return; // no arguments to describe 99 100 // the cookie is actually the invokeExact method for my target 101 // his argument signature is what I'm interested in 102 assert(cookie->is_method(), ""); 103 methodHandle invoker(thread, methodOop(cookie())); 104 assert(invoker->name() == vmSymbols::invokeExact_name(), "must be this kind of method"); 105 assert(!invoker->is_static(), "must have MH argument"); 106 int slot_count = invoker->size_of_parameters(); 107 assert(slot_count >= 1, "must include 'this'"); 108 intptr_t* base = f->saved_args_base(); 109 intptr_t* retval = NULL; 110 if (f->has_return_value_slot()) 111 retval = f->return_value_slot_addr(); 112 int slot_num = slot_count - 1; 113 intptr_t* loc = &base[slot_num]; 114 //blk->do_oop((oop*) loc); // original target, which is irrelevant 115 int arg_num = 0; 116 for (SignatureStream ss(invoker->signature()); !ss.is_done(); ss.next()) { 117 if (ss.at_return_type()) continue; 118 BasicType ptype = ss.type(); 119 if (ptype == T_ARRAY) ptype = T_OBJECT; // fold all refs to T_OBJECT 120 assert(ptype >= T_BOOLEAN && ptype <= T_OBJECT, "not array or void"); 121 slot_num -= type2size[ptype]; 122 loc = &base[slot_num]; 123 bool is_oop = (ptype == T_OBJECT && loc != retval); 124 if (is_oop) blk->do_oop((oop*)loc); 125 arg_num += 1; 126 } 127 assert(slot_num == 0, "must have processed all the arguments"); 128 } 129 130 // Ricochet Frames 131 const Register MethodHandles::RicochetFrame::L1_continuation = L1; 132 const Register MethodHandles::RicochetFrame::L2_saved_target = L2; 133 const Register MethodHandles::RicochetFrame::L3_saved_args_layout = L3; 134 const Register MethodHandles::RicochetFrame::L4_saved_args_base = L4; // cf. Gargs = G4 135 const Register MethodHandles::RicochetFrame::L5_conversion = L5; 136 #ifdef ASSERT 137 const Register MethodHandles::RicochetFrame::L0_magic_number_1 = L0; 138 #endif //ASSERT 139 140 oop MethodHandles::RicochetFrame::compute_saved_args_layout(bool read_cache, bool write_cache) { 141 if (read_cache) { 142 oop cookie = saved_args_layout(); 143 if (cookie != NULL) return cookie; 144 } 145 oop target = saved_target(); 146 oop mtype = java_lang_invoke_MethodHandle::type(target); 147 oop mtform = java_lang_invoke_MethodType::form(mtype); 148 oop cookie = java_lang_invoke_MethodTypeForm::vmlayout(mtform); 149 if (write_cache) { 150 (*saved_args_layout_addr()) = cookie; 151 } 152 return cookie; 153 } 154 155 void MethodHandles::RicochetFrame::generate_ricochet_blob(MacroAssembler* _masm, 156 // output params: 157 int* bounce_offset, 158 int* exception_offset, 159 int* frame_size_in_words) { 160 (*frame_size_in_words) = RicochetFrame::frame_size_in_bytes() / wordSize; 161 162 address start = __ pc(); 163 164 #ifdef ASSERT 165 __ illtrap(0); __ illtrap(0); __ illtrap(0); 166 // here's a hint of something special: 167 __ set(MAGIC_NUMBER_1, G0); 168 __ set(MAGIC_NUMBER_2, G0); 169 #endif //ASSERT 170 __ illtrap(0); // not reached 171 172 // Return values are in registers. 173 // L1_continuation contains a cleanup continuation we must return 174 // to. 175 176 (*bounce_offset) = __ pc() - start; 177 BLOCK_COMMENT("ricochet_blob.bounce"); 178 179 if (VerifyMethodHandles) RicochetFrame::verify_clean(_masm); 180 trace_method_handle(_masm, "ricochet_blob.bounce"); 181 182 __ JMP(L1_continuation, 0); 183 __ delayed()->nop(); 184 __ illtrap(0); 185 186 DEBUG_ONLY(__ set(MAGIC_NUMBER_2, G0)); 187 188 (*exception_offset) = __ pc() - start; 189 BLOCK_COMMENT("ricochet_blob.exception"); 190 191 // compare this to Interpreter::rethrow_exception_entry, which is parallel code 192 // for example, see TemplateInterpreterGenerator::generate_throw_exception 193 // Live registers in: 194 // Oexception (O0): exception 195 // Oissuing_pc (O1): return address/pc that threw exception (ignored, always equal to bounce addr) 196 __ verify_oop(Oexception); 197 198 // Take down the frame. 199 200 // Cf. InterpreterMacroAssembler::remove_activation. 201 leave_ricochet_frame(_masm, /*recv_reg=*/ noreg, I5_savedSP, I7); 202 203 // We are done with this activation frame; find out where to go next. 204 // The continuation point will be an exception handler, which expects 205 // the following registers set up: 206 // 207 // Oexception: exception 208 // Oissuing_pc: the local call that threw exception 209 // Other On: garbage 210 // In/Ln: the contents of the caller's register window 211 // 212 // We do the required restore at the last possible moment, because we 213 // need to preserve some state across a runtime call. 214 // (Remember that the caller activation is unknown--it might not be 215 // interpreted, so things like Lscratch are useless in the caller.) 216 __ mov(Oexception, Oexception ->after_save()); // get exception in I0 so it will be on O0 after restore 217 __ add(I7, frame::pc_return_offset, Oissuing_pc->after_save()); // likewise set I1 to a value local to the caller 218 __ call_VM_leaf(L7_thread_cache, 219 CAST_FROM_FN_PTR(address, SharedRuntime::exception_handler_for_return_address), 220 G2_thread, Oissuing_pc->after_save()); 221 222 // The caller's SP was adjusted upon method entry to accomodate 223 // the callee's non-argument locals. Undo that adjustment. 224 __ JMP(O0, 0); // return exception handler in caller 225 __ delayed()->restore(I5_savedSP, G0, SP); 226 227 // (same old exception object is already in Oexception; see above) 228 // Note that an "issuing PC" is actually the next PC after the call 229 } 230 231 void MethodHandles::RicochetFrame::enter_ricochet_frame(MacroAssembler* _masm, 232 Register recv_reg, 233 Register argv_reg, 234 address return_handler) { 235 // does not include the __ save() 236 assert(argv_reg == Gargs, ""); 237 Address G3_mh_vmtarget( recv_reg, java_lang_invoke_MethodHandle::vmtarget_offset_in_bytes()); 238 Address G3_amh_conversion(recv_reg, java_lang_invoke_AdapterMethodHandle::conversion_offset_in_bytes()); 239 240 // Create the RicochetFrame. 241 // Unlike on x86 we can store all required information in local 242 // registers. 243 BLOCK_COMMENT("push RicochetFrame {"); 244 __ set(ExternalAddress(return_handler), L1_continuation); 245 __ load_heap_oop(G3_mh_vmtarget, L2_saved_target); 246 __ mov(G0, L3_saved_args_layout); 247 __ mov(Gargs, L4_saved_args_base); 248 __ lduw(G3_amh_conversion, L5_conversion); // 32-bit field 249 // I5, I6, I7 are already set up 250 DEBUG_ONLY(__ set((int32_t) MAGIC_NUMBER_1, L0_magic_number_1)); 251 BLOCK_COMMENT("} RicochetFrame"); 252 } 253 254 void MethodHandles::RicochetFrame::leave_ricochet_frame(MacroAssembler* _masm, 255 Register recv_reg, 256 Register new_sp_reg, 257 Register sender_pc_reg) { 258 assert(new_sp_reg == I5_savedSP, "exact_sender_sp already in place"); 259 assert(sender_pc_reg == I7, "in a fixed place"); 260 // does not include the __ ret() & __ restore() 261 assert_different_registers(recv_reg, new_sp_reg, sender_pc_reg); 262 // Take down the frame. 263 // Cf. InterpreterMacroAssembler::remove_activation. 264 BLOCK_COMMENT("end_ricochet_frame {"); 265 if (recv_reg->is_valid()) 266 __ mov(L2_saved_target, recv_reg); 267 BLOCK_COMMENT("} end_ricochet_frame"); 268 } 269 270 // Emit code to verify that FP is pointing at a valid ricochet frame. 271 #ifdef ASSERT 272 enum { 273 ARG_LIMIT = 255, SLOP = 45, 274 // use this parameter for checking for garbage stack movements: 275 UNREASONABLE_STACK_MOVE = (ARG_LIMIT + SLOP) 276 // the slop defends against false alarms due to fencepost errors 277 }; 278 279 void MethodHandles::RicochetFrame::verify_clean(MacroAssembler* _masm) { 280 // The stack should look like this: 281 // ... keep1 | dest=42 | keep2 | magic | handler | magic | recursive args | [RF] 282 // Check various invariants. 283 284 Register O7_temp = O7, O5_temp = O5; 285 286 Label L_ok_1, L_ok_2, L_ok_3, L_ok_4; 287 BLOCK_COMMENT("verify_clean {"); 288 // Magic numbers must check out: 289 __ set((int32_t) MAGIC_NUMBER_1, O7_temp); 290 __ cmp(O7_temp, L0_magic_number_1); 291 __ br(Assembler::equal, false, Assembler::pt, L_ok_1); 292 __ delayed()->nop(); 293 __ stop("damaged ricochet frame: MAGIC_NUMBER_1 not found"); 294 295 __ BIND(L_ok_1); 296 297 // Arguments pointer must look reasonable: 298 #ifdef _LP64 299 Register FP_temp = O5_temp; 300 __ add(FP, STACK_BIAS, FP_temp); 301 #else 302 Register FP_temp = FP; 303 #endif 304 __ cmp(L4_saved_args_base, FP_temp); 305 __ br(Assembler::greaterEqualUnsigned, false, Assembler::pt, L_ok_2); 306 __ delayed()->nop(); 307 __ stop("damaged ricochet frame: L4 < FP"); 308 309 __ BIND(L_ok_2); 310 __ sub(L4_saved_args_base, UNREASONABLE_STACK_MOVE * Interpreter::stackElementSize, O7_temp); 311 __ cmp(O7_temp, FP_temp); 312 __ br(Assembler::lessEqualUnsigned, false, Assembler::pt, L_ok_3); 313 __ delayed()->nop(); 314 __ stop("damaged ricochet frame: (L4 - UNREASONABLE_STACK_MOVE) > FP"); 315 316 __ BIND(L_ok_3); 317 extract_conversion_dest_type(_masm, L5_conversion, O7_temp); 318 __ cmp(O7_temp, T_VOID); 319 __ br(Assembler::equal, false, Assembler::pt, L_ok_4); 320 __ delayed()->nop(); 321 extract_conversion_vminfo(_masm, L5_conversion, O5_temp); 322 __ ld_ptr(L4_saved_args_base, __ argument_offset(O5_temp, O5_temp), O7_temp); 323 assert(__ is_simm13(RETURN_VALUE_PLACEHOLDER), "must be simm13"); 324 __ cmp(O7_temp, (int32_t) RETURN_VALUE_PLACEHOLDER); 325 __ brx(Assembler::equal, false, Assembler::pt, L_ok_4); 326 __ delayed()->nop(); 327 __ stop("damaged ricochet frame: RETURN_VALUE_PLACEHOLDER not found"); 328 __ BIND(L_ok_4); 329 BLOCK_COMMENT("} verify_clean"); 330 } 331 #endif //ASSERT 332 333 void MethodHandles::load_klass_from_Class(MacroAssembler* _masm, Register klass_reg, Register temp_reg, Register temp2_reg) { 334 if (VerifyMethodHandles) 335 verify_klass(_masm, klass_reg, SystemDictionaryHandles::Class_klass(), temp_reg, temp2_reg, 336 "AMH argument is a Class"); 337 __ load_heap_oop(Address(klass_reg, java_lang_Class::klass_offset_in_bytes()), klass_reg); 338 } 339 340 void MethodHandles::load_conversion_vminfo(MacroAssembler* _masm, Address conversion_field_addr, Register reg) { 341 assert(CONV_VMINFO_SHIFT == 0, "preshifted"); 342 assert(CONV_VMINFO_MASK == right_n_bits(BitsPerByte), "else change type of following load"); 343 __ ldub(conversion_field_addr.plus_disp(BytesPerInt - 1), reg); 344 } 345 346 void MethodHandles::extract_conversion_vminfo(MacroAssembler* _masm, Register conversion_field_reg, Register reg) { 347 assert(CONV_VMINFO_SHIFT == 0, "preshifted"); 348 __ and3(conversion_field_reg, CONV_VMINFO_MASK, reg); 349 } 350 351 void MethodHandles::extract_conversion_dest_type(MacroAssembler* _masm, Register conversion_field_reg, Register reg) { 352 __ srl(conversion_field_reg, CONV_DEST_TYPE_SHIFT, reg); 353 __ and3(reg, 0x0F, reg); 354 } 355 356 void MethodHandles::load_stack_move(MacroAssembler* _masm, 357 Address G3_amh_conversion, 358 Register stack_move_reg) { 359 BLOCK_COMMENT("load_stack_move {"); 360 __ ldsw(G3_amh_conversion, stack_move_reg); 361 __ sra(stack_move_reg, CONV_STACK_MOVE_SHIFT, stack_move_reg); 362 if (VerifyMethodHandles) { 363 Label L_ok, L_bad; 364 int32_t stack_move_limit = 0x0800; // extra-large 365 __ cmp(stack_move_reg, stack_move_limit); 366 __ br(Assembler::greaterEqual, false, Assembler::pn, L_bad); 367 __ delayed()->nop(); 368 __ cmp(stack_move_reg, -stack_move_limit); 369 __ br(Assembler::greater, false, Assembler::pt, L_ok); 370 __ delayed()->nop(); 371 __ BIND(L_bad); 372 __ stop("load_stack_move of garbage value"); 373 __ BIND(L_ok); 374 } 375 BLOCK_COMMENT("} load_stack_move"); 376 } 377 378 #ifdef ASSERT 379 void MethodHandles::RicochetFrame::verify() const { 380 assert(magic_number_1() == MAGIC_NUMBER_1, ""); 381 if (!Universe::heap()->is_gc_active()) { 382 if (saved_args_layout() != NULL) { 383 assert(saved_args_layout()->is_method(), "must be valid oop"); 384 } 385 if (saved_target() != NULL) { 386 assert(java_lang_invoke_MethodHandle::is_instance(saved_target()), "checking frame value"); 387 } 388 } 389 int conv_op = adapter_conversion_op(conversion()); 390 assert(conv_op == java_lang_invoke_AdapterMethodHandle::OP_COLLECT_ARGS || 391 conv_op == java_lang_invoke_AdapterMethodHandle::OP_FOLD_ARGS || 392 conv_op == java_lang_invoke_AdapterMethodHandle::OP_PRIM_TO_REF, 393 "must be a sane conversion"); 394 if (has_return_value_slot()) { 395 assert(*return_value_slot_addr() == RETURN_VALUE_PLACEHOLDER, ""); 396 } 397 } 398 399 void MethodHandles::verify_argslot(MacroAssembler* _masm, Register argslot_reg, Register temp_reg, const char* error_message) { 400 // Verify that argslot lies within (Gargs, FP]. 401 Label L_ok, L_bad; 402 BLOCK_COMMENT("verify_argslot {"); 403 __ add(FP, STACK_BIAS, temp_reg); // STACK_BIAS is zero on !_LP64 404 __ cmp(argslot_reg, temp_reg); 405 __ brx(Assembler::greaterUnsigned, false, Assembler::pn, L_bad); 406 __ delayed()->nop(); 407 __ cmp(Gargs, argslot_reg); 408 __ brx(Assembler::lessEqualUnsigned, false, Assembler::pt, L_ok); 409 __ delayed()->nop(); 410 __ BIND(L_bad); 411 __ stop(error_message); 412 __ BIND(L_ok); 413 BLOCK_COMMENT("} verify_argslot"); 414 } 415 416 void MethodHandles::verify_argslots(MacroAssembler* _masm, 417 RegisterOrConstant arg_slots, 418 Register arg_slot_base_reg, 419 Register temp_reg, 420 Register temp2_reg, 421 bool negate_argslots, 422 const char* error_message) { 423 // Verify that [argslot..argslot+size) lies within (Gargs, FP). 424 Label L_ok, L_bad; 425 BLOCK_COMMENT("verify_argslots {"); 426 if (negate_argslots) { 427 if (arg_slots.is_constant()) { 428 arg_slots = -1 * arg_slots.as_constant(); 429 } else { 430 __ neg(arg_slots.as_register(), temp_reg); 431 arg_slots = temp_reg; 432 } 433 } 434 __ add(arg_slot_base_reg, __ argument_offset(arg_slots, temp_reg), temp_reg); 435 __ add(FP, STACK_BIAS, temp2_reg); // STACK_BIAS is zero on !_LP64 436 __ cmp(temp_reg, temp2_reg); 437 __ brx(Assembler::greaterUnsigned, false, Assembler::pn, L_bad); 438 __ delayed()->nop(); 439 // Gargs points to the first word so adjust by BytesPerWord 440 __ add(arg_slot_base_reg, BytesPerWord, temp_reg); 441 __ cmp(Gargs, temp_reg); 442 __ brx(Assembler::lessEqualUnsigned, false, Assembler::pt, L_ok); 443 __ delayed()->nop(); 444 __ BIND(L_bad); 445 __ stop(error_message); 446 __ BIND(L_ok); 447 BLOCK_COMMENT("} verify_argslots"); 448 } 449 450 // Make sure that arg_slots has the same sign as the given direction. 451 // If (and only if) arg_slots is a assembly-time constant, also allow it to be zero. 452 void MethodHandles::verify_stack_move(MacroAssembler* _masm, 453 RegisterOrConstant arg_slots, int direction) { 454 enum { UNREASONABLE_STACK_MOVE = 256 * 4 }; // limit of 255 arguments 455 bool allow_zero = arg_slots.is_constant(); 456 if (direction == 0) { direction = +1; allow_zero = true; } 457 assert(stack_move_unit() == -1, "else add extra checks here"); 458 if (arg_slots.is_register()) { 459 Label L_ok, L_bad; 460 BLOCK_COMMENT("verify_stack_move {"); 461 // __ btst(-stack_move_unit() - 1, arg_slots.as_register()); // no need 462 // __ br(Assembler::notZero, false, Assembler::pn, L_bad); 463 // __ delayed()->nop(); 464 __ cmp(arg_slots.as_register(), (int32_t) NULL_WORD); 465 if (direction > 0) { 466 __ br(allow_zero ? Assembler::less : Assembler::lessEqual, false, Assembler::pn, L_bad); 467 __ delayed()->nop(); 468 __ cmp(arg_slots.as_register(), (int32_t) UNREASONABLE_STACK_MOVE); 469 __ br(Assembler::less, false, Assembler::pn, L_ok); 470 __ delayed()->nop(); 471 } else { 472 __ br(allow_zero ? Assembler::greater : Assembler::greaterEqual, false, Assembler::pn, L_bad); 473 __ delayed()->nop(); 474 __ cmp(arg_slots.as_register(), (int32_t) -UNREASONABLE_STACK_MOVE); 475 __ br(Assembler::greater, false, Assembler::pn, L_ok); 476 __ delayed()->nop(); 477 } 478 __ BIND(L_bad); 479 if (direction > 0) 480 __ stop("assert arg_slots > 0"); 481 else 482 __ stop("assert arg_slots < 0"); 483 __ BIND(L_ok); 484 BLOCK_COMMENT("} verify_stack_move"); 485 } else { 486 intptr_t size = arg_slots.as_constant(); 487 if (direction < 0) size = -size; 488 assert(size >= 0, "correct direction of constant move"); 489 assert(size < UNREASONABLE_STACK_MOVE, "reasonable size of constant move"); 490 } 491 } 492 493 void MethodHandles::verify_klass(MacroAssembler* _masm, 494 Register obj_reg, KlassHandle klass, 495 Register temp_reg, Register temp2_reg, 496 const char* error_message) { 497 oop* klass_addr = klass.raw_value(); 498 assert(klass_addr >= SystemDictionaryHandles::Object_klass().raw_value() && 499 klass_addr <= SystemDictionaryHandles::Long_klass().raw_value(), 500 "must be one of the SystemDictionaryHandles"); 501 Label L_ok, L_bad; 502 BLOCK_COMMENT("verify_klass {"); 503 __ verify_oop(obj_reg); 504 __ br_null(obj_reg, false, Assembler::pn, L_bad); 505 __ delayed()->nop(); 506 __ load_klass(obj_reg, temp_reg); 507 __ set(ExternalAddress(klass_addr), temp2_reg); 508 __ ld_ptr(Address(temp2_reg, 0), temp2_reg); 509 __ cmp(temp_reg, temp2_reg); 510 __ brx(Assembler::equal, false, Assembler::pt, L_ok); 511 __ delayed()->nop(); 512 intptr_t super_check_offset = klass->super_check_offset(); 513 __ ld_ptr(Address(temp_reg, super_check_offset), temp_reg); 514 __ set(ExternalAddress(klass_addr), temp2_reg); 515 __ ld_ptr(Address(temp2_reg, 0), temp2_reg); 516 __ cmp(temp_reg, temp2_reg); 517 __ brx(Assembler::equal, false, Assembler::pt, L_ok); 518 __ delayed()->nop(); 519 __ BIND(L_bad); 520 __ stop(error_message); 521 __ BIND(L_ok); 522 BLOCK_COMMENT("} verify_klass"); 523 } 524 #endif // ASSERT 525 526 // Code generation 527 address MethodHandles::generate_method_handle_interpreter_entry(MacroAssembler* _masm) { 528 // I5_savedSP/O5_savedSP: sender SP (must preserve) 529 // G4 (Gargs): incoming argument list (must preserve) 530 // G5_method: invoke methodOop 531 // G3_method_handle: receiver method handle (must load from sp[MethodTypeForm.vmslots]) 532 // O0, O1, O2, O3, O4: garbage temps, blown away 533 Register O0_mtype = O0; 534 Register O1_scratch = O1; 535 Register O2_scratch = O2; 536 Register O3_scratch = O3; 537 Register O4_argslot = O4; 538 Register O4_argbase = O4; 539 540 // emit WrongMethodType path first, to enable back-branch from main path 541 Label wrong_method_type; 542 __ bind(wrong_method_type); 543 Label invoke_generic_slow_path; 544 assert(methodOopDesc::intrinsic_id_size_in_bytes() == sizeof(u1), "");; 545 __ ldub(Address(G5_method, methodOopDesc::intrinsic_id_offset_in_bytes()), O1_scratch); 546 __ cmp(O1_scratch, (int) vmIntrinsics::_invokeExact); 547 __ brx(Assembler::notEqual, false, Assembler::pt, invoke_generic_slow_path); 548 __ delayed()->nop(); 549 __ mov(O0_mtype, G5_method_type); // required by throw_WrongMethodType 550 // mov(G3_method_handle, G3_method_handle); // already in this register 551 __ jump_to(AddressLiteral(Interpreter::throw_WrongMethodType_entry()), O1_scratch); 552 __ delayed()->nop(); 553 554 // here's where control starts out: 555 __ align(CodeEntryAlignment); 556 address entry_point = __ pc(); 557 558 // fetch the MethodType from the method handle 559 // FIXME: Interpreter should transmit pre-popped stack pointer, to locate base of arg list. 560 // This would simplify several touchy bits of code. 561 // See 6984712: JSR 292 method handle calls need a clean argument base pointer 562 { 563 Register tem = G5_method; 564 for (jint* pchase = methodOopDesc::method_type_offsets_chain(); (*pchase) != -1; pchase++) { 565 __ ld_ptr(Address(tem, *pchase), O0_mtype); 566 tem = O0_mtype; // in case there is another indirection 567 } 568 } 569 570 // given the MethodType, find out where the MH argument is buried 571 __ load_heap_oop(Address(O0_mtype, __ delayed_value(java_lang_invoke_MethodType::form_offset_in_bytes, O1_scratch)), O4_argslot); 572 __ ldsw( Address(O4_argslot, __ delayed_value(java_lang_invoke_MethodTypeForm::vmslots_offset_in_bytes, O1_scratch)), O4_argslot); 573 __ add(__ argument_address(O4_argslot, O4_argslot, 1), O4_argbase); 574 // Note: argument_address uses its input as a scratch register! 575 Address mh_receiver_slot_addr(O4_argbase, -Interpreter::stackElementSize); 576 __ ld_ptr(mh_receiver_slot_addr, G3_method_handle); 577 578 trace_method_handle(_masm, "invokeExact"); 579 580 __ check_method_handle_type(O0_mtype, G3_method_handle, O1_scratch, wrong_method_type); 581 582 // Nobody uses the MH receiver slot after this. Make sure. 583 DEBUG_ONLY(__ set((int32_t) 0x999999, O1_scratch); __ st_ptr(O1_scratch, mh_receiver_slot_addr)); 584 585 __ jump_to_method_handle_entry(G3_method_handle, O1_scratch); 586 587 // for invokeGeneric (only), apply argument and result conversions on the fly 588 __ bind(invoke_generic_slow_path); 589 #ifdef ASSERT 590 if (VerifyMethodHandles) { 591 Label L; 592 __ ldub(Address(G5_method, methodOopDesc::intrinsic_id_offset_in_bytes()), O1_scratch); 593 __ cmp(O1_scratch, (int) vmIntrinsics::_invokeGeneric); 594 __ brx(Assembler::equal, false, Assembler::pt, L); 595 __ delayed()->nop(); 596 __ stop("bad methodOop::intrinsic_id"); 597 __ bind(L); 598 } 599 #endif //ASSERT 600 601 // make room on the stack for another pointer: 602 insert_arg_slots(_masm, 2 * stack_move_unit(), O4_argbase, O1_scratch, O2_scratch, O3_scratch); 603 // load up an adapter from the calling type (Java weaves this) 604 Register O2_form = O2_scratch; 605 Register O3_adapter = O3_scratch; 606 __ load_heap_oop(Address(O0_mtype, __ delayed_value(java_lang_invoke_MethodType::form_offset_in_bytes, O1_scratch)), O2_form); 607 __ load_heap_oop(Address(O2_form, __ delayed_value(java_lang_invoke_MethodTypeForm::genericInvoker_offset_in_bytes, O1_scratch)), O3_adapter); 608 __ verify_oop(O3_adapter); 609 __ st_ptr(O3_adapter, Address(O4_argbase, 1 * Interpreter::stackElementSize)); 610 // As a trusted first argument, pass the type being called, so the adapter knows 611 // the actual types of the arguments and return values. 612 // (Generic invokers are shared among form-families of method-type.) 613 __ st_ptr(O0_mtype, Address(O4_argbase, 0 * Interpreter::stackElementSize)); 614 // FIXME: assert that O3_adapter is of the right method-type. 615 __ mov(O3_adapter, G3_method_handle); 616 trace_method_handle(_masm, "invokeGeneric"); 617 __ jump_to_method_handle_entry(G3_method_handle, O1_scratch); 618 619 return entry_point; 620 } 621 622 // Workaround for C++ overloading nastiness on '0' for RegisterOrConstant. 623 static RegisterOrConstant constant(int value) { 624 return RegisterOrConstant(value); 625 } 626 627 static void load_vmargslot(MacroAssembler* _masm, Address vmargslot_addr, Register result) { 628 __ ldsw(vmargslot_addr, result); 629 } 630 631 static RegisterOrConstant adjust_SP_and_Gargs_down_by_slots(MacroAssembler* _masm, 632 RegisterOrConstant arg_slots, 633 Register temp_reg, Register temp2_reg) { 634 // Keep the stack pointer 2*wordSize aligned. 635 const int TwoWordAlignmentMask = right_n_bits(LogBytesPerWord + 1); 636 if (arg_slots.is_constant()) { 637 const int offset = arg_slots.as_constant() << LogBytesPerWord; 638 const int masked_offset = round_to(offset, 2 * BytesPerWord); 639 const int masked_offset2 = (offset + 1*BytesPerWord) & ~TwoWordAlignmentMask; 640 assert(masked_offset == masked_offset2, "must agree"); 641 __ sub(Gargs, offset, Gargs); 642 __ sub(SP, masked_offset, SP ); 643 return offset; 644 } else { 645 #ifdef ASSERT 646 { 647 Label L_ok; 648 __ cmp(arg_slots.as_register(), 0); 649 __ br(Assembler::greaterEqual, false, Assembler::pt, L_ok); 650 __ delayed()->nop(); 651 __ stop("negative arg_slots"); 652 __ bind(L_ok); 653 } 654 #endif 655 __ sll_ptr(arg_slots.as_register(), LogBytesPerWord, temp_reg); 656 __ add( temp_reg, 1*BytesPerWord, temp2_reg); 657 __ andn(temp2_reg, TwoWordAlignmentMask, temp2_reg); 658 __ sub(Gargs, temp_reg, Gargs); 659 __ sub(SP, temp2_reg, SP ); 660 return temp_reg; 661 } 662 } 663 664 static RegisterOrConstant adjust_SP_and_Gargs_up_by_slots(MacroAssembler* _masm, 665 RegisterOrConstant arg_slots, 666 Register temp_reg, Register temp2_reg) { 667 // Keep the stack pointer 2*wordSize aligned. 668 const int TwoWordAlignmentMask = right_n_bits(LogBytesPerWord + 1); 669 if (arg_slots.is_constant()) { 670 const int offset = arg_slots.as_constant() << LogBytesPerWord; 671 const int masked_offset = offset & ~TwoWordAlignmentMask; 672 __ add(Gargs, offset, Gargs); 673 __ add(SP, masked_offset, SP ); 674 return offset; 675 } else { 676 __ sll_ptr(arg_slots.as_register(), LogBytesPerWord, temp_reg); 677 __ andn(temp_reg, TwoWordAlignmentMask, temp2_reg); 678 __ add(Gargs, temp_reg, Gargs); 679 __ add(SP, temp2_reg, SP ); 680 return temp_reg; 681 } 682 } 683 684 // Helper to insert argument slots into the stack. 685 // arg_slots must be a multiple of stack_move_unit() and < 0 686 // argslot_reg is decremented to point to the new (shifted) location of the argslot 687 // But, temp_reg ends up holding the original value of argslot_reg. 688 void MethodHandles::insert_arg_slots(MacroAssembler* _masm, 689 RegisterOrConstant arg_slots, 690 Register argslot_reg, 691 Register temp_reg, Register temp2_reg, Register temp3_reg) { 692 // allow constant zero 693 if (arg_slots.is_constant() && arg_slots.as_constant() == 0) 694 return; 695 696 assert_different_registers(argslot_reg, temp_reg, temp2_reg, temp3_reg, 697 (!arg_slots.is_register() ? Gargs : arg_slots.as_register())); 698 699 BLOCK_COMMENT("insert_arg_slots {"); 700 if (VerifyMethodHandles) 701 verify_argslot(_masm, argslot_reg, temp_reg, "insertion point must fall within current frame"); 702 if (VerifyMethodHandles) 703 verify_stack_move(_masm, arg_slots, -1); 704 705 // Make space on the stack for the inserted argument(s). 706 // Then pull down everything shallower than argslot_reg. 707 // The stacked return address gets pulled down with everything else. 708 // That is, copy [sp, argslot) downward by -size words. In pseudo-code: 709 // sp -= size; 710 // for (temp = sp + size; temp < argslot; temp++) 711 // temp[-size] = temp[0] 712 // argslot -= size; 713 714 // offset is temp3_reg in case of arg_slots being a register. 715 RegisterOrConstant offset = adjust_SP_and_Gargs_up_by_slots(_masm, arg_slots, temp3_reg, temp_reg); 716 __ sub(Gargs, offset, temp_reg); // source pointer for copy 717 718 { 719 Label loop; 720 __ BIND(loop); 721 // pull one word down each time through the loop 722 __ ld_ptr( Address(temp_reg, 0 ), temp2_reg); 723 __ st_ptr(temp2_reg, Address(temp_reg, offset) ); 724 __ add(temp_reg, wordSize, temp_reg); 725 __ cmp(temp_reg, argslot_reg); 726 __ brx(Assembler::lessUnsigned, false, Assembler::pt, loop); 727 __ delayed()->nop(); // FILLME 728 } 729 730 // Now move the argslot down, to point to the opened-up space. 731 __ add(argslot_reg, offset, argslot_reg); 732 BLOCK_COMMENT("} insert_arg_slots"); 733 } 734 735 736 // Helper to remove argument slots from the stack. 737 // arg_slots must be a multiple of stack_move_unit() and > 0 738 void MethodHandles::remove_arg_slots(MacroAssembler* _masm, 739 RegisterOrConstant arg_slots, 740 Register argslot_reg, 741 Register temp_reg, Register temp2_reg, Register temp3_reg) { 742 // allow constant zero 743 if (arg_slots.is_constant() && arg_slots.as_constant() == 0) 744 return; 745 assert_different_registers(argslot_reg, temp_reg, temp2_reg, temp3_reg, 746 (!arg_slots.is_register() ? Gargs : arg_slots.as_register())); 747 748 BLOCK_COMMENT("remove_arg_slots {"); 749 if (VerifyMethodHandles) 750 verify_argslots(_masm, arg_slots, argslot_reg, temp_reg, temp2_reg, false, 751 "deleted argument(s) must fall within current frame"); 752 if (VerifyMethodHandles) 753 verify_stack_move(_masm, arg_slots, +1); 754 755 // Pull up everything shallower than argslot. 756 // Then remove the excess space on the stack. 757 // The stacked return address gets pulled up with everything else. 758 // That is, copy [sp, argslot) upward by size words. In pseudo-code: 759 // for (temp = argslot-1; temp >= sp; --temp) 760 // temp[size] = temp[0] 761 // argslot += size; 762 // sp += size; 763 764 RegisterOrConstant offset = __ regcon_sll_ptr(arg_slots, LogBytesPerWord, temp3_reg); 765 __ sub(argslot_reg, wordSize, temp_reg); // source pointer for copy 766 767 { 768 Label L_loop; 769 __ BIND(L_loop); 770 // pull one word up each time through the loop 771 __ ld_ptr( Address(temp_reg, 0 ), temp2_reg); 772 __ st_ptr(temp2_reg, Address(temp_reg, offset) ); 773 __ sub(temp_reg, wordSize, temp_reg); 774 __ cmp(temp_reg, Gargs); 775 __ brx(Assembler::greaterEqualUnsigned, false, Assembler::pt, L_loop); 776 __ delayed()->nop(); // FILLME 777 } 778 779 // And adjust the argslot address to point at the deletion point. 780 __ add(argslot_reg, offset, argslot_reg); 781 782 // We don't need the offset at this point anymore, just adjust SP and Gargs. 783 (void) adjust_SP_and_Gargs_up_by_slots(_masm, arg_slots, temp3_reg, temp_reg); 784 785 BLOCK_COMMENT("} remove_arg_slots"); 786 } 787 788 // Helper to copy argument slots to the top of the stack. 789 // The sequence starts with argslot_reg and is counted by slot_count 790 // slot_count must be a multiple of stack_move_unit() and >= 0 791 // This function blows the temps but does not change argslot_reg. 792 void MethodHandles::push_arg_slots(MacroAssembler* _masm, 793 Register argslot_reg, 794 RegisterOrConstant slot_count, 795 Register temp_reg, Register temp2_reg) { 796 // allow constant zero 797 if (slot_count.is_constant() && slot_count.as_constant() == 0) 798 return; 799 assert_different_registers(argslot_reg, temp_reg, temp2_reg, 800 (!slot_count.is_register() ? Gargs : slot_count.as_register()), 801 SP); 802 assert(Interpreter::stackElementSize == wordSize, "else change this code"); 803 804 BLOCK_COMMENT("push_arg_slots {"); 805 if (VerifyMethodHandles) 806 verify_stack_move(_masm, slot_count, 0); 807 808 RegisterOrConstant offset = adjust_SP_and_Gargs_down_by_slots(_masm, slot_count, temp2_reg, temp_reg); 809 810 if (slot_count.is_constant()) { 811 for (int i = slot_count.as_constant() - 1; i >= 0; i--) { 812 __ ld_ptr( Address(argslot_reg, i * wordSize), temp_reg); 813 __ st_ptr(temp_reg, Address(Gargs, i * wordSize)); 814 } 815 } else { 816 Label L_plural, L_loop, L_break; 817 // Emit code to dynamically check for the common cases, zero and one slot. 818 __ cmp(slot_count.as_register(), (int32_t) 1); 819 __ br(Assembler::greater, false, Assembler::pn, L_plural); 820 __ delayed()->nop(); 821 __ br(Assembler::less, false, Assembler::pn, L_break); 822 __ delayed()->nop(); 823 __ ld_ptr( Address(argslot_reg, 0), temp_reg); 824 __ st_ptr(temp_reg, Address(Gargs, 0)); 825 __ ba(false, L_break); 826 __ delayed()->nop(); // FILLME 827 __ BIND(L_plural); 828 829 // Loop for 2 or more: 830 // top = &argslot[slot_count] 831 // while (top > argslot) *(--Gargs) = *(--top) 832 Register top_reg = temp_reg; 833 __ add(argslot_reg, offset, top_reg); 834 __ add(Gargs, offset, Gargs ); // move back up again so we can go down 835 __ BIND(L_loop); 836 __ sub(top_reg, wordSize, top_reg); 837 __ sub(Gargs, wordSize, Gargs ); 838 __ ld_ptr( Address(top_reg, 0), temp2_reg); 839 __ st_ptr(temp2_reg, Address(Gargs, 0)); 840 __ cmp(top_reg, argslot_reg); 841 __ brx(Assembler::greaterUnsigned, false, Assembler::pt, L_loop); 842 __ delayed()->nop(); // FILLME 843 __ BIND(L_break); 844 } 845 BLOCK_COMMENT("} push_arg_slots"); 846 } 847 848 // in-place movement; no change to Gargs 849 // blows temp_reg, temp2_reg 850 void MethodHandles::move_arg_slots_up(MacroAssembler* _masm, 851 Register bottom_reg, // invariant 852 Address top_addr, // can use temp_reg 853 RegisterOrConstant positive_distance_in_slots, // destroyed if register 854 Register temp_reg, Register temp2_reg) { 855 assert_different_registers(bottom_reg, 856 temp_reg, temp2_reg, 857 positive_distance_in_slots.register_or_noreg()); 858 BLOCK_COMMENT("move_arg_slots_up {"); 859 Label L_loop, L_break; 860 Register top_reg = temp_reg; 861 if (!top_addr.is_same_address(Address(top_reg, 0))) { 862 __ add(top_addr, top_reg); 863 } 864 // Detect empty (or broken) loop: 865 #ifdef ASSERT 866 if (VerifyMethodHandles) { 867 // Verify that &bottom < &top (non-empty interval) 868 Label L_ok, L_bad; 869 if (positive_distance_in_slots.is_register()) { 870 __ cmp(positive_distance_in_slots.as_register(), (int32_t) 0); 871 __ br(Assembler::lessEqual, false, Assembler::pn, L_bad); 872 __ delayed()->nop(); 873 } 874 __ cmp(bottom_reg, top_reg); 875 __ brx(Assembler::lessUnsigned, false, Assembler::pt, L_ok); 876 __ delayed()->nop(); 877 __ BIND(L_bad); 878 __ stop("valid bounds (copy up)"); 879 __ BIND(L_ok); 880 } 881 #endif 882 __ cmp(bottom_reg, top_reg); 883 __ brx(Assembler::greaterEqualUnsigned, false, Assembler::pn, L_break); 884 __ delayed()->nop(); 885 // work top down to bottom, copying contiguous data upwards 886 // In pseudo-code: 887 // while (--top >= bottom) *(top + distance) = *(top + 0); 888 RegisterOrConstant offset = __ argument_offset(positive_distance_in_slots, positive_distance_in_slots.register_or_noreg()); 889 __ BIND(L_loop); 890 __ sub(top_reg, wordSize, top_reg); 891 __ ld_ptr( Address(top_reg, 0 ), temp2_reg); 892 __ st_ptr(temp2_reg, Address(top_reg, offset) ); 893 __ cmp(top_reg, bottom_reg); 894 __ brx(Assembler::greaterUnsigned, false, Assembler::pt, L_loop); 895 __ delayed()->nop(); // FILLME 896 assert(Interpreter::stackElementSize == wordSize, "else change loop"); 897 __ BIND(L_break); 898 BLOCK_COMMENT("} move_arg_slots_up"); 899 } 900 901 // in-place movement; no change to rsp 902 // blows temp_reg, temp2_reg 903 void MethodHandles::move_arg_slots_down(MacroAssembler* _masm, 904 Address bottom_addr, // can use temp_reg 905 Register top_reg, // invariant 906 RegisterOrConstant negative_distance_in_slots, // destroyed if register 907 Register temp_reg, Register temp2_reg) { 908 assert_different_registers(top_reg, 909 negative_distance_in_slots.register_or_noreg(), 910 temp_reg, temp2_reg); 911 BLOCK_COMMENT("move_arg_slots_down {"); 912 Label L_loop, L_break; 913 Register bottom_reg = temp_reg; 914 if (!bottom_addr.is_same_address(Address(bottom_reg, 0))) { 915 __ add(bottom_addr, bottom_reg); 916 } 917 // Detect empty (or broken) loop: 918 #ifdef ASSERT 919 assert(!negative_distance_in_slots.is_constant() || negative_distance_in_slots.as_constant() < 0, ""); 920 if (VerifyMethodHandles) { 921 // Verify that &bottom < &top (non-empty interval) 922 Label L_ok, L_bad; 923 if (negative_distance_in_slots.is_register()) { 924 __ cmp(negative_distance_in_slots.as_register(), (int32_t) 0); 925 __ br(Assembler::greaterEqual, false, Assembler::pn, L_bad); 926 __ delayed()->nop(); 927 } 928 __ cmp(bottom_reg, top_reg); 929 __ brx(Assembler::lessUnsigned, false, Assembler::pt, L_ok); 930 __ delayed()->nop(); 931 __ BIND(L_bad); 932 __ stop("valid bounds (copy down)"); 933 __ BIND(L_ok); 934 } 935 #endif 936 __ cmp(bottom_reg, top_reg); 937 __ brx(Assembler::greaterEqualUnsigned, false, Assembler::pn, L_break); 938 __ delayed()->nop(); 939 // work bottom up to top, copying contiguous data downwards 940 // In pseudo-code: 941 // while (bottom < top) *(bottom - distance) = *(bottom + 0), bottom++; 942 RegisterOrConstant offset = __ argument_offset(negative_distance_in_slots, negative_distance_in_slots.register_or_noreg()); 943 __ BIND(L_loop); 944 __ ld_ptr( Address(bottom_reg, 0 ), temp2_reg); 945 __ st_ptr(temp2_reg, Address(bottom_reg, offset) ); 946 __ add(bottom_reg, wordSize, bottom_reg); 947 __ cmp(bottom_reg, top_reg); 948 __ brx(Assembler::lessUnsigned, false, Assembler::pt, L_loop); 949 __ delayed()->nop(); // FILLME 950 assert(Interpreter::stackElementSize == wordSize, "else change loop"); 951 __ BIND(L_break); 952 BLOCK_COMMENT("} move_arg_slots_down"); 953 } 954 955 // Copy from a field or array element to a stacked argument slot. 956 // is_element (ignored) says whether caller is loading an array element instead of an instance field. 957 void MethodHandles::move_typed_arg(MacroAssembler* _masm, 958 BasicType type, bool is_element, 959 Address value_src, Address slot_dest, 960 Register temp_reg) { 961 assert(!slot_dest.uses(temp_reg), "must be different register"); 962 BLOCK_COMMENT(!is_element ? "move_typed_arg {" : "move_typed_arg { (array element)"); 963 if (type == T_OBJECT || type == T_ARRAY) { 964 __ load_heap_oop(value_src, temp_reg); 965 __ verify_oop(temp_reg); 966 __ st_ptr(temp_reg, slot_dest); 967 } else if (type != T_VOID) { 968 int arg_size = type2aelembytes(type); 969 bool arg_is_signed = is_signed_subword_type(type); 970 int slot_size = is_subword_type(type) ? type2aelembytes(T_INT) : arg_size; // store int sub-words as int 971 __ load_sized_value( value_src, temp_reg, arg_size, arg_is_signed); 972 __ store_sized_value(temp_reg, slot_dest, slot_size ); 973 } 974 BLOCK_COMMENT("} move_typed_arg"); 975 } 976 977 // Cf. TemplateInterpreterGenerator::generate_return_entry_for and 978 // InterpreterMacroAssembler::save_return_value 979 void MethodHandles::move_return_value(MacroAssembler* _masm, BasicType type, 980 Address return_slot) { 981 BLOCK_COMMENT("move_return_value {"); 982 // Look at the type and pull the value out of the corresponding register. 983 if (type == T_VOID) { 984 // nothing to do 985 } else if (type == T_OBJECT) { 986 __ verify_oop(O0); 987 __ st_ptr(O0, return_slot); 988 } else if (type == T_INT || is_subword_type(type)) { 989 int type_size = type2aelembytes(T_INT); 990 __ store_sized_value(O0, return_slot, type_size); 991 } else if (type == T_LONG) { 992 // store the value by parts 993 // Note: We assume longs are continguous (if misaligned) on the interpreter stack. 994 #if !defined(_LP64) && defined(COMPILER2) 995 __ stx(G1, return_slot); 996 #else 997 #ifdef _LP64 998 __ stx(O0, return_slot); 999 #else 1000 if (return_slot.has_disp()) { 1001 // The displacement is a constant 1002 __ st(O0, return_slot); 1003 __ st(O1, return_slot.plus_disp(Interpreter::stackElementSize)); 1004 } else { 1005 __ std(O0, return_slot); 1006 } 1007 #endif 1008 #endif 1009 } else if (type == T_FLOAT) { 1010 __ stf(FloatRegisterImpl::S, Ftos_f, return_slot); 1011 } else if (type == T_DOUBLE) { 1012 __ stf(FloatRegisterImpl::D, Ftos_f, return_slot); 1013 } else { 1014 ShouldNotReachHere(); 1015 } 1016 BLOCK_COMMENT("} move_return_value"); 1017 } 1018 1019 #ifndef PRODUCT 1020 extern "C" void print_method_handle(oop mh); 1021 void trace_method_handle_stub(const char* adaptername, 1022 oopDesc* mh, 1023 intptr_t* saved_sp) { 1024 bool has_mh = (strstr(adaptername, "return/") == NULL); // return adapters don't have mh 1025 tty->print_cr("MH %s mh="INTPTR_FORMAT " saved_sp=" INTPTR_FORMAT, adaptername, (intptr_t) mh, saved_sp); 1026 if (has_mh) 1027 print_method_handle(mh); 1028 } 1029 void MethodHandles::trace_method_handle(MacroAssembler* _masm, const char* adaptername) { 1030 if (!TraceMethodHandles) return; 1031 BLOCK_COMMENT("trace_method_handle {"); 1032 // save: Gargs, O5_savedSP 1033 __ save_frame(16); 1034 __ set((intptr_t) adaptername, O0); 1035 __ mov(G3_method_handle, O1); 1036 __ mov(I5_savedSP, O2); 1037 __ mov(G3_method_handle, L3); 1038 __ mov(Gargs, L4); 1039 __ mov(G5_method_type, L5); 1040 __ call_VM_leaf(L7, CAST_FROM_FN_PTR(address, trace_method_handle_stub)); 1041 1042 __ mov(L3, G3_method_handle); 1043 __ mov(L4, Gargs); 1044 __ mov(L5, G5_method_type); 1045 __ restore(); 1046 BLOCK_COMMENT("} trace_method_handle"); 1047 } 1048 #endif // PRODUCT 1049 1050 // which conversion op types are implemented here? 1051 int MethodHandles::adapter_conversion_ops_supported_mask() { 1052 return ((1<<java_lang_invoke_AdapterMethodHandle::OP_RETYPE_ONLY) 1053 |(1<<java_lang_invoke_AdapterMethodHandle::OP_RETYPE_RAW) 1054 |(1<<java_lang_invoke_AdapterMethodHandle::OP_CHECK_CAST) 1055 |(1<<java_lang_invoke_AdapterMethodHandle::OP_PRIM_TO_PRIM) 1056 |(1<<java_lang_invoke_AdapterMethodHandle::OP_REF_TO_PRIM) 1057 // OP_PRIM_TO_REF is below... 1058 |(1<<java_lang_invoke_AdapterMethodHandle::OP_SWAP_ARGS) 1059 |(1<<java_lang_invoke_AdapterMethodHandle::OP_ROT_ARGS) 1060 |(1<<java_lang_invoke_AdapterMethodHandle::OP_DUP_ARGS) 1061 |(1<<java_lang_invoke_AdapterMethodHandle::OP_DROP_ARGS) 1062 // OP_COLLECT_ARGS is below... 1063 |(1<<java_lang_invoke_AdapterMethodHandle::OP_SPREAD_ARGS) 1064 |(!UseRicochetFrames ? 0 : 1065 java_lang_invoke_MethodTypeForm::vmlayout_offset_in_bytes() <= 0 ? 0 : 1066 ((1<<java_lang_invoke_AdapterMethodHandle::OP_PRIM_TO_REF) 1067 |(1<<java_lang_invoke_AdapterMethodHandle::OP_COLLECT_ARGS) 1068 |(1<<java_lang_invoke_AdapterMethodHandle::OP_FOLD_ARGS) 1069 ) 1070 ) 1071 ); 1072 } 1073 1074 //------------------------------------------------------------------------------ 1075 // MethodHandles::generate_method_handle_stub 1076 // 1077 // Generate an "entry" field for a method handle. 1078 // This determines how the method handle will respond to calls. 1079 void MethodHandles::generate_method_handle_stub(MacroAssembler* _masm, MethodHandles::EntryKind ek) { 1080 MethodHandles::EntryKind ek_orig = ek_original_kind(ek); 1081 1082 // Here is the register state during an interpreted call, 1083 // as set up by generate_method_handle_interpreter_entry(): 1084 // - G5: garbage temp (was MethodHandle.invoke methodOop, unused) 1085 // - G3: receiver method handle 1086 // - O5_savedSP: sender SP (must preserve) 1087 1088 const Register O0_scratch = O0; 1089 const Register O1_scratch = O1; 1090 const Register O2_scratch = O2; 1091 const Register O3_scratch = O3; 1092 const Register O4_scratch = O4; 1093 const Register G5_scratch = G5; 1094 1095 // Often used names: 1096 const Register O0_argslot = O0; 1097 1098 // Argument registers for _raise_exception: 1099 const Register O0_code = O0; 1100 const Register O1_actual = O1; 1101 const Register O2_required = O2; 1102 1103 guarantee(java_lang_invoke_MethodHandle::vmentry_offset_in_bytes() != 0, "must have offsets"); 1104 1105 // Some handy addresses: 1106 Address G5_method_fie( G5_method, in_bytes(methodOopDesc::from_interpreted_offset())); 1107 Address G5_method_fce( G5_method, in_bytes(methodOopDesc::from_compiled_offset())); 1108 1109 Address G3_mh_vmtarget( G3_method_handle, java_lang_invoke_MethodHandle::vmtarget_offset_in_bytes()); 1110 1111 Address G3_dmh_vmindex( G3_method_handle, java_lang_invoke_DirectMethodHandle::vmindex_offset_in_bytes()); 1112 1113 Address G3_bmh_vmargslot( G3_method_handle, java_lang_invoke_BoundMethodHandle::vmargslot_offset_in_bytes()); 1114 Address G3_bmh_argument( G3_method_handle, java_lang_invoke_BoundMethodHandle::argument_offset_in_bytes()); 1115 1116 Address G3_amh_vmargslot( G3_method_handle, java_lang_invoke_AdapterMethodHandle::vmargslot_offset_in_bytes()); 1117 Address G3_amh_argument ( G3_method_handle, java_lang_invoke_AdapterMethodHandle::argument_offset_in_bytes()); 1118 Address G3_amh_conversion(G3_method_handle, java_lang_invoke_AdapterMethodHandle::conversion_offset_in_bytes()); 1119 1120 const int java_mirror_offset = klassOopDesc::klass_part_offset_in_bytes() + Klass::java_mirror_offset_in_bytes(); 1121 1122 if (have_entry(ek)) { 1123 __ nop(); // empty stubs make SG sick 1124 return; 1125 } 1126 1127 address interp_entry = __ pc(); 1128 1129 trace_method_handle(_masm, entry_name(ek)); 1130 1131 BLOCK_COMMENT(err_msg("Entry %s {", entry_name(ek))); 1132 1133 switch ((int) ek) { 1134 case _raise_exception: 1135 { 1136 // Not a real MH entry, but rather shared code for raising an 1137 // exception. Since we use the compiled entry, arguments are 1138 // expected in compiler argument registers. 1139 assert(raise_exception_method(), "must be set"); 1140 assert(raise_exception_method()->from_compiled_entry(), "method must be linked"); 1141 1142 __ mov(O5_savedSP, SP); // Cut the stack back to where the caller started. 1143 1144 Label L_no_method; 1145 // FIXME: fill in _raise_exception_method with a suitable java.lang.invoke method 1146 __ set(AddressLiteral((address) &_raise_exception_method), G5_method); 1147 __ ld_ptr(Address(G5_method, 0), G5_method); 1148 __ tst(G5_method); 1149 __ brx(Assembler::zero, false, Assembler::pn, L_no_method); 1150 __ delayed()->nop(); 1151 1152 const int jobject_oop_offset = 0; 1153 __ ld_ptr(Address(G5_method, jobject_oop_offset), G5_method); 1154 __ tst(G5_method); 1155 __ brx(Assembler::zero, false, Assembler::pn, L_no_method); 1156 __ delayed()->nop(); 1157 1158 __ verify_oop(G5_method); 1159 __ jump_indirect_to(G5_method_fce, O3_scratch); // jump to compiled entry 1160 __ delayed()->nop(); 1161 1162 // Do something that is at least causes a valid throw from the interpreter. 1163 __ bind(L_no_method); 1164 __ unimplemented("call throw_WrongMethodType_entry"); 1165 } 1166 break; 1167 1168 case _invokestatic_mh: 1169 case _invokespecial_mh: 1170 { 1171 __ load_heap_oop(G3_mh_vmtarget, G5_method); // target is a methodOop 1172 __ verify_oop(G5_method); 1173 // Same as TemplateTable::invokestatic or invokespecial, 1174 // minus the CP setup and profiling: 1175 if (ek == _invokespecial_mh) { 1176 // Must load & check the first argument before entering the target method. 1177 __ load_method_handle_vmslots(O0_argslot, G3_method_handle, O1_scratch); 1178 __ ld_ptr(__ argument_address(O0_argslot, O0_argslot, -1), G3_method_handle); 1179 __ null_check(G3_method_handle); 1180 __ verify_oop(G3_method_handle); 1181 } 1182 __ jump_indirect_to(G5_method_fie, O1_scratch); 1183 __ delayed()->nop(); 1184 } 1185 break; 1186 1187 case _invokevirtual_mh: 1188 { 1189 // Same as TemplateTable::invokevirtual, 1190 // minus the CP setup and profiling: 1191 1192 // Pick out the vtable index and receiver offset from the MH, 1193 // and then we can discard it: 1194 Register O2_index = O2_scratch; 1195 __ load_method_handle_vmslots(O0_argslot, G3_method_handle, O1_scratch); 1196 __ ldsw(G3_dmh_vmindex, O2_index); 1197 // Note: The verifier allows us to ignore G3_mh_vmtarget. 1198 __ ld_ptr(__ argument_address(O0_argslot, O0_argslot, -1), G3_method_handle); 1199 __ null_check(G3_method_handle, oopDesc::klass_offset_in_bytes()); 1200 1201 // Get receiver klass: 1202 Register O0_klass = O0_argslot; 1203 __ load_klass(G3_method_handle, O0_klass); 1204 __ verify_oop(O0_klass); 1205 1206 // Get target methodOop & entry point: 1207 const int base = instanceKlass::vtable_start_offset() * wordSize; 1208 assert(vtableEntry::size() * wordSize == wordSize, "adjust the scaling in the code below"); 1209 1210 __ sll_ptr(O2_index, LogBytesPerWord, O2_index); 1211 __ add(O0_klass, O2_index, O0_klass); 1212 Address vtable_entry_addr(O0_klass, base + vtableEntry::method_offset_in_bytes()); 1213 __ ld_ptr(vtable_entry_addr, G5_method); 1214 1215 __ verify_oop(G5_method); 1216 __ jump_indirect_to(G5_method_fie, O1_scratch); 1217 __ delayed()->nop(); 1218 } 1219 break; 1220 1221 case _invokeinterface_mh: 1222 { 1223 // Same as TemplateTable::invokeinterface, 1224 // minus the CP setup and profiling: 1225 __ load_method_handle_vmslots(O0_argslot, G3_method_handle, O1_scratch); 1226 Register O1_intf = O1_scratch; 1227 Register G5_index = G5_scratch; 1228 __ load_heap_oop(G3_mh_vmtarget, O1_intf); 1229 __ ldsw(G3_dmh_vmindex, G5_index); 1230 __ ld_ptr(__ argument_address(O0_argslot, O0_argslot, -1), G3_method_handle); 1231 __ null_check(G3_method_handle, oopDesc::klass_offset_in_bytes()); 1232 1233 // Get receiver klass: 1234 Register O0_klass = O0_argslot; 1235 __ load_klass(G3_method_handle, O0_klass); 1236 __ verify_oop(O0_klass); 1237 1238 // Get interface: 1239 Label no_such_interface; 1240 __ verify_oop(O1_intf); 1241 __ lookup_interface_method(O0_klass, O1_intf, 1242 // Note: next two args must be the same: 1243 G5_index, G5_method, 1244 O2_scratch, 1245 O3_scratch, 1246 no_such_interface); 1247 1248 __ verify_oop(G5_method); 1249 __ jump_indirect_to(G5_method_fie, O1_scratch); 1250 __ delayed()->nop(); 1251 1252 __ bind(no_such_interface); 1253 // Throw an exception. 1254 // For historical reasons, it will be IncompatibleClassChangeError. 1255 __ unimplemented("not tested yet"); 1256 __ ld_ptr(Address(O1_intf, java_mirror_offset), O2_required); // required interface 1257 __ mov( O0_klass, O1_actual); // bad receiver 1258 __ jump_to(AddressLiteral(from_interpreted_entry(_raise_exception)), O3_scratch); 1259 __ delayed()->mov(Bytecodes::_invokeinterface, O0_code); // who is complaining? 1260 } 1261 break; 1262 1263 case _bound_ref_mh: 1264 case _bound_int_mh: 1265 case _bound_long_mh: 1266 case _bound_ref_direct_mh: 1267 case _bound_int_direct_mh: 1268 case _bound_long_direct_mh: 1269 { 1270 const bool direct_to_method = (ek >= _bound_ref_direct_mh); 1271 BasicType arg_type = ek_bound_mh_arg_type(ek); 1272 int arg_slots = type2size[arg_type]; 1273 1274 // Make room for the new argument: 1275 load_vmargslot(_masm, G3_bmh_vmargslot, O0_argslot); 1276 __ add(__ argument_address(O0_argslot, O0_argslot), O0_argslot); 1277 1278 insert_arg_slots(_masm, arg_slots * stack_move_unit(), O0_argslot, O1_scratch, O2_scratch, O3_scratch); 1279 1280 // Store bound argument into the new stack slot: 1281 __ load_heap_oop(G3_bmh_argument, O1_scratch); 1282 if (arg_type == T_OBJECT) { 1283 __ st_ptr(O1_scratch, Address(O0_argslot, 0)); 1284 } else { 1285 Address prim_value_addr(O1_scratch, java_lang_boxing_object::value_offset_in_bytes(arg_type)); 1286 move_typed_arg(_masm, arg_type, false, 1287 prim_value_addr, 1288 Address(O0_argslot, 0), 1289 O2_scratch); // must be an even register for !_LP64 long moves (uses O2/O3) 1290 } 1291 1292 if (direct_to_method) { 1293 __ load_heap_oop(G3_mh_vmtarget, G5_method); // target is a methodOop 1294 __ verify_oop(G5_method); 1295 __ jump_indirect_to(G5_method_fie, O1_scratch); 1296 __ delayed()->nop(); 1297 } else { 1298 __ load_heap_oop(G3_mh_vmtarget, G3_method_handle); // target is a methodOop 1299 __ verify_oop(G3_method_handle); 1300 __ jump_to_method_handle_entry(G3_method_handle, O1_scratch); 1301 } 1302 } 1303 break; 1304 1305 case _adapter_retype_only: 1306 case _adapter_retype_raw: 1307 // Immediately jump to the next MH layer: 1308 __ load_heap_oop(G3_mh_vmtarget, G3_method_handle); 1309 __ verify_oop(G3_method_handle); 1310 __ jump_to_method_handle_entry(G3_method_handle, O1_scratch); 1311 // This is OK when all parameter types widen. 1312 // It is also OK when a return type narrows. 1313 break; 1314 1315 case _adapter_check_cast: 1316 { 1317 // Check a reference argument before jumping to the next layer of MH: 1318 load_vmargslot(_masm, G3_amh_vmargslot, O0_argslot); 1319 Address vmarg = __ argument_address(O0_argslot, O0_argslot); 1320 1321 // What class are we casting to? 1322 Register O1_klass = O1_scratch; // Interesting AMH data. 1323 __ load_heap_oop(G3_amh_argument, O1_klass); // This is a Class object! 1324 load_klass_from_Class(_masm, O1_klass, O2_scratch, O3_scratch); 1325 1326 Label L_done; 1327 __ ld_ptr(vmarg, O2_scratch); 1328 __ tst(O2_scratch); 1329 __ brx(Assembler::zero, false, Assembler::pn, L_done); // No cast if null. 1330 __ delayed()->nop(); 1331 __ load_klass(O2_scratch, O2_scratch); 1332 1333 // Live at this point: 1334 // - O0_argslot : argslot index in vmarg; may be required in the failing path 1335 // - O1_klass : klass required by the target method 1336 // - O2_scratch : argument klass to test 1337 // - G3_method_handle: adapter method handle 1338 __ check_klass_subtype(O2_scratch, O1_klass, O3_scratch, O4_scratch, L_done); 1339 1340 // If we get here, the type check failed! 1341 __ load_heap_oop(G3_amh_argument, O2_required); // required class 1342 __ ld_ptr( vmarg, O1_actual); // bad object 1343 __ jump_to(AddressLiteral(from_interpreted_entry(_raise_exception)), O3_scratch); 1344 __ delayed()->mov(Bytecodes::_checkcast, O0_code); // who is complaining? 1345 1346 __ BIND(L_done); 1347 // Get the new MH: 1348 __ load_heap_oop(G3_mh_vmtarget, G3_method_handle); 1349 __ jump_to_method_handle_entry(G3_method_handle, O1_scratch); 1350 } 1351 break; 1352 1353 case _adapter_prim_to_prim: 1354 case _adapter_ref_to_prim: 1355 // Handled completely by optimized cases. 1356 __ stop("init_AdapterMethodHandle should not issue this"); 1357 break; 1358 1359 case _adapter_opt_i2i: // optimized subcase of adapt_prim_to_prim 1360 //case _adapter_opt_f2i: // optimized subcase of adapt_prim_to_prim 1361 case _adapter_opt_l2i: // optimized subcase of adapt_prim_to_prim 1362 case _adapter_opt_unboxi: // optimized subcase of adapt_ref_to_prim 1363 { 1364 // Perform an in-place conversion to int or an int subword. 1365 load_vmargslot(_masm, G3_amh_vmargslot, O0_argslot); 1366 Address value; 1367 Address vmarg; 1368 bool value_left_justified = false; 1369 1370 switch (ek) { 1371 case _adapter_opt_i2i: 1372 value = vmarg = __ argument_address(O0_argslot, O0_argslot); 1373 break; 1374 case _adapter_opt_l2i: 1375 { 1376 // just delete the extra slot 1377 #ifdef _LP64 1378 // In V9, longs are given 2 64-bit slots in the interpreter, but the 1379 // data is passed in only 1 slot. 1380 // Keep the second slot. 1381 __ add(__ argument_address(O0_argslot, O0_argslot, -1), O0_argslot); 1382 remove_arg_slots(_masm, -stack_move_unit(), O0_argslot, O1_scratch, O2_scratch, O3_scratch); 1383 value = Address(O0_argslot, 4); // Get least-significant 32-bit of 64-bit value. 1384 vmarg = Address(O0_argslot, Interpreter::stackElementSize); 1385 #else 1386 // Keep the first slot. 1387 __ add(__ argument_address(O0_argslot, O0_argslot), O0_argslot); 1388 remove_arg_slots(_masm, -stack_move_unit(), O0_argslot, O1_scratch, O2_scratch, O3_scratch); 1389 value = Address(O0_argslot, 0); 1390 vmarg = value; 1391 #endif 1392 } 1393 break; 1394 case _adapter_opt_unboxi: 1395 { 1396 vmarg = __ argument_address(O0_argslot, O0_argslot); 1397 // Load the value up from the heap. 1398 __ ld_ptr(vmarg, O1_scratch); 1399 int value_offset = java_lang_boxing_object::value_offset_in_bytes(T_INT); 1400 #ifdef ASSERT 1401 for (int bt = T_BOOLEAN; bt < T_INT; bt++) { 1402 if (is_subword_type(BasicType(bt))) 1403 assert(value_offset == java_lang_boxing_object::value_offset_in_bytes(BasicType(bt)), ""); 1404 } 1405 #endif 1406 __ null_check(O1_scratch, value_offset); 1407 value = Address(O1_scratch, value_offset); 1408 #ifdef _BIG_ENDIAN 1409 // Values stored in objects are packed. 1410 value_left_justified = true; 1411 #endif 1412 } 1413 break; 1414 default: 1415 ShouldNotReachHere(); 1416 } 1417 1418 // This check is required on _BIG_ENDIAN 1419 Register G5_vminfo = G5_scratch; 1420 __ ldsw(G3_amh_conversion, G5_vminfo); 1421 assert(CONV_VMINFO_SHIFT == 0, "preshifted"); 1422 1423 // Original 32-bit vmdata word must be of this form: 1424 // | MBZ:6 | signBitCount:8 | srcDstTypes:8 | conversionOp:8 | 1425 __ lduw(value, O1_scratch); 1426 if (!value_left_justified) 1427 __ sll(O1_scratch, G5_vminfo, O1_scratch); 1428 Label zero_extend, done; 1429 __ btst(CONV_VMINFO_SIGN_FLAG, G5_vminfo); 1430 __ br(Assembler::zero, false, Assembler::pn, zero_extend); 1431 __ delayed()->nop(); 1432 1433 // this path is taken for int->byte, int->short 1434 __ sra(O1_scratch, G5_vminfo, O1_scratch); 1435 __ ba(false, done); 1436 __ delayed()->nop(); 1437 1438 __ bind(zero_extend); 1439 // this is taken for int->char 1440 __ srl(O1_scratch, G5_vminfo, O1_scratch); 1441 1442 __ bind(done); 1443 __ st(O1_scratch, vmarg); 1444 1445 // Get the new MH: 1446 __ load_heap_oop(G3_mh_vmtarget, G3_method_handle); 1447 __ jump_to_method_handle_entry(G3_method_handle, O1_scratch); 1448 } 1449 break; 1450 1451 case _adapter_opt_i2l: // optimized subcase of adapt_prim_to_prim 1452 case _adapter_opt_unboxl: // optimized subcase of adapt_ref_to_prim 1453 { 1454 // Perform an in-place int-to-long or ref-to-long conversion. 1455 load_vmargslot(_masm, G3_amh_vmargslot, O0_argslot); 1456 1457 // On big-endian machine we duplicate the slot and store the MSW 1458 // in the first slot. 1459 __ add(__ argument_address(O0_argslot, O0_argslot, 1), O0_argslot); 1460 1461 insert_arg_slots(_masm, stack_move_unit(), O0_argslot, O1_scratch, O2_scratch, O3_scratch); 1462 1463 Address arg_lsw(O0_argslot, 0); 1464 Address arg_msw(O0_argslot, -Interpreter::stackElementSize); 1465 1466 switch (ek) { 1467 case _adapter_opt_i2l: 1468 { 1469 #ifdef _LP64 1470 __ ldsw(arg_lsw, O2_scratch); // Load LSW sign-extended 1471 #else 1472 __ ldsw(arg_lsw, O3_scratch); // Load LSW sign-extended 1473 __ srlx(O3_scratch, BitsPerInt, O2_scratch); // Move MSW value to lower 32-bits for std 1474 #endif 1475 __ st_long(O2_scratch, arg_msw); // Uses O2/O3 on !_LP64 1476 } 1477 break; 1478 case _adapter_opt_unboxl: 1479 { 1480 // Load the value up from the heap. 1481 __ ld_ptr(arg_lsw, O1_scratch); 1482 int value_offset = java_lang_boxing_object::value_offset_in_bytes(T_LONG); 1483 assert(value_offset == java_lang_boxing_object::value_offset_in_bytes(T_DOUBLE), ""); 1484 __ null_check(O1_scratch, value_offset); 1485 __ ld_long(Address(O1_scratch, value_offset), O2_scratch); // Uses O2/O3 on !_LP64 1486 __ st_long(O2_scratch, arg_msw); 1487 } 1488 break; 1489 default: 1490 ShouldNotReachHere(); 1491 } 1492 1493 __ load_heap_oop(G3_mh_vmtarget, G3_method_handle); 1494 __ jump_to_method_handle_entry(G3_method_handle, O1_scratch); 1495 } 1496 break; 1497 1498 case _adapter_opt_f2d: // optimized subcase of adapt_prim_to_prim 1499 case _adapter_opt_d2f: // optimized subcase of adapt_prim_to_prim 1500 { 1501 // perform an in-place floating primitive conversion 1502 __ unimplemented(entry_name(ek)); 1503 } 1504 break; 1505 1506 case _adapter_prim_to_ref: 1507 __ unimplemented(entry_name(ek)); // %%% FIXME: NYI 1508 break; 1509 1510 case _adapter_swap_args: 1511 case _adapter_rot_args: 1512 // handled completely by optimized cases 1513 __ stop("init_AdapterMethodHandle should not issue this"); 1514 break; 1515 1516 case _adapter_opt_swap_1: 1517 case _adapter_opt_swap_2: 1518 case _adapter_opt_rot_1_up: 1519 case _adapter_opt_rot_1_down: 1520 case _adapter_opt_rot_2_up: 1521 case _adapter_opt_rot_2_down: 1522 { 1523 int swap_slots = ek_adapter_opt_swap_slots(ek); 1524 int rotate = ek_adapter_opt_swap_mode(ek); 1525 1526 // 'argslot' is the position of the first argument to swap. 1527 load_vmargslot(_masm, G3_amh_vmargslot, O0_argslot); 1528 __ add(__ argument_address(O0_argslot, O0_argslot), O0_argslot); 1529 if (VerifyMethodHandles) 1530 verify_argslot(_masm, O0_argslot, O2_scratch, "swap point must fall within current frame"); 1531 1532 // 'vminfo' is the second. 1533 Register O1_destslot = O1_scratch; 1534 load_conversion_vminfo(_masm, G3_amh_conversion, O1_destslot); 1535 __ add(__ argument_address(O1_destslot, O1_destslot), O1_destslot); 1536 if (VerifyMethodHandles) 1537 verify_argslot(_masm, O1_destslot, O2_scratch, "swap point must fall within current frame"); 1538 1539 assert(Interpreter::stackElementSize == wordSize, "else rethink use of wordSize here"); 1540 if (!rotate) { 1541 // simple swap 1542 for (int i = 0; i < swap_slots; i++) { 1543 __ ld_ptr( Address(O0_argslot, i * wordSize), O2_scratch); 1544 __ ld_ptr( Address(O1_destslot, i * wordSize), O3_scratch); 1545 __ st_ptr(O3_scratch, Address(O0_argslot, i * wordSize)); 1546 __ st_ptr(O2_scratch, Address(O1_destslot, i * wordSize)); 1547 } 1548 } else { 1549 // A rotate is actually pair of moves, with an "odd slot" (or pair) 1550 // changing place with a series of other slots. 1551 // First, push the "odd slot", which is going to get overwritten 1552 switch (swap_slots) { 1553 case 2 : __ ld_ptr(Address(O0_argslot, 1 * wordSize), O4_scratch); // fall-thru 1554 case 1 : __ ld_ptr(Address(O0_argslot, 0 * wordSize), O3_scratch); break; 1555 default: ShouldNotReachHere(); 1556 } 1557 if (rotate > 0) { 1558 // Here is rotate > 0: 1559 // (low mem) (high mem) 1560 // | dest: more_slots... | arg: odd_slot :arg+1 | 1561 // => 1562 // | dest: odd_slot | dest+1: more_slots... :arg+1 | 1563 // work argslot down to destslot, copying contiguous data upwards 1564 // pseudo-code: 1565 // argslot = src_addr - swap_bytes 1566 // destslot = dest_addr 1567 // while (argslot >= destslot) *(argslot + swap_bytes) = *(argslot + 0), argslot--; 1568 move_arg_slots_up(_masm, 1569 O1_destslot, 1570 Address(O0_argslot, 0), 1571 swap_slots, 1572 O0_argslot, O2_scratch); 1573 } else { 1574 // Here is the other direction, rotate < 0: 1575 // (low mem) (high mem) 1576 // | arg: odd_slot | arg+1: more_slots... :dest+1 | 1577 // => 1578 // | arg: more_slots... | dest: odd_slot :dest+1 | 1579 // work argslot up to destslot, copying contiguous data downwards 1580 // pseudo-code: 1581 // argslot = src_addr + swap_bytes 1582 // destslot = dest_addr 1583 // while (argslot <= destslot) *(argslot - swap_bytes) = *(argslot + 0), argslot++; 1584 // dest_slot denotes an exclusive upper limit 1585 int limit_bias = OP_ROT_ARGS_DOWN_LIMIT_BIAS; 1586 if (limit_bias != 0) 1587 __ add(O1_destslot, - limit_bias * wordSize, O1_destslot); 1588 move_arg_slots_down(_masm, 1589 Address(O0_argslot, swap_slots * wordSize), 1590 O1_destslot, 1591 -swap_slots, 1592 O0_argslot, O2_scratch); 1593 1594 __ sub(O1_destslot, swap_slots * wordSize, O1_destslot); 1595 } 1596 // pop the original first chunk into the destination slot, now free 1597 switch (swap_slots) { 1598 case 2 : __ st_ptr(O4_scratch, Address(O1_destslot, 1 * wordSize)); // fall-thru 1599 case 1 : __ st_ptr(O3_scratch, Address(O1_destslot, 0 * wordSize)); break; 1600 default: ShouldNotReachHere(); 1601 } 1602 } 1603 1604 __ load_heap_oop(G3_mh_vmtarget, G3_method_handle); 1605 __ jump_to_method_handle_entry(G3_method_handle, O1_scratch); 1606 } 1607 break; 1608 1609 case _adapter_dup_args: 1610 { 1611 // 'argslot' is the position of the first argument to duplicate. 1612 load_vmargslot(_masm, G3_amh_vmargslot, O0_argslot); 1613 __ add(__ argument_address(O0_argslot, O0_argslot), O0_argslot); 1614 1615 // 'stack_move' is negative number of words to duplicate. 1616 Register O1_stack_move = O1_scratch; 1617 load_stack_move(_masm, G3_amh_conversion, O1_stack_move); 1618 1619 if (VerifyMethodHandles) { 1620 verify_argslots(_masm, O1_stack_move, O0_argslot, O2_scratch, O3_scratch, true, 1621 "copied argument(s) must fall within current frame"); 1622 } 1623 1624 // insert location is always the bottom of the argument list: 1625 __ neg(O1_stack_move); 1626 push_arg_slots(_masm, O0_argslot, O1_stack_move, O2_scratch, O3_scratch); 1627 1628 __ load_heap_oop(G3_mh_vmtarget, G3_method_handle); 1629 __ jump_to_method_handle_entry(G3_method_handle, O1_scratch); 1630 } 1631 break; 1632 1633 case _adapter_drop_args: 1634 { 1635 // 'argslot' is the position of the first argument to nuke. 1636 load_vmargslot(_masm, G3_amh_vmargslot, O0_argslot); 1637 __ add(__ argument_address(O0_argslot, O0_argslot), O0_argslot); 1638 1639 // 'stack_move' is number of words to drop. 1640 Register O1_stack_move = O1_scratch; 1641 load_stack_move(_masm, G3_amh_conversion, O1_stack_move); 1642 1643 remove_arg_slots(_masm, O1_stack_move, O0_argslot, O2_scratch, O3_scratch, O4_scratch); 1644 1645 __ load_heap_oop(G3_mh_vmtarget, G3_method_handle); 1646 __ jump_to_method_handle_entry(G3_method_handle, O1_scratch); 1647 } 1648 break; 1649 1650 case _adapter_collect_args: 1651 case _adapter_fold_args: 1652 case _adapter_spread_args: 1653 // Handled completely by optimized cases. 1654 __ stop("init_AdapterMethodHandle should not issue this"); 1655 break; 1656 1657 case _adapter_opt_collect_ref: 1658 case _adapter_opt_collect_int: 1659 case _adapter_opt_collect_long: 1660 case _adapter_opt_collect_float: 1661 case _adapter_opt_collect_double: 1662 case _adapter_opt_collect_void: 1663 case _adapter_opt_collect_0_ref: 1664 case _adapter_opt_collect_1_ref: 1665 case _adapter_opt_collect_2_ref: 1666 case _adapter_opt_collect_3_ref: 1667 case _adapter_opt_collect_4_ref: 1668 case _adapter_opt_collect_5_ref: 1669 case _adapter_opt_filter_S0_ref: 1670 case _adapter_opt_filter_S1_ref: 1671 case _adapter_opt_filter_S2_ref: 1672 case _adapter_opt_filter_S3_ref: 1673 case _adapter_opt_filter_S4_ref: 1674 case _adapter_opt_filter_S5_ref: 1675 case _adapter_opt_collect_2_S0_ref: 1676 case _adapter_opt_collect_2_S1_ref: 1677 case _adapter_opt_collect_2_S2_ref: 1678 case _adapter_opt_collect_2_S3_ref: 1679 case _adapter_opt_collect_2_S4_ref: 1680 case _adapter_opt_collect_2_S5_ref: 1681 case _adapter_opt_fold_ref: 1682 case _adapter_opt_fold_int: 1683 case _adapter_opt_fold_long: 1684 case _adapter_opt_fold_float: 1685 case _adapter_opt_fold_double: 1686 case _adapter_opt_fold_void: 1687 case _adapter_opt_fold_1_ref: 1688 case _adapter_opt_fold_2_ref: 1689 case _adapter_opt_fold_3_ref: 1690 case _adapter_opt_fold_4_ref: 1691 case _adapter_opt_fold_5_ref: 1692 { 1693 // Given a fresh incoming stack frame, build a new ricochet frame. 1694 // On entry, TOS points at a return PC, and FP is the callers frame ptr. 1695 // RSI/R13 has the caller's exact stack pointer, which we must also preserve. 1696 // RCX contains an AdapterMethodHandle of the indicated kind. 1697 1698 // Relevant AMH fields: 1699 // amh.vmargslot: 1700 // points to the trailing edge of the arguments 1701 // to filter, collect, or fold. For a boxing operation, 1702 // it points just after the single primitive value. 1703 // amh.argument: 1704 // recursively called MH, on |collect| arguments 1705 // amh.vmtarget: 1706 // final destination MH, on return value, etc. 1707 // amh.conversion.dest: 1708 // tells what is the type of the return value 1709 // (not needed here, since dest is also derived from ek) 1710 // amh.conversion.vminfo: 1711 // points to the trailing edge of the return value 1712 // when the vmtarget is to be called; this is 1713 // equal to vmargslot + (retained ? |collect| : 0) 1714 1715 // Pass 0 or more argument slots to the recursive target. 1716 int collect_count_constant = ek_adapter_opt_collect_count(ek); 1717 1718 // The collected arguments are copied from the saved argument list: 1719 int collect_slot_constant = ek_adapter_opt_collect_slot(ek); 1720 1721 assert(ek_orig == _adapter_collect_args || 1722 ek_orig == _adapter_fold_args, ""); 1723 bool retain_original_args = (ek_orig == _adapter_fold_args); 1724 1725 // The return value is replaced (or inserted) at the 'vminfo' argslot. 1726 // Sometimes we can compute this statically. 1727 int dest_slot_constant = -1; 1728 if (!retain_original_args) 1729 dest_slot_constant = collect_slot_constant; 1730 else if (collect_slot_constant >= 0 && collect_count_constant >= 0) 1731 // We are preserving all the arguments, and the return value is prepended, 1732 // so the return slot is to the left (above) the |collect| sequence. 1733 dest_slot_constant = collect_slot_constant + collect_count_constant; 1734 1735 // Replace all those slots by the result of the recursive call. 1736 // The result type can be one of ref, int, long, float, double, void. 1737 // In the case of void, nothing is pushed on the stack after return. 1738 BasicType dest = ek_adapter_opt_collect_type(ek); 1739 assert(dest == type2wfield[dest], "dest is a stack slot type"); 1740 int dest_count = type2size[dest]; 1741 assert(dest_count == 1 || dest_count == 2 || (dest_count == 0 && dest == T_VOID), "dest has a size"); 1742 1743 // Choose a return continuation. 1744 EntryKind ek_ret = _adapter_opt_return_any; 1745 if (dest != T_CONFLICT && OptimizeMethodHandles) { 1746 switch (dest) { 1747 case T_INT : ek_ret = _adapter_opt_return_int; break; 1748 case T_LONG : ek_ret = _adapter_opt_return_long; break; 1749 case T_FLOAT : ek_ret = _adapter_opt_return_float; break; 1750 case T_DOUBLE : ek_ret = _adapter_opt_return_double; break; 1751 case T_OBJECT : ek_ret = _adapter_opt_return_ref; break; 1752 case T_VOID : ek_ret = _adapter_opt_return_void; break; 1753 default : ShouldNotReachHere(); 1754 } 1755 if (dest == T_OBJECT && dest_slot_constant >= 0) { 1756 EntryKind ek_try = EntryKind(_adapter_opt_return_S0_ref + dest_slot_constant); 1757 if (ek_try <= _adapter_opt_return_LAST && 1758 ek_adapter_opt_return_slot(ek_try) == dest_slot_constant) { 1759 ek_ret = ek_try; 1760 } 1761 } 1762 assert(ek_adapter_opt_return_type(ek_ret) == dest, ""); 1763 } 1764 1765 // Already pushed: ... keep1 | collect | keep2 | 1766 1767 // Push a few extra argument words, if we need them to store the return value. 1768 { 1769 int extra_slots = 0; 1770 if (retain_original_args) { 1771 extra_slots = dest_count; 1772 } else if (collect_count_constant == -1) { 1773 extra_slots = dest_count; // collect_count might be zero; be generous 1774 } else if (dest_count > collect_count_constant) { 1775 extra_slots = (dest_count - collect_count_constant); 1776 } else { 1777 // else we know we have enough dead space in |collect| to repurpose for return values 1778 } 1779 if (extra_slots != 0) { 1780 __ sub(SP, round_to(extra_slots, 2) * Interpreter::stackElementSize, SP); 1781 } 1782 } 1783 1784 // Set up Ricochet Frame. 1785 __ mov(SP, O5_savedSP); // record SP for the callee 1786 1787 // One extra (empty) slot for outgoing target MH (see Gargs computation below). 1788 __ save_frame(2); // Note: we need to add 2 slots since frame::memory_parameter_word_sp_offset is 23. 1789 1790 // Note: Gargs is live throughout the following, until we make our recursive call. 1791 // And the RF saves a copy in L4_saved_args_base. 1792 1793 RicochetFrame::enter_ricochet_frame(_masm, G3_method_handle, Gargs, 1794 entry(ek_ret)->from_interpreted_entry()); 1795 1796 // Compute argument base: 1797 // Set up Gargs for current frame, extra (empty) slot is for outgoing target MH (space reserved by save_frame above). 1798 __ add(FP, STACK_BIAS - (1 * Interpreter::stackElementSize), Gargs); 1799 1800 // Now pushed: ... keep1 | collect | keep2 | extra | [RF] 1801 1802 #ifdef ASSERT 1803 if (VerifyMethodHandles && dest != T_CONFLICT) { 1804 BLOCK_COMMENT("verify AMH.conv.dest {"); 1805 extract_conversion_dest_type(_masm, RicochetFrame::L5_conversion, O1_scratch); 1806 Label L_dest_ok; 1807 __ cmp(O1_scratch, (int) dest); 1808 __ br(Assembler::equal, false, Assembler::pt, L_dest_ok); 1809 __ delayed()->nop(); 1810 if (dest == T_INT) { 1811 for (int bt = T_BOOLEAN; bt < T_INT; bt++) { 1812 if (is_subword_type(BasicType(bt))) { 1813 __ cmp(O1_scratch, (int) bt); 1814 __ br(Assembler::equal, false, Assembler::pt, L_dest_ok); 1815 __ delayed()->nop(); 1816 } 1817 } 1818 } 1819 __ stop("bad dest in AMH.conv"); 1820 __ BIND(L_dest_ok); 1821 BLOCK_COMMENT("} verify AMH.conv.dest"); 1822 } 1823 #endif //ASSERT 1824 1825 // Find out where the original copy of the recursive argument sequence begins. 1826 Register O0_coll = O0_scratch; 1827 { 1828 RegisterOrConstant collect_slot = collect_slot_constant; 1829 if (collect_slot_constant == -1) { 1830 load_vmargslot(_masm, G3_amh_vmargslot, O1_scratch); 1831 collect_slot = O1_scratch; 1832 } 1833 // collect_slot might be 0, but we need the move anyway. 1834 __ add(RicochetFrame::L4_saved_args_base, __ argument_offset(collect_slot, collect_slot.register_or_noreg()), O0_coll); 1835 // O0_coll now points at the trailing edge of |collect| and leading edge of |keep2| 1836 } 1837 1838 // Replace the old AMH with the recursive MH. (No going back now.) 1839 // In the case of a boxing call, the recursive call is to a 'boxer' method, 1840 // such as Integer.valueOf or Long.valueOf. In the case of a filter 1841 // or collect call, it will take one or more arguments, transform them, 1842 // and return some result, to store back into argument_base[vminfo]. 1843 __ load_heap_oop(G3_amh_argument, G3_method_handle); 1844 if (VerifyMethodHandles) verify_method_handle(_masm, G3_method_handle, O1_scratch, O2_scratch); 1845 1846 // Calculate |collect|, the number of arguments we are collecting. 1847 Register O1_collect_count = O1_scratch; 1848 RegisterOrConstant collect_count; 1849 if (collect_count_constant < 0) { 1850 __ load_method_handle_vmslots(O1_collect_count, G3_method_handle, O2_scratch); 1851 collect_count = O1_collect_count; 1852 } else { 1853 collect_count = collect_count_constant; 1854 #ifdef ASSERT 1855 if (VerifyMethodHandles) { 1856 BLOCK_COMMENT("verify collect_count_constant {"); 1857 __ load_method_handle_vmslots(O3_scratch, G3_method_handle, O2_scratch); 1858 Label L_count_ok; 1859 __ cmp(O3_scratch, collect_count_constant); 1860 __ br(Assembler::equal, false, Assembler::pt, L_count_ok); 1861 __ delayed()->nop(); 1862 __ stop("bad vminfo in AMH.conv"); 1863 __ BIND(L_count_ok); 1864 BLOCK_COMMENT("} verify collect_count_constant"); 1865 } 1866 #endif //ASSERT 1867 } 1868 1869 // copy |collect| slots directly to TOS: 1870 push_arg_slots(_masm, O0_coll, collect_count, O2_scratch, O3_scratch); 1871 // Now pushed: ... keep1 | collect | keep2 | RF... | collect | 1872 // O0_coll still points at the trailing edge of |collect| and leading edge of |keep2| 1873 1874 // If necessary, adjust the saved arguments to make room for the eventual return value. 1875 // Normal adjustment: ... keep1 | +dest+ | -collect- | keep2 | RF... | collect | 1876 // If retaining args: ... keep1 | +dest+ | collect | keep2 | RF... | collect | 1877 // In the non-retaining case, this might move keep2 either up or down. 1878 // We don't have to copy the whole | RF... collect | complex, 1879 // but we must adjust RF.saved_args_base. 1880 // Also, from now on, we will forget about the original copy of |collect|. 1881 // If we are retaining it, we will treat it as part of |keep2|. 1882 // For clarity we will define |keep3| = |collect|keep2| or |keep2|. 1883 1884 BLOCK_COMMENT("adjust trailing arguments {"); 1885 // Compare the sizes of |+dest+| and |-collect-|, which are opposed opening and closing movements. 1886 int open_count = dest_count; 1887 RegisterOrConstant close_count = collect_count_constant; 1888 Register O1_close_count = O1_collect_count; 1889 if (retain_original_args) { 1890 close_count = constant(0); 1891 } else if (collect_count_constant == -1) { 1892 close_count = O1_collect_count; 1893 } 1894 1895 // How many slots need moving? This is simply dest_slot (0 => no |keep3|). 1896 RegisterOrConstant keep3_count; 1897 Register O2_keep3_count = O2_scratch; 1898 if (dest_slot_constant < 0) { 1899 extract_conversion_vminfo(_masm, RicochetFrame::L5_conversion, O2_keep3_count); 1900 keep3_count = O2_keep3_count; 1901 } else { 1902 keep3_count = dest_slot_constant; 1903 #ifdef ASSERT 1904 if (VerifyMethodHandles && dest_slot_constant < 0) { 1905 BLOCK_COMMENT("verify dest_slot_constant {"); 1906 extract_conversion_vminfo(_masm, RicochetFrame::L5_conversion, O3_scratch); 1907 Label L_vminfo_ok; 1908 __ cmp(O3_scratch, dest_slot_constant); 1909 __ br(Assembler::equal, false, Assembler::pt, L_vminfo_ok); 1910 __ delayed()->nop(); 1911 __ stop("bad vminfo in AMH.conv"); 1912 __ BIND(L_vminfo_ok); 1913 BLOCK_COMMENT("} verify dest_slot_constant"); 1914 } 1915 #endif //ASSERT 1916 } 1917 1918 // tasks remaining: 1919 bool move_keep3 = (!keep3_count.is_constant() || keep3_count.as_constant() != 0); 1920 bool stomp_dest = (NOT_DEBUG(dest == T_OBJECT) DEBUG_ONLY(dest_count != 0)); 1921 bool fix_arg_base = (!close_count.is_constant() || open_count != close_count.as_constant()); 1922 1923 // Old and new argument locations (based at slot 0). 1924 // Net shift (&new_argv - &old_argv) is (close_count - open_count). 1925 bool zero_open_count = (open_count == 0); // remember this bit of info 1926 if (move_keep3 && fix_arg_base) { 1927 // It will be easier to have everything in one register: 1928 if (close_count.is_register()) { 1929 // Deduct open_count from close_count register to get a clean +/- value. 1930 __ sub(close_count.as_register(), open_count, close_count.as_register()); 1931 } else { 1932 close_count = close_count.as_constant() - open_count; 1933 } 1934 open_count = 0; 1935 } 1936 Register L4_old_argv = RicochetFrame::L4_saved_args_base; 1937 Register O3_new_argv = O3_scratch; 1938 if (fix_arg_base) { 1939 __ add(L4_old_argv, __ argument_offset(close_count, O4_scratch), O3_new_argv, 1940 -(open_count * Interpreter::stackElementSize)); 1941 } 1942 1943 // First decide if any actual data are to be moved. 1944 // We can skip if (a) |keep3| is empty, or (b) the argument list size didn't change. 1945 // (As it happens, all movements involve an argument list size change.) 1946 1947 // If there are variable parameters, use dynamic checks to skip around the whole mess. 1948 Label L_done; 1949 if (keep3_count.is_register()) { 1950 __ tst(keep3_count.as_register()); 1951 __ br(Assembler::zero, false, Assembler::pn, L_done); 1952 __ delayed()->nop(); 1953 } 1954 if (close_count.is_register()) { 1955 __ cmp(close_count.as_register(), open_count); 1956 __ br(Assembler::equal, false, Assembler::pn, L_done); 1957 __ delayed()->nop(); 1958 } 1959 1960 if (move_keep3 && fix_arg_base) { 1961 bool emit_move_down = false, emit_move_up = false, emit_guard = false; 1962 if (!close_count.is_constant()) { 1963 emit_move_down = emit_guard = !zero_open_count; 1964 emit_move_up = true; 1965 } else if (open_count != close_count.as_constant()) { 1966 emit_move_down = (open_count > close_count.as_constant()); 1967 emit_move_up = !emit_move_down; 1968 } 1969 Label L_move_up; 1970 if (emit_guard) { 1971 __ cmp(close_count.as_register(), open_count); 1972 __ br(Assembler::greater, false, Assembler::pn, L_move_up); 1973 __ delayed()->nop(); 1974 } 1975 1976 if (emit_move_down) { 1977 // Move arguments down if |+dest+| > |-collect-| 1978 // (This is rare, except when arguments are retained.) 1979 // This opens space for the return value. 1980 if (keep3_count.is_constant()) { 1981 for (int i = 0; i < keep3_count.as_constant(); i++) { 1982 __ ld_ptr( Address(L4_old_argv, i * Interpreter::stackElementSize), O4_scratch); 1983 __ st_ptr(O4_scratch, Address(O3_new_argv, i * Interpreter::stackElementSize) ); 1984 } 1985 } else { 1986 // Live: O1_close_count, O2_keep3_count, O3_new_argv 1987 Register argv_top = O0_scratch; 1988 __ add(L4_old_argv, __ argument_offset(keep3_count, O4_scratch), argv_top); 1989 move_arg_slots_down(_masm, 1990 Address(L4_old_argv, 0), // beginning of old argv 1991 argv_top, // end of old argv 1992 close_count, // distance to move down (must be negative) 1993 O4_scratch, G5_scratch); 1994 } 1995 } 1996 1997 if (emit_guard) { 1998 __ ba(false, L_done); // assumes emit_move_up is true also 1999 __ delayed()->nop(); 2000 __ BIND(L_move_up); 2001 } 2002 2003 if (emit_move_up) { 2004 // Move arguments up if |+dest+| < |-collect-| 2005 // (This is usual, except when |keep3| is empty.) 2006 // This closes up the space occupied by the now-deleted collect values. 2007 if (keep3_count.is_constant()) { 2008 for (int i = keep3_count.as_constant() - 1; i >= 0; i--) { 2009 __ ld_ptr( Address(L4_old_argv, i * Interpreter::stackElementSize), O4_scratch); 2010 __ st_ptr(O4_scratch, Address(O3_new_argv, i * Interpreter::stackElementSize) ); 2011 } 2012 } else { 2013 Address argv_top(L4_old_argv, __ argument_offset(keep3_count, O4_scratch)); 2014 // Live: O1_close_count, O2_keep3_count, O3_new_argv 2015 move_arg_slots_up(_masm, 2016 L4_old_argv, // beginning of old argv 2017 argv_top, // end of old argv 2018 close_count, // distance to move up (must be positive) 2019 O4_scratch, G5_scratch); 2020 } 2021 } 2022 } 2023 __ BIND(L_done); 2024 2025 if (fix_arg_base) { 2026 // adjust RF.saved_args_base 2027 __ mov(O3_new_argv, RicochetFrame::L4_saved_args_base); 2028 } 2029 2030 if (stomp_dest) { 2031 // Stomp the return slot, so it doesn't hold garbage. 2032 // This isn't strictly necessary, but it may help detect bugs. 2033 __ set(RicochetFrame::RETURN_VALUE_PLACEHOLDER, O4_scratch); 2034 __ st_ptr(O4_scratch, Address(RicochetFrame::L4_saved_args_base, 2035 __ argument_offset(keep3_count, keep3_count.register_or_noreg()))); // uses O2_keep3_count 2036 } 2037 BLOCK_COMMENT("} adjust trailing arguments"); 2038 2039 BLOCK_COMMENT("do_recursive_call"); 2040 __ mov(SP, O5_savedSP); // record SP for the callee 2041 __ set(ExternalAddress(SharedRuntime::ricochet_blob()->bounce_addr() - frame::pc_return_offset), O7); 2042 // The globally unique bounce address has two purposes: 2043 // 1. It helps the JVM recognize this frame (frame::is_ricochet_frame). 2044 // 2. When returned to, it cuts back the stack and redirects control flow 2045 // to the return handler. 2046 // The return handler will further cut back the stack when it takes 2047 // down the RF. Perhaps there is a way to streamline this further. 2048 2049 // State during recursive call: 2050 // ... keep1 | dest | dest=42 | keep3 | RF... | collect | bounce_pc | 2051 __ jump_to_method_handle_entry(G3_method_handle, O1_scratch); 2052 } 2053 break; 2054 2055 case _adapter_opt_return_ref: 2056 case _adapter_opt_return_int: 2057 case _adapter_opt_return_long: 2058 case _adapter_opt_return_float: 2059 case _adapter_opt_return_double: 2060 case _adapter_opt_return_void: 2061 case _adapter_opt_return_S0_ref: 2062 case _adapter_opt_return_S1_ref: 2063 case _adapter_opt_return_S2_ref: 2064 case _adapter_opt_return_S3_ref: 2065 case _adapter_opt_return_S4_ref: 2066 case _adapter_opt_return_S5_ref: 2067 { 2068 BasicType dest_type_constant = ek_adapter_opt_return_type(ek); 2069 int dest_slot_constant = ek_adapter_opt_return_slot(ek); 2070 2071 if (VerifyMethodHandles) RicochetFrame::verify_clean(_masm); 2072 2073 if (dest_slot_constant == -1) { 2074 // The current stub is a general handler for this dest_type. 2075 // It can be called from _adapter_opt_return_any below. 2076 // Stash the address in a little table. 2077 assert((dest_type_constant & CONV_TYPE_MASK) == dest_type_constant, "oob"); 2078 address return_handler = __ pc(); 2079 _adapter_return_handlers[dest_type_constant] = return_handler; 2080 if (dest_type_constant == T_INT) { 2081 // do the subword types too 2082 for (int bt = T_BOOLEAN; bt < T_INT; bt++) { 2083 if (is_subword_type(BasicType(bt)) && 2084 _adapter_return_handlers[bt] == NULL) { 2085 _adapter_return_handlers[bt] = return_handler; 2086 } 2087 } 2088 } 2089 } 2090 2091 // On entry to this continuation handler, make Gargs live again. 2092 __ mov(RicochetFrame::L4_saved_args_base, Gargs); 2093 2094 Register O7_temp = O7; 2095 Register O5_vminfo = O5; 2096 2097 RegisterOrConstant dest_slot = dest_slot_constant; 2098 if (dest_slot_constant == -1) { 2099 extract_conversion_vminfo(_masm, RicochetFrame::L5_conversion, O5_vminfo); 2100 dest_slot = O5_vminfo; 2101 } 2102 // Store the result back into the argslot. 2103 // This code uses the interpreter calling sequence, in which the return value 2104 // is usually left in the TOS register, as defined by InterpreterMacroAssembler::pop. 2105 // There are certain irregularities with floating point values, which can be seen 2106 // in TemplateInterpreterGenerator::generate_return_entry_for. 2107 move_return_value(_masm, dest_type_constant, __ argument_address(dest_slot, O7_temp)); 2108 2109 RicochetFrame::leave_ricochet_frame(_masm, G3_method_handle, I5_savedSP, I7); 2110 2111 // Load the final target and go. 2112 if (VerifyMethodHandles) verify_method_handle(_masm, G3_method_handle, O0_scratch, O1_scratch); 2113 __ restore(I5_savedSP, G0, SP); 2114 __ jump_to_method_handle_entry(G3_method_handle, O0_scratch); 2115 __ illtrap(0); 2116 } 2117 break; 2118 2119 case _adapter_opt_return_any: 2120 { 2121 Register O7_temp = O7; 2122 Register O5_dest_type = O5; 2123 2124 if (VerifyMethodHandles) RicochetFrame::verify_clean(_masm); 2125 extract_conversion_dest_type(_masm, RicochetFrame::L5_conversion, O5_dest_type); 2126 __ set(ExternalAddress((address) &_adapter_return_handlers[0]), O7_temp); 2127 __ sll_ptr(O5_dest_type, LogBytesPerWord, O5_dest_type); 2128 __ ld_ptr(O7_temp, O5_dest_type, O7_temp); 2129 2130 #ifdef ASSERT 2131 { Label L_ok; 2132 __ br_notnull(O7_temp, false, Assembler::pt, L_ok); 2133 __ delayed()->nop(); 2134 __ stop("bad method handle return"); 2135 __ BIND(L_ok); 2136 } 2137 #endif //ASSERT 2138 __ JMP(O7_temp, 0); 2139 __ delayed()->nop(); 2140 } 2141 break; 2142 2143 case _adapter_opt_spread_0: 2144 case _adapter_opt_spread_1_ref: 2145 case _adapter_opt_spread_2_ref: 2146 case _adapter_opt_spread_3_ref: 2147 case _adapter_opt_spread_4_ref: 2148 case _adapter_opt_spread_5_ref: 2149 case _adapter_opt_spread_ref: 2150 case _adapter_opt_spread_byte: 2151 case _adapter_opt_spread_char: 2152 case _adapter_opt_spread_short: 2153 case _adapter_opt_spread_int: 2154 case _adapter_opt_spread_long: 2155 case _adapter_opt_spread_float: 2156 case _adapter_opt_spread_double: 2157 { 2158 // spread an array out into a group of arguments 2159 int length_constant = ek_adapter_opt_spread_count(ek); 2160 bool length_can_be_zero = (length_constant == 0); 2161 if (length_constant < 0) { 2162 // some adapters with variable length must handle the zero case 2163 if (!OptimizeMethodHandles || 2164 ek_adapter_opt_spread_type(ek) != T_OBJECT) 2165 length_can_be_zero = true; 2166 } 2167 2168 // find the address of the array argument 2169 load_vmargslot(_masm, G3_amh_vmargslot, O0_argslot); 2170 __ add(__ argument_address(O0_argslot, O0_argslot), O0_argslot); 2171 2172 // O0_argslot points both to the array and to the first output arg 2173 Address vmarg = Address(O0_argslot, 0); 2174 2175 // Get the array value. 2176 Register O1_array = O1_scratch; 2177 Register O2_array_klass = O2_scratch; 2178 BasicType elem_type = ek_adapter_opt_spread_type(ek); 2179 int elem_slots = type2size[elem_type]; // 1 or 2 2180 int array_slots = 1; // array is always a T_OBJECT 2181 int length_offset = arrayOopDesc::length_offset_in_bytes(); 2182 int elem0_offset = arrayOopDesc::base_offset_in_bytes(elem_type); 2183 __ ld_ptr(vmarg, O1_array); 2184 2185 Label L_array_is_empty, L_insert_arg_space, L_copy_args, L_args_done; 2186 if (length_can_be_zero) { 2187 // handle the null pointer case, if zero is allowed 2188 Label L_skip; 2189 if (length_constant < 0) { 2190 load_conversion_vminfo(_masm, G3_amh_conversion, O3_scratch); 2191 __ br_zero(Assembler::notZero, false, Assembler::pn, O3_scratch, L_skip); 2192 __ delayed()->nop(); 2193 } 2194 __ br_null(O1_array, false, Assembler::pn, L_array_is_empty); 2195 __ delayed()->nop(); 2196 __ BIND(L_skip); 2197 } 2198 __ null_check(O1_array, oopDesc::klass_offset_in_bytes()); 2199 __ load_klass(O1_array, O2_array_klass); 2200 2201 // Check the array type. 2202 Register O3_klass = O3_scratch; 2203 __ load_heap_oop(G3_amh_argument, O3_klass); // this is a Class object! 2204 load_klass_from_Class(_masm, O3_klass, O4_scratch, G5_scratch); 2205 2206 Label L_ok_array_klass, L_bad_array_klass, L_bad_array_length; 2207 __ check_klass_subtype(O2_array_klass, O3_klass, O4_scratch, G5_scratch, L_ok_array_klass); 2208 // If we get here, the type check failed! 2209 __ ba(false, L_bad_array_klass); 2210 __ delayed()->nop(); 2211 __ BIND(L_ok_array_klass); 2212 2213 // Check length. 2214 if (length_constant >= 0) { 2215 __ ldsw(Address(O1_array, length_offset), O4_scratch); 2216 __ cmp(O4_scratch, length_constant); 2217 } else { 2218 Register O3_vminfo = O3_scratch; 2219 load_conversion_vminfo(_masm, G3_amh_conversion, O3_vminfo); 2220 __ ldsw(Address(O1_array, length_offset), O4_scratch); 2221 __ cmp(O3_vminfo, O4_scratch); 2222 } 2223 __ br(Assembler::notEqual, false, Assembler::pn, L_bad_array_length); 2224 __ delayed()->nop(); 2225 2226 Register O2_argslot_limit = O2_scratch; 2227 2228 // Array length checks out. Now insert any required stack slots. 2229 if (length_constant == -1) { 2230 // Form a pointer to the end of the affected region. 2231 __ add(O0_argslot, Interpreter::stackElementSize, O2_argslot_limit); 2232 // 'stack_move' is negative number of words to insert 2233 // This number already accounts for elem_slots. 2234 Register O3_stack_move = O3_scratch; 2235 load_stack_move(_masm, G3_amh_conversion, O3_stack_move); 2236 __ cmp(O3_stack_move, 0); 2237 assert(stack_move_unit() < 0, "else change this comparison"); 2238 __ br(Assembler::less, false, Assembler::pn, L_insert_arg_space); 2239 __ delayed()->nop(); 2240 __ br(Assembler::equal, false, Assembler::pn, L_copy_args); 2241 __ delayed()->nop(); 2242 // single argument case, with no array movement 2243 __ BIND(L_array_is_empty); 2244 remove_arg_slots(_masm, -stack_move_unit() * array_slots, 2245 O0_argslot, O1_scratch, O2_scratch, O3_scratch); 2246 __ ba(false, L_args_done); // no spreading to do 2247 __ delayed()->nop(); 2248 __ BIND(L_insert_arg_space); 2249 // come here in the usual case, stack_move < 0 (2 or more spread arguments) 2250 // Live: O1_array, O2_argslot_limit, O3_stack_move 2251 insert_arg_slots(_masm, O3_stack_move, 2252 O0_argslot, O4_scratch, G5_scratch, O1_scratch); 2253 // reload from rdx_argslot_limit since rax_argslot is now decremented 2254 __ ld_ptr(Address(O2_argslot_limit, -Interpreter::stackElementSize), O1_array); 2255 } else if (length_constant >= 1) { 2256 int new_slots = (length_constant * elem_slots) - array_slots; 2257 insert_arg_slots(_masm, new_slots * stack_move_unit(), 2258 O0_argslot, O2_scratch, O3_scratch, O4_scratch); 2259 } else if (length_constant == 0) { 2260 __ BIND(L_array_is_empty); 2261 remove_arg_slots(_masm, -stack_move_unit() * array_slots, 2262 O0_argslot, O1_scratch, O2_scratch, O3_scratch); 2263 } else { 2264 ShouldNotReachHere(); 2265 } 2266 2267 // Copy from the array to the new slots. 2268 // Note: Stack change code preserves integrity of O0_argslot pointer. 2269 // So even after slot insertions, O0_argslot still points to first argument. 2270 // Beware: Arguments that are shallow on the stack are deep in the array, 2271 // and vice versa. So a downward-growing stack (the usual) has to be copied 2272 // elementwise in reverse order from the source array. 2273 __ BIND(L_copy_args); 2274 if (length_constant == -1) { 2275 // [O0_argslot, O2_argslot_limit) is the area we are inserting into. 2276 // Array element [0] goes at O0_argslot_limit[-wordSize]. 2277 Register O1_source = O1_array; 2278 __ add(Address(O1_array, elem0_offset), O1_source); 2279 Register O4_fill_ptr = O4_scratch; 2280 __ mov(O2_argslot_limit, O4_fill_ptr); 2281 Label L_loop; 2282 __ BIND(L_loop); 2283 __ add(O4_fill_ptr, -Interpreter::stackElementSize * elem_slots, O4_fill_ptr); 2284 move_typed_arg(_masm, elem_type, true, 2285 Address(O1_source, 0), Address(O4_fill_ptr, 0), 2286 O2_scratch); // must be an even register for !_LP64 long moves (uses O2/O3) 2287 __ add(O1_source, type2aelembytes(elem_type), O1_source); 2288 __ cmp(O4_fill_ptr, O0_argslot); 2289 __ brx(Assembler::greaterUnsigned, false, Assembler::pt, L_loop); 2290 __ delayed()->nop(); // FILLME 2291 } else if (length_constant == 0) { 2292 // nothing to copy 2293 } else { 2294 int elem_offset = elem0_offset; 2295 int slot_offset = length_constant * Interpreter::stackElementSize; 2296 for (int index = 0; index < length_constant; index++) { 2297 slot_offset -= Interpreter::stackElementSize * elem_slots; // fill backward 2298 move_typed_arg(_masm, elem_type, true, 2299 Address(O1_array, elem_offset), Address(O0_argslot, slot_offset), 2300 O2_scratch); // must be an even register for !_LP64 long moves (uses O2/O3) 2301 elem_offset += type2aelembytes(elem_type); 2302 } 2303 } 2304 __ BIND(L_args_done); 2305 2306 // Arguments are spread. Move to next method handle. 2307 __ load_heap_oop(G3_mh_vmtarget, G3_method_handle); 2308 __ jump_to_method_handle_entry(G3_method_handle, O1_scratch); 2309 2310 __ BIND(L_bad_array_klass); 2311 assert(!vmarg.uses(O2_required), "must be different registers"); 2312 __ load_heap_oop(Address(O2_array_klass, java_mirror_offset), O2_required); // required class 2313 __ ld_ptr( vmarg, O1_actual); // bad object 2314 __ jump_to(AddressLiteral(from_interpreted_entry(_raise_exception)), O3_scratch); 2315 __ delayed()->mov(Bytecodes::_aaload, O0_code); // who is complaining? 2316 2317 __ bind(L_bad_array_length); 2318 assert(!vmarg.uses(O2_required), "must be different registers"); 2319 __ mov( G3_method_handle, O2_required); // required class 2320 __ ld_ptr(vmarg, O1_actual); // bad object 2321 __ jump_to(AddressLiteral(from_interpreted_entry(_raise_exception)), O3_scratch); 2322 __ delayed()->mov(Bytecodes::_arraylength, O0_code); // who is complaining? 2323 } 2324 break; 2325 2326 default: 2327 DEBUG_ONLY(tty->print_cr("bad ek=%d (%s)", (int)ek, entry_name(ek))); 2328 ShouldNotReachHere(); 2329 } 2330 BLOCK_COMMENT(err_msg("} Entry %s", entry_name(ek))); 2331 2332 address me_cookie = MethodHandleEntry::start_compiled_entry(_masm, interp_entry); 2333 __ unimplemented(entry_name(ek)); // %%% FIXME: NYI 2334 2335 init_entry(ek, MethodHandleEntry::finish_compiled_entry(_masm, me_cookie)); 2336 }