1 /* 2 * Copyright (c) 2003, 2013, 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 "interp_masm_x86.hpp" 27 #include "interpreter/interpreter.hpp" 28 #include "interpreter/interpreterRuntime.hpp" 29 #include "oops/arrayOop.hpp" 30 #include "oops/markOop.hpp" 31 #include "oops/methodData.hpp" 32 #include "oops/method.hpp" 33 #include "prims/jvmtiExport.hpp" 34 #include "prims/jvmtiRedefineClassesTrace.hpp" 35 #include "prims/jvmtiThreadState.hpp" 36 #include "runtime/basicLock.hpp" 37 #include "runtime/biasedLocking.hpp" 38 #include "runtime/sharedRuntime.hpp" 39 #include "runtime/thread.inline.hpp" 40 41 42 // Implementation of InterpreterMacroAssembler 43 44 #ifdef CC_INTERP 45 void InterpreterMacroAssembler::get_method(Register reg) { 46 movptr(reg, Address(rbp, -((int)sizeof(BytecodeInterpreter) + 2 * wordSize))); 47 movptr(reg, Address(reg, byte_offset_of(BytecodeInterpreter, _method))); 48 } 49 #endif // CC_INTERP 50 51 #ifndef CC_INTERP 52 53 void InterpreterMacroAssembler::call_VM_leaf_base(address entry_point, 54 int number_of_arguments) { 55 // interpreter specific 56 // 57 // Note: No need to save/restore bcp & locals (r13 & r14) pointer 58 // since these are callee saved registers and no blocking/ 59 // GC can happen in leaf calls. 60 // Further Note: DO NOT save/restore bcp/locals. If a caller has 61 // already saved them so that it can use esi/edi as temporaries 62 // then a save/restore here will DESTROY the copy the caller 63 // saved! There used to be a save_bcp() that only happened in 64 // the ASSERT path (no restore_bcp). Which caused bizarre failures 65 // when jvm built with ASSERTs. 66 #ifdef ASSERT 67 { 68 Label L; 69 cmpptr(Address(rbp, frame::interpreter_frame_last_sp_offset * wordSize), (int32_t)NULL_WORD); 70 jcc(Assembler::equal, L); 71 stop("InterpreterMacroAssembler::call_VM_leaf_base:" 72 " last_sp != NULL"); 73 bind(L); 74 } 75 #endif 76 // super call 77 MacroAssembler::call_VM_leaf_base(entry_point, number_of_arguments); 78 // interpreter specific 79 // Used to ASSERT that r13/r14 were equal to frame's bcp/locals 80 // but since they may not have been saved (and we don't want to 81 // save thme here (see note above) the assert is invalid. 82 } 83 84 void InterpreterMacroAssembler::call_VM_base(Register oop_result, 85 Register java_thread, 86 Register last_java_sp, 87 address entry_point, 88 int number_of_arguments, 89 bool check_exceptions) { 90 // interpreter specific 91 // 92 // Note: Could avoid restoring locals ptr (callee saved) - however doesn't 93 // really make a difference for these runtime calls, since they are 94 // slow anyway. Btw., bcp must be saved/restored since it may change 95 // due to GC. 96 // assert(java_thread == noreg , "not expecting a precomputed java thread"); 97 save_bcp(); 98 #ifdef ASSERT 99 { 100 Label L; 101 cmpptr(Address(rbp, frame::interpreter_frame_last_sp_offset * wordSize), (int32_t)NULL_WORD); 102 jcc(Assembler::equal, L); 103 stop("InterpreterMacroAssembler::call_VM_leaf_base:" 104 " last_sp != NULL"); 105 bind(L); 106 } 107 #endif /* ASSERT */ 108 // super call 109 MacroAssembler::call_VM_base(oop_result, noreg, last_java_sp, 110 entry_point, number_of_arguments, 111 check_exceptions); 112 // interpreter specific 113 restore_bcp(); 114 restore_locals(); 115 } 116 117 118 void InterpreterMacroAssembler::check_and_handle_popframe(Register java_thread) { 119 if (JvmtiExport::can_pop_frame()) { 120 Label L; 121 // Initiate popframe handling only if it is not already being 122 // processed. If the flag has the popframe_processing bit set, it 123 // means that this code is called *during* popframe handling - we 124 // don't want to reenter. 125 // This method is only called just after the call into the vm in 126 // call_VM_base, so the arg registers are available. 127 movl(c_rarg0, Address(r15_thread, JavaThread::popframe_condition_offset())); 128 testl(c_rarg0, JavaThread::popframe_pending_bit); 129 jcc(Assembler::zero, L); 130 testl(c_rarg0, JavaThread::popframe_processing_bit); 131 jcc(Assembler::notZero, L); 132 // Call Interpreter::remove_activation_preserving_args_entry() to get the 133 // address of the same-named entrypoint in the generated interpreter code. 134 call_VM_leaf(CAST_FROM_FN_PTR(address, Interpreter::remove_activation_preserving_args_entry)); 135 jmp(rax); 136 bind(L); 137 } 138 } 139 140 141 void InterpreterMacroAssembler::load_earlyret_value(TosState state) { 142 movptr(rcx, Address(r15_thread, JavaThread::jvmti_thread_state_offset())); 143 const Address tos_addr(rcx, JvmtiThreadState::earlyret_tos_offset()); 144 const Address oop_addr(rcx, JvmtiThreadState::earlyret_oop_offset()); 145 const Address val_addr(rcx, JvmtiThreadState::earlyret_value_offset()); 146 switch (state) { 147 case atos: movptr(rax, oop_addr); 148 movptr(oop_addr, (int32_t)NULL_WORD); 149 verify_oop(rax, state); break; 150 case ltos: movptr(rax, val_addr); break; 151 case btos: // fall through 152 case ctos: // fall through 153 case stos: // fall through 154 case itos: movl(rax, val_addr); break; 155 case ftos: movflt(xmm0, val_addr); break; 156 case dtos: movdbl(xmm0, val_addr); break; 157 case vtos: /* nothing to do */ break; 158 default : ShouldNotReachHere(); 159 } 160 // Clean up tos value in the thread object 161 movl(tos_addr, (int) ilgl); 162 movl(val_addr, (int32_t) NULL_WORD); 163 } 164 165 166 void InterpreterMacroAssembler::check_and_handle_earlyret(Register java_thread) { 167 if (JvmtiExport::can_force_early_return()) { 168 Label L; 169 movptr(c_rarg0, Address(r15_thread, JavaThread::jvmti_thread_state_offset())); 170 testptr(c_rarg0, c_rarg0); 171 jcc(Assembler::zero, L); // if (thread->jvmti_thread_state() == NULL) exit; 172 173 // Initiate earlyret handling only if it is not already being processed. 174 // If the flag has the earlyret_processing bit set, it means that this code 175 // is called *during* earlyret handling - we don't want to reenter. 176 movl(c_rarg0, Address(c_rarg0, JvmtiThreadState::earlyret_state_offset())); 177 cmpl(c_rarg0, JvmtiThreadState::earlyret_pending); 178 jcc(Assembler::notEqual, L); 179 180 // Call Interpreter::remove_activation_early_entry() to get the address of the 181 // same-named entrypoint in the generated interpreter code. 182 movptr(c_rarg0, Address(r15_thread, JavaThread::jvmti_thread_state_offset())); 183 movl(c_rarg0, Address(c_rarg0, JvmtiThreadState::earlyret_tos_offset())); 184 call_VM_leaf(CAST_FROM_FN_PTR(address, Interpreter::remove_activation_early_entry), c_rarg0); 185 jmp(rax); 186 bind(L); 187 } 188 } 189 190 191 void InterpreterMacroAssembler::get_unsigned_2_byte_index_at_bcp( 192 Register reg, 193 int bcp_offset) { 194 assert(bcp_offset >= 0, "bcp is still pointing to start of bytecode"); 195 load_unsigned_short(reg, Address(r13, bcp_offset)); 196 bswapl(reg); 197 shrl(reg, 16); 198 } 199 200 201 void InterpreterMacroAssembler::get_cache_index_at_bcp(Register index, 202 int bcp_offset, 203 size_t index_size) { 204 assert(bcp_offset > 0, "bcp is still pointing to start of bytecode"); 205 if (index_size == sizeof(u2)) { 206 load_unsigned_short(index, Address(r13, bcp_offset)); 207 } else if (index_size == sizeof(u4)) { 208 assert(EnableInvokeDynamic, "giant index used only for JSR 292"); 209 movl(index, Address(r13, bcp_offset)); 210 // Check if the secondary index definition is still ~x, otherwise 211 // we have to change the following assembler code to calculate the 212 // plain index. 213 assert(ConstantPool::decode_invokedynamic_index(~123) == 123, "else change next line"); 214 notl(index); // convert to plain index 215 } else if (index_size == sizeof(u1)) { 216 load_unsigned_byte(index, Address(r13, bcp_offset)); 217 } else { 218 ShouldNotReachHere(); 219 } 220 } 221 222 223 void InterpreterMacroAssembler::get_cache_and_index_at_bcp(Register cache, 224 Register index, 225 int bcp_offset, 226 size_t index_size) { 227 assert_different_registers(cache, index); 228 get_cache_index_at_bcp(index, bcp_offset, index_size); 229 movptr(cache, Address(rbp, frame::interpreter_frame_cache_offset * wordSize)); 230 assert(sizeof(ConstantPoolCacheEntry) == 4 * wordSize, "adjust code below"); 231 // convert from field index to ConstantPoolCacheEntry index 232 assert(exact_log2(in_words(ConstantPoolCacheEntry::size())) == 2, "else change next line"); 233 shll(index, 2); 234 } 235 236 237 void InterpreterMacroAssembler::get_cache_and_index_and_bytecode_at_bcp(Register cache, 238 Register index, 239 Register bytecode, 240 int byte_no, 241 int bcp_offset, 242 size_t index_size) { 243 get_cache_and_index_at_bcp(cache, index, bcp_offset, index_size); 244 // We use a 32-bit load here since the layout of 64-bit words on 245 // little-endian machines allow us that. 246 movl(bytecode, Address(cache, index, Address::times_ptr, ConstantPoolCache::base_offset() + ConstantPoolCacheEntry::indices_offset())); 247 const int shift_count = (1 + byte_no) * BitsPerByte; 248 assert((byte_no == TemplateTable::f1_byte && shift_count == ConstantPoolCacheEntry::bytecode_1_shift) || 249 (byte_no == TemplateTable::f2_byte && shift_count == ConstantPoolCacheEntry::bytecode_2_shift), 250 "correct shift count"); 251 shrl(bytecode, shift_count); 252 assert(ConstantPoolCacheEntry::bytecode_1_mask == ConstantPoolCacheEntry::bytecode_2_mask, "common mask"); 253 andl(bytecode, ConstantPoolCacheEntry::bytecode_1_mask); 254 } 255 256 257 void InterpreterMacroAssembler::get_cache_entry_pointer_at_bcp(Register cache, 258 Register tmp, 259 int bcp_offset, 260 size_t index_size) { 261 assert(cache != tmp, "must use different register"); 262 get_cache_index_at_bcp(tmp, bcp_offset, index_size); 263 assert(sizeof(ConstantPoolCacheEntry) == 4 * wordSize, "adjust code below"); 264 // convert from field index to ConstantPoolCacheEntry index 265 // and from word offset to byte offset 266 assert(exact_log2(in_bytes(ConstantPoolCacheEntry::size_in_bytes())) == 2 + LogBytesPerWord, "else change next line"); 267 shll(tmp, 2 + LogBytesPerWord); 268 movptr(cache, Address(rbp, frame::interpreter_frame_cache_offset * wordSize)); 269 // skip past the header 270 addptr(cache, in_bytes(ConstantPoolCache::base_offset())); 271 addptr(cache, tmp); // construct pointer to cache entry 272 } 273 274 // Load object from cpool->resolved_references(index) 275 void InterpreterMacroAssembler::load_resolved_reference_at_index( 276 Register result, Register index) { 277 assert_different_registers(result, index); 278 // convert from field index to resolved_references() index and from 279 // word index to byte offset. Since this is a java object, it can be compressed 280 Register tmp = index; // reuse 281 shll(tmp, LogBytesPerHeapOop); 282 283 get_constant_pool(result); 284 // load pointer for resolved_references[] objArray 285 movptr(result, Address(result, ConstantPool::resolved_references_offset_in_bytes())); 286 // JNIHandles::resolve(obj); 287 movptr(result, Address(result, 0)); 288 // Add in the index 289 addptr(result, tmp); 290 load_heap_oop(result, Address(result, arrayOopDesc::base_offset_in_bytes(T_OBJECT))); 291 } 292 293 // Generate a subtype check: branch to ok_is_subtype if sub_klass is a 294 // subtype of super_klass. 295 // 296 // Args: 297 // rax: superklass 298 // Rsub_klass: subklass 299 // 300 // Kills: 301 // rcx, rdi 302 void InterpreterMacroAssembler::gen_subtype_check(Register Rsub_klass, 303 Label& ok_is_subtype) { 304 assert(Rsub_klass != rax, "rax holds superklass"); 305 assert(Rsub_klass != r14, "r14 holds locals"); 306 assert(Rsub_klass != r13, "r13 holds bcp"); 307 assert(Rsub_klass != rcx, "rcx holds 2ndary super array length"); 308 assert(Rsub_klass != rdi, "rdi holds 2ndary super array scan ptr"); 309 310 // Profile the not-null value's klass. 311 profile_typecheck(rcx, Rsub_klass, rdi); // blows rcx, reloads rdi 312 313 // Do the check. 314 check_klass_subtype(Rsub_klass, rax, rcx, ok_is_subtype); // blows rcx 315 316 // Profile the failure of the check. 317 profile_typecheck_failed(rcx); // blows rcx 318 } 319 320 321 322 // Java Expression Stack 323 324 void InterpreterMacroAssembler::pop_ptr(Register r) { 325 pop(r); 326 } 327 328 void InterpreterMacroAssembler::pop_i(Register r) { 329 // XXX can't use pop currently, upper half non clean 330 movl(r, Address(rsp, 0)); 331 addptr(rsp, wordSize); 332 } 333 334 void InterpreterMacroAssembler::pop_l(Register r) { 335 movq(r, Address(rsp, 0)); 336 addptr(rsp, 2 * Interpreter::stackElementSize); 337 } 338 339 void InterpreterMacroAssembler::pop_f(XMMRegister r) { 340 movflt(r, Address(rsp, 0)); 341 addptr(rsp, wordSize); 342 } 343 344 void InterpreterMacroAssembler::pop_d(XMMRegister r) { 345 movdbl(r, Address(rsp, 0)); 346 addptr(rsp, 2 * Interpreter::stackElementSize); 347 } 348 349 void InterpreterMacroAssembler::push_ptr(Register r) { 350 push(r); 351 } 352 353 void InterpreterMacroAssembler::push_i(Register r) { 354 push(r); 355 } 356 357 void InterpreterMacroAssembler::push_l(Register r) { 358 subptr(rsp, 2 * wordSize); 359 movq(Address(rsp, 0), r); 360 } 361 362 void InterpreterMacroAssembler::push_f(XMMRegister r) { 363 subptr(rsp, wordSize); 364 movflt(Address(rsp, 0), r); 365 } 366 367 void InterpreterMacroAssembler::push_d(XMMRegister r) { 368 subptr(rsp, 2 * wordSize); 369 movdbl(Address(rsp, 0), r); 370 } 371 372 void InterpreterMacroAssembler::pop(TosState state) { 373 switch (state) { 374 case atos: pop_ptr(); break; 375 case btos: 376 case ctos: 377 case stos: 378 case itos: pop_i(); break; 379 case ltos: pop_l(); break; 380 case ftos: pop_f(); break; 381 case dtos: pop_d(); break; 382 case vtos: /* nothing to do */ break; 383 default: ShouldNotReachHere(); 384 } 385 verify_oop(rax, state); 386 } 387 388 void InterpreterMacroAssembler::push(TosState state) { 389 verify_oop(rax, state); 390 switch (state) { 391 case atos: push_ptr(); break; 392 case btos: 393 case ctos: 394 case stos: 395 case itos: push_i(); break; 396 case ltos: push_l(); break; 397 case ftos: push_f(); break; 398 case dtos: push_d(); break; 399 case vtos: /* nothing to do */ break; 400 default : ShouldNotReachHere(); 401 } 402 } 403 404 405 // Helpers for swap and dup 406 void InterpreterMacroAssembler::load_ptr(int n, Register val) { 407 movptr(val, Address(rsp, Interpreter::expr_offset_in_bytes(n))); 408 } 409 410 void InterpreterMacroAssembler::store_ptr(int n, Register val) { 411 movptr(Address(rsp, Interpreter::expr_offset_in_bytes(n)), val); 412 } 413 414 415 void InterpreterMacroAssembler::prepare_to_jump_from_interpreted() { 416 // set sender sp 417 lea(r13, Address(rsp, wordSize)); 418 // record last_sp 419 movptr(Address(rbp, frame::interpreter_frame_last_sp_offset * wordSize), r13); 420 } 421 422 423 // Jump to from_interpreted entry of a call unless single stepping is possible 424 // in this thread in which case we must call the i2i entry 425 void InterpreterMacroAssembler::jump_from_interpreted(Register method, Register temp) { 426 prepare_to_jump_from_interpreted(); 427 428 if (JvmtiExport::can_post_interpreter_events()) { 429 Label run_compiled_code; 430 // JVMTI events, such as single-stepping, are implemented partly by avoiding running 431 // compiled code in threads for which the event is enabled. Check here for 432 // interp_only_mode if these events CAN be enabled. 433 // interp_only is an int, on little endian it is sufficient to test the byte only 434 // Is a cmpl faster? 435 cmpb(Address(r15_thread, JavaThread::interp_only_mode_offset()), 0); 436 jccb(Assembler::zero, run_compiled_code); 437 jmp(Address(method, Method::interpreter_entry_offset())); 438 bind(run_compiled_code); 439 } 440 441 jmp(Address(method, Method::from_interpreted_offset())); 442 443 } 444 445 446 // The following two routines provide a hook so that an implementation 447 // can schedule the dispatch in two parts. amd64 does not do this. 448 void InterpreterMacroAssembler::dispatch_prolog(TosState state, int step) { 449 // Nothing amd64 specific to be done here 450 } 451 452 void InterpreterMacroAssembler::dispatch_epilog(TosState state, int step) { 453 dispatch_next(state, step); 454 } 455 456 void InterpreterMacroAssembler::dispatch_base(TosState state, 457 address* table, 458 bool verifyoop) { 459 verify_FPU(1, state); 460 if (VerifyActivationFrameSize) { 461 Label L; 462 mov(rcx, rbp); 463 subptr(rcx, rsp); 464 int32_t min_frame_size = 465 (frame::link_offset - frame::interpreter_frame_initial_sp_offset) * 466 wordSize; 467 cmpptr(rcx, (int32_t)min_frame_size); 468 jcc(Assembler::greaterEqual, L); 469 stop("broken stack frame"); 470 bind(L); 471 } 472 if (verifyoop) { 473 verify_oop(rax, state); 474 } 475 lea(rscratch1, ExternalAddress((address)table)); 476 jmp(Address(rscratch1, rbx, Address::times_8)); 477 } 478 479 void InterpreterMacroAssembler::dispatch_only(TosState state) { 480 dispatch_base(state, Interpreter::dispatch_table(state)); 481 } 482 483 void InterpreterMacroAssembler::dispatch_only_normal(TosState state) { 484 dispatch_base(state, Interpreter::normal_table(state)); 485 } 486 487 void InterpreterMacroAssembler::dispatch_only_noverify(TosState state) { 488 dispatch_base(state, Interpreter::normal_table(state), false); 489 } 490 491 492 void InterpreterMacroAssembler::dispatch_next(TosState state, int step) { 493 // load next bytecode (load before advancing r13 to prevent AGI) 494 load_unsigned_byte(rbx, Address(r13, step)); 495 // advance r13 496 increment(r13, step); 497 dispatch_base(state, Interpreter::dispatch_table(state)); 498 } 499 500 void InterpreterMacroAssembler::dispatch_via(TosState state, address* table) { 501 // load current bytecode 502 load_unsigned_byte(rbx, Address(r13, 0)); 503 dispatch_base(state, table); 504 } 505 506 // remove activation 507 // 508 // Unlock the receiver if this is a synchronized method. 509 // Unlock any Java monitors from syncronized blocks. 510 // Remove the activation from the stack. 511 // 512 // If there are locked Java monitors 513 // If throw_monitor_exception 514 // throws IllegalMonitorStateException 515 // Else if install_monitor_exception 516 // installs IllegalMonitorStateException 517 // Else 518 // no error processing 519 void InterpreterMacroAssembler::remove_activation( 520 TosState state, 521 Register ret_addr, 522 bool throw_monitor_exception, 523 bool install_monitor_exception, 524 bool notify_jvmdi) { 525 // Note: Registers rdx xmm0 may be in use for the 526 // result check if synchronized method 527 Label unlocked, unlock, no_unlock; 528 529 // get the value of _do_not_unlock_if_synchronized into rdx 530 const Address do_not_unlock_if_synchronized(r15_thread, 531 in_bytes(JavaThread::do_not_unlock_if_synchronized_offset())); 532 movbool(rdx, do_not_unlock_if_synchronized); 533 movbool(do_not_unlock_if_synchronized, false); // reset the flag 534 535 // get method access flags 536 movptr(rbx, Address(rbp, frame::interpreter_frame_method_offset * wordSize)); 537 movl(rcx, Address(rbx, Method::access_flags_offset())); 538 testl(rcx, JVM_ACC_SYNCHRONIZED); 539 jcc(Assembler::zero, unlocked); 540 541 // Don't unlock anything if the _do_not_unlock_if_synchronized flag 542 // is set. 543 testbool(rdx); 544 jcc(Assembler::notZero, no_unlock); 545 546 // unlock monitor 547 push(state); // save result 548 549 // BasicObjectLock will be first in list, since this is a 550 // synchronized method. However, need to check that the object has 551 // not been unlocked by an explicit monitorexit bytecode. 552 const Address monitor(rbp, frame::interpreter_frame_initial_sp_offset * 553 wordSize - (int) sizeof(BasicObjectLock)); 554 // We use c_rarg1 so that if we go slow path it will be the correct 555 // register for unlock_object to pass to VM directly 556 lea(c_rarg1, monitor); // address of first monitor 557 558 movptr(rax, Address(c_rarg1, BasicObjectLock::obj_offset_in_bytes())); 559 testptr(rax, rax); 560 jcc(Assembler::notZero, unlock); 561 562 pop(state); 563 if (throw_monitor_exception) { 564 // Entry already unlocked, need to throw exception 565 call_VM(noreg, CAST_FROM_FN_PTR(address, 566 InterpreterRuntime::throw_illegal_monitor_state_exception)); 567 should_not_reach_here(); 568 } else { 569 // Monitor already unlocked during a stack unroll. If requested, 570 // install an illegal_monitor_state_exception. Continue with 571 // stack unrolling. 572 if (install_monitor_exception) { 573 call_VM(noreg, CAST_FROM_FN_PTR(address, 574 InterpreterRuntime::new_illegal_monitor_state_exception)); 575 } 576 jmp(unlocked); 577 } 578 579 bind(unlock); 580 unlock_object(c_rarg1); 581 pop(state); 582 583 // Check that for block-structured locking (i.e., that all locked 584 // objects has been unlocked) 585 bind(unlocked); 586 587 // rax: Might contain return value 588 589 // Check that all monitors are unlocked 590 { 591 Label loop, exception, entry, restart; 592 const int entry_size = frame::interpreter_frame_monitor_size() * wordSize; 593 const Address monitor_block_top( 594 rbp, frame::interpreter_frame_monitor_block_top_offset * wordSize); 595 const Address monitor_block_bot( 596 rbp, frame::interpreter_frame_initial_sp_offset * wordSize); 597 598 bind(restart); 599 // We use c_rarg1 so that if we go slow path it will be the correct 600 // register for unlock_object to pass to VM directly 601 movptr(c_rarg1, monitor_block_top); // points to current entry, starting 602 // with top-most entry 603 lea(rbx, monitor_block_bot); // points to word before bottom of 604 // monitor block 605 jmp(entry); 606 607 // Entry already locked, need to throw exception 608 bind(exception); 609 610 if (throw_monitor_exception) { 611 // Throw exception 612 MacroAssembler::call_VM(noreg, 613 CAST_FROM_FN_PTR(address, InterpreterRuntime:: 614 throw_illegal_monitor_state_exception)); 615 should_not_reach_here(); 616 } else { 617 // Stack unrolling. Unlock object and install illegal_monitor_exception. 618 // Unlock does not block, so don't have to worry about the frame. 619 // We don't have to preserve c_rarg1 since we are going to throw an exception. 620 621 push(state); 622 unlock_object(c_rarg1); 623 pop(state); 624 625 if (install_monitor_exception) { 626 call_VM(noreg, CAST_FROM_FN_PTR(address, 627 InterpreterRuntime:: 628 new_illegal_monitor_state_exception)); 629 } 630 631 jmp(restart); 632 } 633 634 bind(loop); 635 // check if current entry is used 636 cmpptr(Address(c_rarg1, BasicObjectLock::obj_offset_in_bytes()), (int32_t) NULL); 637 jcc(Assembler::notEqual, exception); 638 639 addptr(c_rarg1, entry_size); // otherwise advance to next entry 640 bind(entry); 641 cmpptr(c_rarg1, rbx); // check if bottom reached 642 jcc(Assembler::notEqual, loop); // if not at bottom then check this entry 643 } 644 645 bind(no_unlock); 646 647 // jvmti support 648 if (notify_jvmdi) { 649 notify_method_exit(state, NotifyJVMTI); // preserve TOSCA 650 } else { 651 notify_method_exit(state, SkipNotifyJVMTI); // preserve TOSCA 652 } 653 654 // remove activation 655 // get sender sp 656 movptr(rbx, 657 Address(rbp, frame::interpreter_frame_sender_sp_offset * wordSize)); 658 leave(); // remove frame anchor 659 pop(ret_addr); // get return address 660 mov(rsp, rbx); // set sp to sender sp 661 } 662 663 #endif // C_INTERP 664 665 void InterpreterMacroAssembler::get_method_counters(Register method, 666 Register mcs, Label& skip) { 667 Label has_counters; 668 movptr(mcs, Address(method, Method::method_counters_offset())); 669 testptr(mcs, mcs); 670 jcc(Assembler::notZero, has_counters); 671 call_VM(noreg, CAST_FROM_FN_PTR(address, 672 InterpreterRuntime::build_method_counters), method); 673 movptr(mcs, Address(method,Method::method_counters_offset())); 674 testptr(mcs, mcs); 675 jcc(Assembler::zero, skip); // No MethodCounters allocated, OutOfMemory 676 bind(has_counters); 677 } 678 679 680 // Lock object 681 // 682 // Args: 683 // c_rarg1: BasicObjectLock to be used for locking 684 // 685 // Kills: 686 // rax 687 // c_rarg0, c_rarg1, c_rarg2, c_rarg3, .. (param regs) 688 // rscratch1, rscratch2 (scratch regs) 689 void InterpreterMacroAssembler::lock_object(Register lock_reg) { 690 assert(lock_reg == c_rarg1, "The argument is only for looks. It must be c_rarg1"); 691 692 if (UseHeavyMonitors) { 693 call_VM(noreg, 694 CAST_FROM_FN_PTR(address, InterpreterRuntime::monitorenter), 695 lock_reg); 696 } else { 697 Label done; 698 699 const Register swap_reg = rax; // Must use rax for cmpxchg instruction 700 const Register obj_reg = c_rarg3; // Will contain the oop 701 702 const int obj_offset = BasicObjectLock::obj_offset_in_bytes(); 703 const int lock_offset = BasicObjectLock::lock_offset_in_bytes (); 704 const int mark_offset = lock_offset + 705 BasicLock::displaced_header_offset_in_bytes(); 706 707 Label slow_case; 708 709 // Load object pointer into obj_reg %c_rarg3 710 movptr(obj_reg, Address(lock_reg, obj_offset)); 711 712 if (UseBiasedLocking) { 713 biased_locking_enter(lock_reg, obj_reg, swap_reg, rscratch1, false, done, &slow_case); 714 } 715 716 // Load immediate 1 into swap_reg %rax 717 movl(swap_reg, 1); 718 719 // Load (object->mark() | 1) into swap_reg %rax 720 orptr(swap_reg, Address(obj_reg, 0)); 721 722 // Save (object->mark() | 1) into BasicLock's displaced header 723 movptr(Address(lock_reg, mark_offset), swap_reg); 724 725 assert(lock_offset == 0, 726 "displached header must be first word in BasicObjectLock"); 727 728 if (os::is_MP()) lock(); 729 cmpxchgptr(lock_reg, Address(obj_reg, 0)); 730 if (PrintBiasedLockingStatistics) { 731 cond_inc32(Assembler::zero, 732 ExternalAddress((address) BiasedLocking::fast_path_entry_count_addr())); 733 } 734 jcc(Assembler::zero, done); 735 736 // Test if the oopMark is an obvious stack pointer, i.e., 737 // 1) (mark & 7) == 0, and 738 // 2) rsp <= mark < mark + os::pagesize() 739 // 740 // These 3 tests can be done by evaluating the following 741 // expression: ((mark - rsp) & (7 - os::vm_page_size())), 742 // assuming both stack pointer and pagesize have their 743 // least significant 3 bits clear. 744 // NOTE: the oopMark is in swap_reg %rax as the result of cmpxchg 745 subptr(swap_reg, rsp); 746 andptr(swap_reg, 7 - os::vm_page_size()); 747 748 // Save the test result, for recursive case, the result is zero 749 movptr(Address(lock_reg, mark_offset), swap_reg); 750 751 if (PrintBiasedLockingStatistics) { 752 cond_inc32(Assembler::zero, 753 ExternalAddress((address) BiasedLocking::fast_path_entry_count_addr())); 754 } 755 jcc(Assembler::zero, done); 756 757 bind(slow_case); 758 759 // Call the runtime routine for slow case 760 call_VM(noreg, 761 CAST_FROM_FN_PTR(address, InterpreterRuntime::monitorenter), 762 lock_reg); 763 764 bind(done); 765 } 766 } 767 768 769 // Unlocks an object. Used in monitorexit bytecode and 770 // remove_activation. Throws an IllegalMonitorException if object is 771 // not locked by current thread. 772 // 773 // Args: 774 // c_rarg1: BasicObjectLock for lock 775 // 776 // Kills: 777 // rax 778 // c_rarg0, c_rarg1, c_rarg2, c_rarg3, ... (param regs) 779 // rscratch1, rscratch2 (scratch regs) 780 void InterpreterMacroAssembler::unlock_object(Register lock_reg) { 781 assert(lock_reg == c_rarg1, "The argument is only for looks. It must be rarg1"); 782 783 if (UseHeavyMonitors) { 784 call_VM(noreg, 785 CAST_FROM_FN_PTR(address, InterpreterRuntime::monitorexit), 786 lock_reg); 787 } else { 788 Label done; 789 790 const Register swap_reg = rax; // Must use rax for cmpxchg instruction 791 const Register header_reg = c_rarg2; // Will contain the old oopMark 792 const Register obj_reg = c_rarg3; // Will contain the oop 793 794 save_bcp(); // Save in case of exception 795 796 // Convert from BasicObjectLock structure to object and BasicLock 797 // structure Store the BasicLock address into %rax 798 lea(swap_reg, Address(lock_reg, BasicObjectLock::lock_offset_in_bytes())); 799 800 // Load oop into obj_reg(%c_rarg3) 801 movptr(obj_reg, Address(lock_reg, BasicObjectLock::obj_offset_in_bytes())); 802 803 // Free entry 804 movptr(Address(lock_reg, BasicObjectLock::obj_offset_in_bytes()), (int32_t)NULL_WORD); 805 806 if (UseBiasedLocking) { 807 biased_locking_exit(obj_reg, header_reg, done); 808 } 809 810 // Load the old header from BasicLock structure 811 movptr(header_reg, Address(swap_reg, 812 BasicLock::displaced_header_offset_in_bytes())); 813 814 // Test for recursion 815 testptr(header_reg, header_reg); 816 817 // zero for recursive case 818 jcc(Assembler::zero, done); 819 820 // Atomic swap back the old header 821 if (os::is_MP()) lock(); 822 cmpxchgptr(header_reg, Address(obj_reg, 0)); 823 824 // zero for recursive case 825 jcc(Assembler::zero, done); 826 827 // Call the runtime routine for slow case. 828 movptr(Address(lock_reg, BasicObjectLock::obj_offset_in_bytes()), 829 obj_reg); // restore obj 830 call_VM(noreg, 831 CAST_FROM_FN_PTR(address, InterpreterRuntime::monitorexit), 832 lock_reg); 833 834 bind(done); 835 836 restore_bcp(); 837 } 838 } 839 840 #ifndef CC_INTERP 841 842 void InterpreterMacroAssembler::test_method_data_pointer(Register mdp, 843 Label& zero_continue) { 844 assert(ProfileInterpreter, "must be profiling interpreter"); 845 movptr(mdp, Address(rbp, frame::interpreter_frame_mdx_offset * wordSize)); 846 testptr(mdp, mdp); 847 jcc(Assembler::zero, zero_continue); 848 } 849 850 851 // Set the method data pointer for the current bcp. 852 void InterpreterMacroAssembler::set_method_data_pointer_for_bcp() { 853 assert(ProfileInterpreter, "must be profiling interpreter"); 854 Label set_mdp; 855 push(rax); 856 push(rbx); 857 858 get_method(rbx); 859 // Test MDO to avoid the call if it is NULL. 860 movptr(rax, Address(rbx, in_bytes(Method::method_data_offset()))); 861 testptr(rax, rax); 862 jcc(Assembler::zero, set_mdp); 863 // rbx: method 864 // r13: bcp 865 call_VM_leaf(CAST_FROM_FN_PTR(address, InterpreterRuntime::bcp_to_di), rbx, r13); 866 // rax: mdi 867 // mdo is guaranteed to be non-zero here, we checked for it before the call. 868 movptr(rbx, Address(rbx, in_bytes(Method::method_data_offset()))); 869 addptr(rbx, in_bytes(MethodData::data_offset())); 870 addptr(rax, rbx); 871 bind(set_mdp); 872 movptr(Address(rbp, frame::interpreter_frame_mdx_offset * wordSize), rax); 873 pop(rbx); 874 pop(rax); 875 } 876 877 void InterpreterMacroAssembler::verify_method_data_pointer() { 878 assert(ProfileInterpreter, "must be profiling interpreter"); 879 #ifdef ASSERT 880 Label verify_continue; 881 push(rax); 882 push(rbx); 883 push(c_rarg3); 884 push(c_rarg2); 885 test_method_data_pointer(c_rarg3, verify_continue); // If mdp is zero, continue 886 get_method(rbx); 887 888 // If the mdp is valid, it will point to a DataLayout header which is 889 // consistent with the bcp. The converse is highly probable also. 890 load_unsigned_short(c_rarg2, 891 Address(c_rarg3, in_bytes(DataLayout::bci_offset()))); 892 addptr(c_rarg2, Address(rbx, Method::const_offset())); 893 lea(c_rarg2, Address(c_rarg2, ConstMethod::codes_offset())); 894 cmpptr(c_rarg2, r13); 895 jcc(Assembler::equal, verify_continue); 896 // rbx: method 897 // r13: bcp 898 // c_rarg3: mdp 899 call_VM_leaf(CAST_FROM_FN_PTR(address, InterpreterRuntime::verify_mdp), 900 rbx, r13, c_rarg3); 901 bind(verify_continue); 902 pop(c_rarg2); 903 pop(c_rarg3); 904 pop(rbx); 905 pop(rax); 906 #endif // ASSERT 907 } 908 909 910 void InterpreterMacroAssembler::set_mdp_data_at(Register mdp_in, 911 int constant, 912 Register value) { 913 assert(ProfileInterpreter, "must be profiling interpreter"); 914 Address data(mdp_in, constant); 915 movptr(data, value); 916 } 917 918 919 void InterpreterMacroAssembler::increment_mdp_data_at(Register mdp_in, 920 int constant, 921 bool decrement) { 922 // Counter address 923 Address data(mdp_in, constant); 924 925 increment_mdp_data_at(data, decrement); 926 } 927 928 void InterpreterMacroAssembler::increment_mdp_data_at(Address data, 929 bool decrement) { 930 assert(ProfileInterpreter, "must be profiling interpreter"); 931 // %%% this does 64bit counters at best it is wasting space 932 // at worst it is a rare bug when counters overflow 933 934 if (decrement) { 935 // Decrement the register. Set condition codes. 936 addptr(data, (int32_t) -DataLayout::counter_increment); 937 // If the decrement causes the counter to overflow, stay negative 938 Label L; 939 jcc(Assembler::negative, L); 940 addptr(data, (int32_t) DataLayout::counter_increment); 941 bind(L); 942 } else { 943 assert(DataLayout::counter_increment == 1, 944 "flow-free idiom only works with 1"); 945 // Increment the register. Set carry flag. 946 addptr(data, DataLayout::counter_increment); 947 // If the increment causes the counter to overflow, pull back by 1. 948 sbbptr(data, (int32_t)0); 949 } 950 } 951 952 953 void InterpreterMacroAssembler::increment_mdp_data_at(Register mdp_in, 954 Register reg, 955 int constant, 956 bool decrement) { 957 Address data(mdp_in, reg, Address::times_1, constant); 958 959 increment_mdp_data_at(data, decrement); 960 } 961 962 void InterpreterMacroAssembler::set_mdp_flag_at(Register mdp_in, 963 int flag_byte_constant) { 964 assert(ProfileInterpreter, "must be profiling interpreter"); 965 int header_offset = in_bytes(DataLayout::header_offset()); 966 int header_bits = DataLayout::flag_mask_to_header_mask(flag_byte_constant); 967 // Set the flag 968 orl(Address(mdp_in, header_offset), header_bits); 969 } 970 971 972 973 void InterpreterMacroAssembler::test_mdp_data_at(Register mdp_in, 974 int offset, 975 Register value, 976 Register test_value_out, 977 Label& not_equal_continue) { 978 assert(ProfileInterpreter, "must be profiling interpreter"); 979 if (test_value_out == noreg) { 980 cmpptr(value, Address(mdp_in, offset)); 981 } else { 982 // Put the test value into a register, so caller can use it: 983 movptr(test_value_out, Address(mdp_in, offset)); 984 cmpptr(test_value_out, value); 985 } 986 jcc(Assembler::notEqual, not_equal_continue); 987 } 988 989 990 void InterpreterMacroAssembler::update_mdp_by_offset(Register mdp_in, 991 int offset_of_disp) { 992 assert(ProfileInterpreter, "must be profiling interpreter"); 993 Address disp_address(mdp_in, offset_of_disp); 994 addptr(mdp_in, disp_address); 995 movptr(Address(rbp, frame::interpreter_frame_mdx_offset * wordSize), mdp_in); 996 } 997 998 999 void InterpreterMacroAssembler::update_mdp_by_offset(Register mdp_in, 1000 Register reg, 1001 int offset_of_disp) { 1002 assert(ProfileInterpreter, "must be profiling interpreter"); 1003 Address disp_address(mdp_in, reg, Address::times_1, offset_of_disp); 1004 addptr(mdp_in, disp_address); 1005 movptr(Address(rbp, frame::interpreter_frame_mdx_offset * wordSize), mdp_in); 1006 } 1007 1008 1009 void InterpreterMacroAssembler::update_mdp_by_constant(Register mdp_in, 1010 int constant) { 1011 assert(ProfileInterpreter, "must be profiling interpreter"); 1012 addptr(mdp_in, constant); 1013 movptr(Address(rbp, frame::interpreter_frame_mdx_offset * wordSize), mdp_in); 1014 } 1015 1016 1017 void InterpreterMacroAssembler::update_mdp_for_ret(Register return_bci) { 1018 assert(ProfileInterpreter, "must be profiling interpreter"); 1019 push(return_bci); // save/restore across call_VM 1020 call_VM(noreg, 1021 CAST_FROM_FN_PTR(address, InterpreterRuntime::update_mdp_for_ret), 1022 return_bci); 1023 pop(return_bci); 1024 } 1025 1026 1027 void InterpreterMacroAssembler::profile_taken_branch(Register mdp, 1028 Register bumped_count) { 1029 if (ProfileInterpreter) { 1030 Label profile_continue; 1031 1032 // If no method data exists, go to profile_continue. 1033 // Otherwise, assign to mdp 1034 test_method_data_pointer(mdp, profile_continue); 1035 1036 // We are taking a branch. Increment the taken count. 1037 // We inline increment_mdp_data_at to return bumped_count in a register 1038 //increment_mdp_data_at(mdp, in_bytes(JumpData::taken_offset())); 1039 Address data(mdp, in_bytes(JumpData::taken_offset())); 1040 movptr(bumped_count, data); 1041 assert(DataLayout::counter_increment == 1, 1042 "flow-free idiom only works with 1"); 1043 addptr(bumped_count, DataLayout::counter_increment); 1044 sbbptr(bumped_count, 0); 1045 movptr(data, bumped_count); // Store back out 1046 1047 // The method data pointer needs to be updated to reflect the new target. 1048 update_mdp_by_offset(mdp, in_bytes(JumpData::displacement_offset())); 1049 bind(profile_continue); 1050 } 1051 } 1052 1053 1054 void InterpreterMacroAssembler::profile_not_taken_branch(Register mdp) { 1055 if (ProfileInterpreter) { 1056 Label profile_continue; 1057 1058 // If no method data exists, go to profile_continue. 1059 test_method_data_pointer(mdp, profile_continue); 1060 1061 // We are taking a branch. Increment the not taken count. 1062 increment_mdp_data_at(mdp, in_bytes(BranchData::not_taken_offset())); 1063 1064 // The method data pointer needs to be updated to correspond to 1065 // the next bytecode 1066 update_mdp_by_constant(mdp, in_bytes(BranchData::branch_data_size())); 1067 bind(profile_continue); 1068 } 1069 } 1070 1071 void InterpreterMacroAssembler::profile_call(Register mdp) { 1072 if (ProfileInterpreter) { 1073 Label profile_continue; 1074 1075 // If no method data exists, go to profile_continue. 1076 test_method_data_pointer(mdp, profile_continue); 1077 1078 // We are making a call. Increment the count. 1079 increment_mdp_data_at(mdp, in_bytes(CounterData::count_offset())); 1080 1081 // The method data pointer needs to be updated to reflect the new target. 1082 update_mdp_by_constant(mdp, in_bytes(CounterData::counter_data_size())); 1083 bind(profile_continue); 1084 } 1085 } 1086 1087 1088 void InterpreterMacroAssembler::profile_final_call(Register mdp) { 1089 if (ProfileInterpreter) { 1090 Label profile_continue; 1091 1092 // If no method data exists, go to profile_continue. 1093 test_method_data_pointer(mdp, profile_continue); 1094 1095 // We are making a call. Increment the count. 1096 increment_mdp_data_at(mdp, in_bytes(CounterData::count_offset())); 1097 1098 // The method data pointer needs to be updated to reflect the new target. 1099 update_mdp_by_constant(mdp, 1100 in_bytes(VirtualCallData:: 1101 virtual_call_data_size())); 1102 bind(profile_continue); 1103 } 1104 } 1105 1106 1107 void InterpreterMacroAssembler::profile_virtual_call(Register receiver, 1108 Register mdp, 1109 Register reg2, 1110 bool receiver_can_be_null) { 1111 if (ProfileInterpreter) { 1112 Label profile_continue; 1113 1114 // If no method data exists, go to profile_continue. 1115 test_method_data_pointer(mdp, profile_continue); 1116 1117 Label skip_receiver_profile; 1118 if (receiver_can_be_null) { 1119 Label not_null; 1120 testptr(receiver, receiver); 1121 jccb(Assembler::notZero, not_null); 1122 // We are making a call. Increment the count for null receiver. 1123 increment_mdp_data_at(mdp, in_bytes(CounterData::count_offset())); 1124 jmp(skip_receiver_profile); 1125 bind(not_null); 1126 } 1127 1128 // Record the receiver type. 1129 record_klass_in_profile(receiver, mdp, reg2, true); 1130 bind(skip_receiver_profile); 1131 1132 // The method data pointer needs to be updated to reflect the new target. 1133 update_mdp_by_constant(mdp, 1134 in_bytes(VirtualCallData:: 1135 virtual_call_data_size())); 1136 bind(profile_continue); 1137 } 1138 } 1139 1140 // This routine creates a state machine for updating the multi-row 1141 // type profile at a virtual call site (or other type-sensitive bytecode). 1142 // The machine visits each row (of receiver/count) until the receiver type 1143 // is found, or until it runs out of rows. At the same time, it remembers 1144 // the location of the first empty row. (An empty row records null for its 1145 // receiver, and can be allocated for a newly-observed receiver type.) 1146 // Because there are two degrees of freedom in the state, a simple linear 1147 // search will not work; it must be a decision tree. Hence this helper 1148 // function is recursive, to generate the required tree structured code. 1149 // It's the interpreter, so we are trading off code space for speed. 1150 // See below for example code. 1151 void InterpreterMacroAssembler::record_klass_in_profile_helper( 1152 Register receiver, Register mdp, 1153 Register reg2, int start_row, 1154 Label& done, bool is_virtual_call) { 1155 if (TypeProfileWidth == 0) { 1156 if (is_virtual_call) { 1157 increment_mdp_data_at(mdp, in_bytes(CounterData::count_offset())); 1158 } 1159 return; 1160 } 1161 1162 int last_row = VirtualCallData::row_limit() - 1; 1163 assert(start_row <= last_row, "must be work left to do"); 1164 // Test this row for both the receiver and for null. 1165 // Take any of three different outcomes: 1166 // 1. found receiver => increment count and goto done 1167 // 2. found null => keep looking for case 1, maybe allocate this cell 1168 // 3. found something else => keep looking for cases 1 and 2 1169 // Case 3 is handled by a recursive call. 1170 for (int row = start_row; row <= last_row; row++) { 1171 Label next_test; 1172 bool test_for_null_also = (row == start_row); 1173 1174 // See if the receiver is receiver[n]. 1175 int recvr_offset = in_bytes(VirtualCallData::receiver_offset(row)); 1176 test_mdp_data_at(mdp, recvr_offset, receiver, 1177 (test_for_null_also ? reg2 : noreg), 1178 next_test); 1179 // (Reg2 now contains the receiver from the CallData.) 1180 1181 // The receiver is receiver[n]. Increment count[n]. 1182 int count_offset = in_bytes(VirtualCallData::receiver_count_offset(row)); 1183 increment_mdp_data_at(mdp, count_offset); 1184 jmp(done); 1185 bind(next_test); 1186 1187 if (test_for_null_also) { 1188 Label found_null; 1189 // Failed the equality check on receiver[n]... Test for null. 1190 testptr(reg2, reg2); 1191 if (start_row == last_row) { 1192 // The only thing left to do is handle the null case. 1193 if (is_virtual_call) { 1194 jccb(Assembler::zero, found_null); 1195 // Receiver did not match any saved receiver and there is no empty row for it. 1196 // Increment total counter to indicate polymorphic case. 1197 increment_mdp_data_at(mdp, in_bytes(CounterData::count_offset())); 1198 jmp(done); 1199 bind(found_null); 1200 } else { 1201 jcc(Assembler::notZero, done); 1202 } 1203 break; 1204 } 1205 // Since null is rare, make it be the branch-taken case. 1206 jcc(Assembler::zero, found_null); 1207 1208 // Put all the "Case 3" tests here. 1209 record_klass_in_profile_helper(receiver, mdp, reg2, start_row + 1, done, is_virtual_call); 1210 1211 // Found a null. Keep searching for a matching receiver, 1212 // but remember that this is an empty (unused) slot. 1213 bind(found_null); 1214 } 1215 } 1216 1217 // In the fall-through case, we found no matching receiver, but we 1218 // observed the receiver[start_row] is NULL. 1219 1220 // Fill in the receiver field and increment the count. 1221 int recvr_offset = in_bytes(VirtualCallData::receiver_offset(start_row)); 1222 set_mdp_data_at(mdp, recvr_offset, receiver); 1223 int count_offset = in_bytes(VirtualCallData::receiver_count_offset(start_row)); 1224 movl(reg2, DataLayout::counter_increment); 1225 set_mdp_data_at(mdp, count_offset, reg2); 1226 if (start_row > 0) { 1227 jmp(done); 1228 } 1229 } 1230 1231 // Example state machine code for three profile rows: 1232 // // main copy of decision tree, rooted at row[1] 1233 // if (row[0].rec == rec) { row[0].incr(); goto done; } 1234 // if (row[0].rec != NULL) { 1235 // // inner copy of decision tree, rooted at row[1] 1236 // if (row[1].rec == rec) { row[1].incr(); goto done; } 1237 // if (row[1].rec != NULL) { 1238 // // degenerate decision tree, rooted at row[2] 1239 // if (row[2].rec == rec) { row[2].incr(); goto done; } 1240 // if (row[2].rec != NULL) { count.incr(); goto done; } // overflow 1241 // row[2].init(rec); goto done; 1242 // } else { 1243 // // remember row[1] is empty 1244 // if (row[2].rec == rec) { row[2].incr(); goto done; } 1245 // row[1].init(rec); goto done; 1246 // } 1247 // } else { 1248 // // remember row[0] is empty 1249 // if (row[1].rec == rec) { row[1].incr(); goto done; } 1250 // if (row[2].rec == rec) { row[2].incr(); goto done; } 1251 // row[0].init(rec); goto done; 1252 // } 1253 // done: 1254 1255 void InterpreterMacroAssembler::record_klass_in_profile(Register receiver, 1256 Register mdp, Register reg2, 1257 bool is_virtual_call) { 1258 assert(ProfileInterpreter, "must be profiling"); 1259 Label done; 1260 1261 record_klass_in_profile_helper(receiver, mdp, reg2, 0, done, is_virtual_call); 1262 1263 bind (done); 1264 } 1265 1266 void InterpreterMacroAssembler::profile_ret(Register return_bci, 1267 Register mdp) { 1268 if (ProfileInterpreter) { 1269 Label profile_continue; 1270 uint row; 1271 1272 // If no method data exists, go to profile_continue. 1273 test_method_data_pointer(mdp, profile_continue); 1274 1275 // Update the total ret count. 1276 increment_mdp_data_at(mdp, in_bytes(CounterData::count_offset())); 1277 1278 for (row = 0; row < RetData::row_limit(); row++) { 1279 Label next_test; 1280 1281 // See if return_bci is equal to bci[n]: 1282 test_mdp_data_at(mdp, 1283 in_bytes(RetData::bci_offset(row)), 1284 return_bci, noreg, 1285 next_test); 1286 1287 // return_bci is equal to bci[n]. Increment the count. 1288 increment_mdp_data_at(mdp, in_bytes(RetData::bci_count_offset(row))); 1289 1290 // The method data pointer needs to be updated to reflect the new target. 1291 update_mdp_by_offset(mdp, 1292 in_bytes(RetData::bci_displacement_offset(row))); 1293 jmp(profile_continue); 1294 bind(next_test); 1295 } 1296 1297 update_mdp_for_ret(return_bci); 1298 1299 bind(profile_continue); 1300 } 1301 } 1302 1303 1304 void InterpreterMacroAssembler::profile_null_seen(Register mdp) { 1305 if (ProfileInterpreter) { 1306 Label profile_continue; 1307 1308 // If no method data exists, go to profile_continue. 1309 test_method_data_pointer(mdp, profile_continue); 1310 1311 set_mdp_flag_at(mdp, BitData::null_seen_byte_constant()); 1312 1313 // The method data pointer needs to be updated. 1314 int mdp_delta = in_bytes(BitData::bit_data_size()); 1315 if (TypeProfileCasts) { 1316 mdp_delta = in_bytes(VirtualCallData::virtual_call_data_size()); 1317 } 1318 update_mdp_by_constant(mdp, mdp_delta); 1319 1320 bind(profile_continue); 1321 } 1322 } 1323 1324 1325 void InterpreterMacroAssembler::profile_typecheck_failed(Register mdp) { 1326 if (ProfileInterpreter && TypeProfileCasts) { 1327 Label profile_continue; 1328 1329 // If no method data exists, go to profile_continue. 1330 test_method_data_pointer(mdp, profile_continue); 1331 1332 int count_offset = in_bytes(CounterData::count_offset()); 1333 // Back up the address, since we have already bumped the mdp. 1334 count_offset -= in_bytes(VirtualCallData::virtual_call_data_size()); 1335 1336 // *Decrement* the counter. We expect to see zero or small negatives. 1337 increment_mdp_data_at(mdp, count_offset, true); 1338 1339 bind (profile_continue); 1340 } 1341 } 1342 1343 1344 void InterpreterMacroAssembler::profile_typecheck(Register mdp, Register klass, Register reg2) { 1345 if (ProfileInterpreter) { 1346 Label profile_continue; 1347 1348 // If no method data exists, go to profile_continue. 1349 test_method_data_pointer(mdp, profile_continue); 1350 1351 // The method data pointer needs to be updated. 1352 int mdp_delta = in_bytes(BitData::bit_data_size()); 1353 if (TypeProfileCasts) { 1354 mdp_delta = in_bytes(VirtualCallData::virtual_call_data_size()); 1355 1356 // Record the object type. 1357 record_klass_in_profile(klass, mdp, reg2, false); 1358 } 1359 update_mdp_by_constant(mdp, mdp_delta); 1360 1361 bind(profile_continue); 1362 } 1363 } 1364 1365 1366 void InterpreterMacroAssembler::profile_switch_default(Register mdp) { 1367 if (ProfileInterpreter) { 1368 Label profile_continue; 1369 1370 // If no method data exists, go to profile_continue. 1371 test_method_data_pointer(mdp, profile_continue); 1372 1373 // Update the default case count 1374 increment_mdp_data_at(mdp, 1375 in_bytes(MultiBranchData::default_count_offset())); 1376 1377 // The method data pointer needs to be updated. 1378 update_mdp_by_offset(mdp, 1379 in_bytes(MultiBranchData:: 1380 default_displacement_offset())); 1381 1382 bind(profile_continue); 1383 } 1384 } 1385 1386 1387 void InterpreterMacroAssembler::profile_switch_case(Register index, 1388 Register mdp, 1389 Register reg2) { 1390 if (ProfileInterpreter) { 1391 Label profile_continue; 1392 1393 // If no method data exists, go to profile_continue. 1394 test_method_data_pointer(mdp, profile_continue); 1395 1396 // Build the base (index * per_case_size_in_bytes()) + 1397 // case_array_offset_in_bytes() 1398 movl(reg2, in_bytes(MultiBranchData::per_case_size())); 1399 imulptr(index, reg2); // XXX l ? 1400 addptr(index, in_bytes(MultiBranchData::case_array_offset())); // XXX l ? 1401 1402 // Update the case count 1403 increment_mdp_data_at(mdp, 1404 index, 1405 in_bytes(MultiBranchData::relative_count_offset())); 1406 1407 // The method data pointer needs to be updated. 1408 update_mdp_by_offset(mdp, 1409 index, 1410 in_bytes(MultiBranchData:: 1411 relative_displacement_offset())); 1412 1413 bind(profile_continue); 1414 } 1415 } 1416 1417 1418 1419 void InterpreterMacroAssembler::verify_oop(Register reg, TosState state) { 1420 if (state == atos) { 1421 MacroAssembler::verify_oop(reg); 1422 } 1423 } 1424 1425 void InterpreterMacroAssembler::verify_FPU(int stack_depth, TosState state) { 1426 } 1427 1428 // Jump if ((*counter_addr += increment) & mask) satisfies the condition. 1429 void InterpreterMacroAssembler::increment_mask_and_jump(Address counter_addr, 1430 int increment, int mask, 1431 Register scratch, bool preloaded, 1432 Condition cond, Label* where) { 1433 if (!preloaded) { 1434 movl(scratch, counter_addr); 1435 } 1436 incrementl(scratch, increment); 1437 movl(counter_addr, scratch); 1438 andl(scratch, mask); 1439 jcc(cond, *where); 1440 } 1441 #endif // !CC_INTERP 1442 1443 1444 void InterpreterMacroAssembler::notify_method_entry() { 1445 // Whenever JVMTI is interp_only_mode, method entry/exit events are sent to 1446 // track stack depth. If it is possible to enter interp_only_mode we add 1447 // the code to check if the event should be sent. 1448 if (JvmtiExport::can_post_interpreter_events()) { 1449 Label L; 1450 movl(rdx, Address(r15_thread, JavaThread::interp_only_mode_offset())); 1451 testl(rdx, rdx); 1452 jcc(Assembler::zero, L); 1453 call_VM(noreg, CAST_FROM_FN_PTR(address, 1454 InterpreterRuntime::post_method_entry)); 1455 bind(L); 1456 } 1457 1458 { 1459 SkipIfEqual skip(this, &DTraceMethodProbes, false); 1460 get_method(c_rarg1); 1461 call_VM_leaf(CAST_FROM_FN_PTR(address, SharedRuntime::dtrace_method_entry), 1462 r15_thread, c_rarg1); 1463 } 1464 1465 // RedefineClasses() tracing support for obsolete method entry 1466 if (RC_TRACE_IN_RANGE(0x00001000, 0x00002000)) { 1467 get_method(c_rarg1); 1468 call_VM_leaf( 1469 CAST_FROM_FN_PTR(address, SharedRuntime::rc_trace_method_entry), 1470 r15_thread, c_rarg1); 1471 } 1472 } 1473 1474 1475 void InterpreterMacroAssembler::notify_method_exit( 1476 TosState state, NotifyMethodExitMode mode) { 1477 // Whenever JVMTI is interp_only_mode, method entry/exit events are sent to 1478 // track stack depth. If it is possible to enter interp_only_mode we add 1479 // the code to check if the event should be sent. 1480 if (mode == NotifyJVMTI && JvmtiExport::can_post_interpreter_events()) { 1481 Label L; 1482 // Note: frame::interpreter_frame_result has a dependency on how the 1483 // method result is saved across the call to post_method_exit. If this 1484 // is changed then the interpreter_frame_result implementation will 1485 // need to be updated too. 1486 1487 // For c++ interpreter the result is always stored at a known location in the frame 1488 // template interpreter will leave it on the top of the stack. 1489 NOT_CC_INTERP(push(state);) 1490 movl(rdx, Address(r15_thread, JavaThread::interp_only_mode_offset())); 1491 testl(rdx, rdx); 1492 jcc(Assembler::zero, L); 1493 call_VM(noreg, 1494 CAST_FROM_FN_PTR(address, InterpreterRuntime::post_method_exit)); 1495 bind(L); 1496 NOT_CC_INTERP(pop(state)); 1497 } 1498 1499 { 1500 SkipIfEqual skip(this, &DTraceMethodProbes, false); 1501 NOT_CC_INTERP(push(state)); 1502 get_method(c_rarg1); 1503 call_VM_leaf(CAST_FROM_FN_PTR(address, SharedRuntime::dtrace_method_exit), 1504 r15_thread, c_rarg1); 1505 NOT_CC_INTERP(pop(state)); 1506 } 1507 } 1508