1 /* 2 * Copyright (c) 2008, 2018, 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 "asm/assembler.hpp" 27 #include "asm/macroAssembler.inline.hpp" 28 #include "interpreter/bytecodeHistogram.hpp" 29 #include "interpreter/interp_masm.hpp" 30 #include "interpreter/interpreter.hpp" 31 #include "interpreter/interpreterRuntime.hpp" 32 #include "interpreter/templateInterpreterGenerator.hpp" 33 #include "interpreter/templateTable.hpp" 34 #include "oops/arrayOop.hpp" 35 #include "oops/methodData.hpp" 36 #include "oops/method.hpp" 37 #include "oops/oop.inline.hpp" 38 #include "prims/jvmtiExport.hpp" 39 #include "prims/jvmtiThreadState.hpp" 40 #include "prims/methodHandles.hpp" 41 #include "runtime/arguments.hpp" 42 #include "runtime/deoptimization.hpp" 43 #include "runtime/frame.inline.hpp" 44 #include "runtime/sharedRuntime.hpp" 45 #include "runtime/stubRoutines.hpp" 46 #include "runtime/synchronizer.hpp" 47 #include "runtime/timer.hpp" 48 #include "runtime/vframeArray.hpp" 49 #include "utilities/align.hpp" 50 #include "utilities/debug.hpp" 51 #include "utilities/macros.hpp" 52 53 // Size of interpreter code. Increase if too small. Interpreter will 54 // fail with a guarantee ("not enough space for interpreter generation"); 55 // if too small. 56 // Run with +PrintInterpreter to get the VM to print out the size. 57 // Max size with JVMTI 58 int TemplateInterpreter::InterpreterCodeSize = 180 * 1024; 59 60 #define __ _masm-> 61 62 //------------------------------------------------------------------------------------------------------------------------ 63 64 address TemplateInterpreterGenerator::generate_slow_signature_handler() { 65 address entry = __ pc(); 66 67 // callee-save register for saving LR, shared with generate_native_entry 68 const Register Rsaved_ret_addr = Rtmp_save0; 69 70 __ mov(Rsaved_ret_addr, LR); 71 72 __ mov(R1, Rmethod); 73 __ mov(R2, Rlocals); 74 __ mov(R3, SP); 75 76 77 // Safer to save R9 (when scratched) since callers may have been 78 // written assuming R9 survives. This is suboptimal but 79 // probably not important for this slow case call site. 80 // Note for R9 saving: slow_signature_handler may copy register 81 // arguments above the current SP (passed as R3). It is safe for 82 // call_VM to use push and pop to protect additional values on the 83 // stack if needed. 84 __ call_VM(CAST_FROM_FN_PTR(address, InterpreterRuntime::slow_signature_handler), true /* save R9 if needed*/); 85 __ add(SP, SP, wordSize); // Skip R0 86 __ pop(RegisterSet(R1, R3)); // Load arguments passed in registers 87 #ifdef __ABI_HARD__ 88 // Few alternatives to an always-load-FP-registers approach: 89 // - parse method signature to detect FP arguments 90 // - keep a counter/flag on a stack indicationg number of FP arguments in the method. 91 // The later has been originally implemented and tested but a conditional path could 92 // eliminate any gain imposed by avoiding 8 double word loads. 93 __ fldmiad(SP, FloatRegisterSet(D0, 8), writeback); 94 #endif // __ABI_HARD__ 95 96 __ ret(Rsaved_ret_addr); 97 98 return entry; 99 } 100 101 102 // 103 // Various method entries (that c++ and asm interpreter agree upon) 104 //------------------------------------------------------------------------------------------------------------------------ 105 // 106 // 107 108 // Abstract method entry 109 // Attempt to execute abstract method. Throw exception 110 address TemplateInterpreterGenerator::generate_abstract_entry(void) { 111 address entry_point = __ pc(); 112 113 114 __ empty_expression_stack(); 115 116 __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::throw_AbstractMethodError)); 117 118 DEBUG_ONLY(STOP("generate_abstract_entry");) // Should not reach here 119 return entry_point; 120 } 121 122 address TemplateInterpreterGenerator::generate_math_entry(AbstractInterpreter::MethodKind kind) { 123 if (!InlineIntrinsics) return NULL; // Generate a vanilla entry 124 125 // TODO: ARM 126 return NULL; 127 128 address entry_point = __ pc(); 129 STOP("generate_math_entry"); 130 return entry_point; 131 } 132 133 address TemplateInterpreterGenerator::generate_StackOverflowError_handler() { 134 address entry = __ pc(); 135 136 // Note: There should be a minimal interpreter frame set up when stack 137 // overflow occurs since we check explicitly for it now. 138 // 139 #ifdef ASSERT 140 { Label L; 141 __ sub(Rtemp, FP, - frame::interpreter_frame_monitor_block_top_offset * wordSize); 142 __ cmp(SP, Rtemp); // Rtemp = maximal SP for current FP, 143 // (stack grows negative) 144 __ b(L, ls); // check if frame is complete 145 __ stop ("interpreter frame not set up"); 146 __ bind(L); 147 } 148 #endif // ASSERT 149 150 // Restore bcp under the assumption that the current frame is still 151 // interpreted 152 __ restore_bcp(); 153 154 // expression stack must be empty before entering the VM if an exception 155 // happened 156 __ empty_expression_stack(); 157 158 // throw exception 159 __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::throw_StackOverflowError)); 160 161 __ should_not_reach_here(); 162 163 return entry; 164 } 165 166 address TemplateInterpreterGenerator::generate_ArrayIndexOutOfBounds_handler() { 167 address entry = __ pc(); 168 169 // index is in R4_ArrayIndexOutOfBounds_index 170 171 // expression stack must be empty before entering the VM if an exception happened 172 __ empty_expression_stack(); 173 174 // setup parameters 175 // Array expected in R1. 176 __ mov(R2, R4_ArrayIndexOutOfBounds_index); 177 178 __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::throw_ArrayIndexOutOfBoundsException), R1, R2); 179 180 __ nop(); // to avoid filling CPU pipeline with invalid instructions 181 __ nop(); 182 __ should_not_reach_here(); 183 184 return entry; 185 } 186 187 address TemplateInterpreterGenerator::generate_ClassCastException_handler() { 188 address entry = __ pc(); 189 190 // object is in R2_ClassCastException_obj 191 192 // expression stack must be empty before entering the VM if an exception 193 // happened 194 __ empty_expression_stack(); 195 196 __ mov(R1, R2_ClassCastException_obj); 197 __ call_VM(noreg, 198 CAST_FROM_FN_PTR(address, 199 InterpreterRuntime::throw_ClassCastException), 200 R1); 201 202 __ should_not_reach_here(); 203 204 return entry; 205 } 206 207 address TemplateInterpreterGenerator::generate_exception_handler_common(const char* name, const char* message, bool pass_oop) { 208 assert(!pass_oop || message == NULL, "either oop or message but not both"); 209 address entry = __ pc(); 210 211 InlinedString Lname(name); 212 InlinedString Lmessage(message); 213 214 if (pass_oop) { 215 // object is at TOS 216 __ pop_ptr(R2); 217 } 218 219 // expression stack must be empty before entering the VM if an exception happened 220 __ empty_expression_stack(); 221 222 // setup parameters 223 __ ldr_literal(R1, Lname); 224 225 if (pass_oop) { 226 __ call_VM(Rexception_obj, CAST_FROM_FN_PTR(address, InterpreterRuntime::create_klass_exception), R1, R2); 227 } else { 228 if (message != NULL) { 229 __ ldr_literal(R2, Lmessage); 230 } else { 231 __ mov(R2, 0); 232 } 233 __ call_VM(Rexception_obj, CAST_FROM_FN_PTR(address, InterpreterRuntime::create_exception), R1, R2); 234 } 235 236 // throw exception 237 __ b(Interpreter::throw_exception_entry()); 238 239 __ nop(); // to avoid filling CPU pipeline with invalid instructions 240 __ nop(); 241 __ bind_literal(Lname); 242 if (!pass_oop && (message != NULL)) { 243 __ bind_literal(Lmessage); 244 } 245 246 return entry; 247 } 248 249 address TemplateInterpreterGenerator::generate_return_entry_for(TosState state, int step, size_t index_size) { 250 address entry = __ pc(); 251 252 __ interp_verify_oop(R0_tos, state, __FILE__, __LINE__); 253 254 // Restore stack bottom in case i2c adjusted stack 255 __ ldr(SP, Address(FP, frame::interpreter_frame_last_sp_offset * wordSize)); 256 // and NULL it as marker that SP is now tos until next java call 257 __ mov(Rtemp, (int)NULL_WORD); 258 __ str(Rtemp, Address(FP, frame::interpreter_frame_last_sp_offset * wordSize)); 259 260 __ restore_method(); 261 __ restore_bcp(); 262 __ restore_dispatch(); 263 __ restore_locals(); 264 265 const Register Rcache = R2_tmp; 266 const Register Rindex = R3_tmp; 267 __ get_cache_and_index_at_bcp(Rcache, Rindex, 1, index_size); 268 269 __ add(Rtemp, Rcache, AsmOperand(Rindex, lsl, LogBytesPerWord)); 270 __ ldrb(Rtemp, Address(Rtemp, ConstantPoolCache::base_offset() + ConstantPoolCacheEntry::flags_offset())); 271 __ check_stack_top(); 272 __ add(Rstack_top, Rstack_top, AsmOperand(Rtemp, lsl, Interpreter::logStackElementSize)); 273 274 __ convert_retval_to_tos(state); 275 276 __ check_and_handle_popframe(); 277 __ check_and_handle_earlyret(); 278 279 __ dispatch_next(state, step); 280 281 return entry; 282 } 283 284 285 address TemplateInterpreterGenerator::generate_deopt_entry_for(TosState state, int step, address continuation) { 286 address entry = __ pc(); 287 288 __ interp_verify_oop(R0_tos, state, __FILE__, __LINE__); 289 290 // The stack is not extended by deopt but we must NULL last_sp as this 291 // entry is like a "return". 292 __ mov(Rtemp, 0); 293 __ str(Rtemp, Address(FP, frame::interpreter_frame_last_sp_offset * wordSize)); 294 295 __ restore_method(); 296 __ restore_bcp(); 297 __ restore_dispatch(); 298 __ restore_locals(); 299 300 // handle exceptions 301 { Label L; 302 __ ldr(Rtemp, Address(Rthread, Thread::pending_exception_offset())); 303 __ cbz(Rtemp, L); 304 __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::throw_pending_exception)); 305 __ should_not_reach_here(); 306 __ bind(L); 307 } 308 309 if (continuation == NULL) { 310 __ dispatch_next(state, step); 311 } else { 312 __ jump_to_entry(continuation); 313 } 314 315 return entry; 316 } 317 318 address TemplateInterpreterGenerator::generate_result_handler_for(BasicType type) { 319 // Result handlers are not used on 32-bit ARM 320 // since the returned value is already in appropriate format. 321 __ should_not_reach_here(); // to avoid empty code block 322 323 // The result handler non-zero indicates an object is returned and this is 324 // used in the native entry code. 325 return type == T_OBJECT ? (address)(-1) : NULL; 326 } 327 328 address TemplateInterpreterGenerator::generate_safept_entry_for(TosState state, address runtime_entry) { 329 address entry = __ pc(); 330 __ push(state); 331 __ call_VM(noreg, runtime_entry); 332 333 // load current bytecode 334 __ ldrb(R3_bytecode, Address(Rbcp)); 335 __ dispatch_only_normal(vtos); 336 return entry; 337 } 338 339 340 // Helpers for commoning out cases in the various type of method entries. 341 // 342 343 // increment invocation count & check for overflow 344 // 345 // Note: checking for negative value instead of overflow 346 // so we have a 'sticky' overflow test 347 // 348 // In: Rmethod. 349 // 350 // Uses R0, R1, Rtemp. 351 // 352 void TemplateInterpreterGenerator::generate_counter_incr(Label* overflow, 353 Label* profile_method, 354 Label* profile_method_continue) { 355 Label done; 356 const Register Rcounters = Rtemp; 357 const Address invocation_counter(Rcounters, 358 MethodCounters::invocation_counter_offset() + 359 InvocationCounter::counter_offset()); 360 361 // Note: In tiered we increment either counters in MethodCounters* or 362 // in MDO depending if we're profiling or not. 363 if (TieredCompilation) { 364 int increment = InvocationCounter::count_increment; 365 Label no_mdo; 366 if (ProfileInterpreter) { 367 // Are we profiling? 368 __ ldr(R1_tmp, Address(Rmethod, Method::method_data_offset())); 369 __ cbz(R1_tmp, no_mdo); 370 // Increment counter in the MDO 371 const Address mdo_invocation_counter(R1_tmp, 372 in_bytes(MethodData::invocation_counter_offset()) + 373 in_bytes(InvocationCounter::counter_offset())); 374 const Address mask(R1_tmp, in_bytes(MethodData::invoke_mask_offset())); 375 __ increment_mask_and_jump(mdo_invocation_counter, increment, mask, R0_tmp, Rtemp, eq, overflow); 376 __ b(done); 377 } 378 __ bind(no_mdo); 379 __ get_method_counters(Rmethod, Rcounters, done); 380 const Address mask(Rcounters, in_bytes(MethodCounters::invoke_mask_offset())); 381 __ increment_mask_and_jump(invocation_counter, increment, mask, R0_tmp, R1_tmp, eq, overflow); 382 __ bind(done); 383 } else { // not TieredCompilation 384 const Address backedge_counter(Rcounters, 385 MethodCounters::backedge_counter_offset() + 386 InvocationCounter::counter_offset()); 387 388 const Register Ricnt = R0_tmp; // invocation counter 389 const Register Rbcnt = R1_tmp; // backedge counter 390 391 __ get_method_counters(Rmethod, Rcounters, done); 392 393 if (ProfileInterpreter) { 394 const Register Riic = R1_tmp; 395 __ ldr_s32(Riic, Address(Rcounters, MethodCounters::interpreter_invocation_counter_offset())); 396 __ add(Riic, Riic, 1); 397 __ str_32(Riic, Address(Rcounters, MethodCounters::interpreter_invocation_counter_offset())); 398 } 399 400 // Update standard invocation counters 401 402 __ ldr_u32(Ricnt, invocation_counter); 403 __ ldr_u32(Rbcnt, backedge_counter); 404 405 __ add(Ricnt, Ricnt, InvocationCounter::count_increment); 406 407 __ bic(Rbcnt, Rbcnt, ~InvocationCounter::count_mask_value); // mask out the status bits 408 409 __ str_32(Ricnt, invocation_counter); // save invocation count 410 __ add(Ricnt, Ricnt, Rbcnt); // add both counters 411 412 // profile_method is non-null only for interpreted method so 413 // profile_method != NULL == !native_call 414 // BytecodeInterpreter only calls for native so code is elided. 415 416 if (ProfileInterpreter && profile_method != NULL) { 417 assert(profile_method_continue != NULL, "should be non-null"); 418 419 // Test to see if we should create a method data oop 420 // Reuse R1_tmp as we don't need backedge counters anymore. 421 Address profile_limit(Rcounters, in_bytes(MethodCounters::interpreter_profile_limit_offset())); 422 __ ldr_s32(R1_tmp, profile_limit); 423 __ cmp_32(Ricnt, R1_tmp); 424 __ b(*profile_method_continue, lt); 425 426 // if no method data exists, go to profile_method 427 __ test_method_data_pointer(R1_tmp, *profile_method); 428 } 429 430 Address invoke_limit(Rcounters, in_bytes(MethodCounters::interpreter_invocation_limit_offset())); 431 __ ldr_s32(R1_tmp, invoke_limit); 432 __ cmp_32(Ricnt, R1_tmp); 433 __ b(*overflow, hs); 434 __ bind(done); 435 } 436 } 437 438 void TemplateInterpreterGenerator::generate_counter_overflow(Label& do_continue) { 439 // InterpreterRuntime::frequency_counter_overflow takes one argument 440 // indicating if the counter overflow occurs at a backwards branch (non-NULL bcp). 441 // The call returns the address of the verified entry point for the method or NULL 442 // if the compilation did not complete (either went background or bailed out). 443 __ mov(R1, (int)false); 444 __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::frequency_counter_overflow), R1); 445 446 // jump to the interpreted entry. 447 __ b(do_continue); 448 } 449 450 void TemplateInterpreterGenerator::generate_stack_overflow_check(void) { 451 // Check if we've got enough room on the stack for 452 // - overhead; 453 // - locals; 454 // - expression stack. 455 // 456 // Registers on entry: 457 // 458 // R3 = number of additional locals 459 // Rthread 460 // Rmethod 461 // Registers used: R0, R1, R2, Rtemp. 462 463 const Register Radditional_locals = R3; 464 const Register RmaxStack = R2; 465 466 // monitor entry size 467 const int entry_size = frame::interpreter_frame_monitor_size() * wordSize; 468 469 // total overhead size: entry_size + (saved registers, thru expr stack bottom). 470 // be sure to change this if you add/subtract anything to/from the overhead area 471 const int overhead_size = (frame::sender_sp_offset - frame::interpreter_frame_initial_sp_offset)*wordSize + entry_size; 472 473 // Pages reserved for VM runtime calls and subsequent Java calls. 474 const int reserved_pages = JavaThread::stack_shadow_zone_size(); 475 476 // Thread::stack_size() includes guard pages, and they should not be touched. 477 const int guard_pages = JavaThread::stack_guard_zone_size(); 478 479 __ ldr(R0, Address(Rthread, Thread::stack_base_offset())); 480 __ ldr(R1, Address(Rthread, Thread::stack_size_offset())); 481 __ ldr(Rtemp, Address(Rmethod, Method::const_offset())); 482 __ ldrh(RmaxStack, Address(Rtemp, ConstMethod::max_stack_offset())); 483 __ sub_slow(Rtemp, SP, overhead_size + reserved_pages + guard_pages + Method::extra_stack_words()); 484 485 // reserve space for additional locals 486 __ sub(Rtemp, Rtemp, AsmOperand(Radditional_locals, lsl, Interpreter::logStackElementSize)); 487 488 // stack size 489 __ sub(R0, R0, R1); 490 491 // reserve space for expression stack 492 __ sub(Rtemp, Rtemp, AsmOperand(RmaxStack, lsl, Interpreter::logStackElementSize)); 493 494 __ cmp(Rtemp, R0); 495 496 __ mov(SP, Rsender_sp, ls); // restore SP 497 __ b(StubRoutines::throw_StackOverflowError_entry(), ls); 498 } 499 500 501 // Allocate monitor and lock method (asm interpreter) 502 // 503 void TemplateInterpreterGenerator::lock_method() { 504 // synchronize method 505 506 const int entry_size = frame::interpreter_frame_monitor_size() * wordSize; 507 assert ((entry_size % StackAlignmentInBytes) == 0, "should keep stack alignment"); 508 509 #ifdef ASSERT 510 { Label L; 511 __ ldr_u32(Rtemp, Address(Rmethod, Method::access_flags_offset())); 512 __ tbnz(Rtemp, JVM_ACC_SYNCHRONIZED_BIT, L); 513 __ stop("method doesn't need synchronization"); 514 __ bind(L); 515 } 516 #endif // ASSERT 517 518 // get synchronization object 519 { Label done; 520 __ ldr_u32(Rtemp, Address(Rmethod, Method::access_flags_offset())); 521 __ tst(Rtemp, JVM_ACC_STATIC); 522 __ ldr(R0, Address(Rlocals, Interpreter::local_offset_in_bytes(0)), eq); // get receiver (assume this is frequent case) 523 __ b(done, eq); 524 __ load_mirror(R0, Rmethod, Rtemp); 525 __ bind(done); 526 } 527 528 // add space for monitor & lock 529 530 531 __ sub(Rstack_top, Rstack_top, entry_size); 532 __ check_stack_top_on_expansion(); 533 // add space for a monitor entry 534 __ str(Rstack_top, Address(FP, frame::interpreter_frame_monitor_block_top_offset * wordSize)); 535 // set new monitor block top 536 __ str(R0, Address(Rstack_top, BasicObjectLock::obj_offset_in_bytes())); 537 // store object 538 __ mov(R1, Rstack_top); // monitor entry address 539 __ lock_object(R1); 540 } 541 542 543 // 544 // Generate a fixed interpreter frame. This is identical setup for interpreted methods 545 // and for native methods hence the shared code. 546 547 void TemplateInterpreterGenerator::generate_fixed_frame(bool native_call) { 548 // Generates the following stack layout: 549 // 550 // [ expr. stack bottom ] 551 // [ saved Rbcp ] 552 // [ current Rlocals ] 553 // [ cache ] 554 // [ mdx ] 555 // [ Method* ] 556 // [ last_sp ] 557 // [ sender_sp ] 558 // [ saved FP ] <--- FP 559 // [ saved LR ] 560 561 // initialize fixed part of activation frame 562 __ push(LR); // save return address 563 __ push(FP); // save FP 564 __ mov(FP, SP); // establish new FP 565 566 __ push(Rsender_sp); 567 568 __ mov(R0, 0); 569 __ push(R0); // leave last_sp as null 570 571 // setup Rbcp 572 if (native_call) { 573 __ mov(Rbcp, 0); // bcp = 0 for native calls 574 } else { 575 __ ldr(Rtemp, Address(Rmethod, Method::const_offset())); // get ConstMethod* 576 __ add(Rbcp, Rtemp, ConstMethod::codes_offset()); // get codebase 577 } 578 579 __ push(Rmethod); // save Method* 580 // Get mirror and store it in the frame as GC root for this Method* 581 __ load_mirror(Rtemp, Rmethod, Rtemp); 582 __ push(Rtemp); 583 584 if (ProfileInterpreter) { 585 __ ldr(Rtemp, Address(Rmethod, Method::method_data_offset())); 586 __ tst(Rtemp, Rtemp); 587 __ add(Rtemp, Rtemp, in_bytes(MethodData::data_offset()), ne); 588 __ push(Rtemp); // set the mdp (method data pointer) 589 } else { 590 __ push(R0); 591 } 592 593 __ ldr(Rtemp, Address(Rmethod, Method::const_offset())); 594 __ ldr(Rtemp, Address(Rtemp, ConstMethod::constants_offset())); 595 __ ldr(Rtemp, Address(Rtemp, ConstantPool::cache_offset_in_bytes())); 596 __ push(Rtemp); // set constant pool cache 597 __ push(Rlocals); // set locals pointer 598 __ push(Rbcp); // set bcp 599 __ push(R0); // reserve word for pointer to expression stack bottom 600 __ str(SP, Address(SP, 0)); // set expression stack bottom 601 } 602 603 604 // End of helpers 605 606 //------------------------------------------------------------------------------------------------------------------------ 607 // Entry points 608 // 609 // Here we generate the various kind of entries into the interpreter. 610 // The two main entry type are generic bytecode methods and native call method. 611 // These both come in synchronized and non-synchronized versions but the 612 // frame layout they create is very similar. The other method entry 613 // types are really just special purpose entries that are really entry 614 // and interpretation all in one. These are for trivial methods like 615 // accessor, empty, or special math methods. 616 // 617 // When control flow reaches any of the entry types for the interpreter 618 // the following holds -> 619 // 620 // Arguments: 621 // 622 // Rmethod: Method* 623 // Rthread: thread 624 // Rsender_sp: sender sp 625 // Rparams (SP on 32-bit ARM): pointer to method parameters 626 // 627 // LR: return address 628 // 629 // Stack layout immediately at entry 630 // 631 // [ parameter n ] <--- Rparams (SP on 32-bit ARM) 632 // ... 633 // [ parameter 1 ] 634 // [ expression stack ] (caller's java expression stack) 635 636 // Assuming that we don't go to one of the trivial specialized 637 // entries the stack will look like below when we are ready to execute 638 // the first bytecode (or call the native routine). The register usage 639 // will be as the template based interpreter expects. 640 // 641 // local variables follow incoming parameters immediately; i.e. 642 // the return address is saved at the end of the locals. 643 // 644 // [ expr. stack ] <--- Rstack_top (SP on 32-bit ARM) 645 // [ monitor entry ] 646 // ... 647 // [ monitor entry ] 648 // [ expr. stack bottom ] 649 // [ saved Rbcp ] 650 // [ current Rlocals ] 651 // [ cache ] 652 // [ mdx ] 653 // [ mirror ] 654 // [ Method* ] 655 // 656 // 32-bit ARM: 657 // [ last_sp ] 658 // 659 // [ sender_sp ] 660 // [ saved FP ] <--- FP 661 // [ saved LR ] 662 // [ optional padding(*)] 663 // [ local variable m ] 664 // ... 665 // [ local variable 1 ] 666 // [ parameter n ] 667 // ... 668 // [ parameter 1 ] <--- Rlocals 669 // 670 671 address TemplateInterpreterGenerator::generate_Reference_get_entry(void) { 672 // Code: _aload_0, _getfield, _areturn 673 // parameter size = 1 674 // 675 // The code that gets generated by this routine is split into 2 parts: 676 // 1. The "intrinsified" code performing an ON_WEAK_OOP_REF load, 677 // 2. The slow path - which is an expansion of the regular method entry. 678 // 679 // Notes:- 680 // * An intrinsic is always executed, where an ON_WEAK_OOP_REF load is performed. 681 // * We may jump to the slow path iff the receiver is null. If the 682 // Reference object is null then we no longer perform an ON_WEAK_OOP_REF load 683 // Thus we can use the regular method entry code to generate the NPE. 684 // 685 // Rmethod: Method* 686 // Rthread: thread 687 // Rsender_sp: sender sp, must be preserved for slow path, set SP to it on fast path 688 // Rparams: parameters 689 690 address entry = __ pc(); 691 Label slow_path; 692 const Register Rthis = R0; 693 const Register Rret_addr = Rtmp_save1; 694 assert_different_registers(Rthis, Rret_addr, Rsender_sp); 695 696 const int referent_offset = java_lang_ref_Reference::referent_offset; 697 guarantee(referent_offset > 0, "referent offset not initialized"); 698 699 // Check if local 0 != NULL 700 // If the receiver is null then it is OK to jump to the slow path. 701 __ ldr(Rthis, Address(Rparams)); 702 __ cbz(Rthis, slow_path); 703 704 // Preserve LR 705 __ mov(Rret_addr, LR); 706 707 // Load the value of the referent field. 708 const Address field_address(Rthis, referent_offset); 709 __ load_heap_oop(R0, field_address, Rtemp, R1_tmp, R2_tmp, ON_WEAK_OOP_REF); 710 711 // _areturn 712 __ mov(SP, Rsender_sp); 713 __ ret(Rret_addr); 714 715 // generate a vanilla interpreter entry as the slow path 716 __ bind(slow_path); 717 __ jump_to_entry(Interpreter::entry_for_kind(Interpreter::zerolocals)); 718 return entry; 719 } 720 721 // Not supported 722 address TemplateInterpreterGenerator::generate_CRC32_update_entry() { return NULL; } 723 address TemplateInterpreterGenerator::generate_CRC32_updateBytes_entry(AbstractInterpreter::MethodKind kind) { return NULL; } 724 address TemplateInterpreterGenerator::generate_CRC32C_updateBytes_entry(AbstractInterpreter::MethodKind kind) { return NULL; } 725 726 // 727 // Interpreter stub for calling a native method. (asm interpreter) 728 // This sets up a somewhat different looking stack for calling the native method 729 // than the typical interpreter frame setup. 730 // 731 732 address TemplateInterpreterGenerator::generate_native_entry(bool synchronized) { 733 // determine code generation flags 734 bool inc_counter = UseCompiler || CountCompiledCalls || LogTouchedMethods; 735 736 // Incoming registers: 737 // 738 // Rmethod: Method* 739 // Rthread: thread 740 // Rsender_sp: sender sp 741 // Rparams: parameters 742 743 address entry_point = __ pc(); 744 745 // Register allocation 746 const Register Rsize_of_params = R6; 747 const Register Rsig_handler = Rtmp_save0; 748 const Register Rnative_code = Rtmp_save1; 749 const Register Rresult_handler = R6; 750 751 const Register Rsaved_result_lo = Rtmp_save0; // R4 752 const Register Rsaved_result_hi = Rtmp_save1; // R5 753 FloatRegister saved_result_fp; 754 755 756 __ ldr(Rsize_of_params, Address(Rmethod, Method::const_offset())); 757 __ ldrh(Rsize_of_params, Address(Rsize_of_params, ConstMethod::size_of_parameters_offset())); 758 759 // native calls don't need the stack size check since they have no expression stack 760 // and the arguments are already on the stack and we only add a handful of words 761 // to the stack 762 763 // compute beginning of parameters (Rlocals) 764 __ sub(Rlocals, Rparams, wordSize); 765 __ add(Rlocals, Rlocals, AsmOperand(Rsize_of_params, lsl, Interpreter::logStackElementSize)); 766 767 // reserve stack space for oop_temp 768 __ mov(R0, 0); 769 __ push(R0); 770 771 generate_fixed_frame(true); // Note: R9 is now saved in the frame 772 773 // make sure method is native & not abstract 774 #ifdef ASSERT 775 __ ldr_u32(Rtemp, Address(Rmethod, Method::access_flags_offset())); 776 { 777 Label L; 778 __ tbnz(Rtemp, JVM_ACC_NATIVE_BIT, L); 779 __ stop("tried to execute non-native method as native"); 780 __ bind(L); 781 } 782 { Label L; 783 __ tbz(Rtemp, JVM_ACC_ABSTRACT_BIT, L); 784 __ stop("tried to execute abstract method in interpreter"); 785 __ bind(L); 786 } 787 #endif 788 789 // increment invocation count & check for overflow 790 Label invocation_counter_overflow; 791 if (inc_counter) { 792 if (synchronized) { 793 // Avoid unlocking method's monitor in case of exception, as it has not 794 // been locked yet. 795 __ set_do_not_unlock_if_synchronized(true, Rtemp); 796 } 797 generate_counter_incr(&invocation_counter_overflow, NULL, NULL); 798 } 799 800 Label continue_after_compile; 801 __ bind(continue_after_compile); 802 803 if (inc_counter && synchronized) { 804 __ set_do_not_unlock_if_synchronized(false, Rtemp); 805 } 806 807 // check for synchronized methods 808 // Must happen AFTER invocation_counter check and stack overflow check, 809 // so method is not locked if overflows. 810 // 811 if (synchronized) { 812 lock_method(); 813 } else { 814 // no synchronization necessary 815 #ifdef ASSERT 816 { Label L; 817 __ ldr_u32(Rtemp, Address(Rmethod, Method::access_flags_offset())); 818 __ tbz(Rtemp, JVM_ACC_SYNCHRONIZED_BIT, L); 819 __ stop("method needs synchronization"); 820 __ bind(L); 821 } 822 #endif 823 } 824 825 // start execution 826 #ifdef ASSERT 827 { Label L; 828 __ ldr(Rtemp, Address(FP, frame::interpreter_frame_monitor_block_top_offset * wordSize)); 829 __ cmp(Rtemp, Rstack_top); 830 __ b(L, eq); 831 __ stop("broken stack frame setup in interpreter"); 832 __ bind(L); 833 } 834 #endif 835 __ check_extended_sp(Rtemp); 836 837 // jvmti/dtrace support 838 __ notify_method_entry(); 839 #if R9_IS_SCRATCHED 840 __ restore_method(); 841 #endif 842 843 { 844 Label L; 845 __ ldr(Rsig_handler, Address(Rmethod, Method::signature_handler_offset())); 846 __ cbnz(Rsig_handler, L); 847 __ mov(R1, Rmethod); 848 __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::prepare_native_call), R1, true); 849 __ ldr(Rsig_handler, Address(Rmethod, Method::signature_handler_offset())); 850 __ bind(L); 851 } 852 853 { 854 Label L; 855 __ ldr(Rnative_code, Address(Rmethod, Method::native_function_offset())); 856 __ cbnz(Rnative_code, L); 857 __ mov(R1, Rmethod); 858 __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::prepare_native_call), R1); 859 __ ldr(Rnative_code, Address(Rmethod, Method::native_function_offset())); 860 __ bind(L); 861 } 862 863 // Allocate stack space for arguments 864 865 866 // C functions need aligned stack 867 __ bic(SP, SP, StackAlignmentInBytes - 1); 868 // Multiply by BytesPerLong instead of BytesPerWord, because calling convention 869 // may require empty slots due to long alignment, e.g. func(int, jlong, int, jlong) 870 __ sub(SP, SP, AsmOperand(Rsize_of_params, lsl, LogBytesPerLong)); 871 872 #ifdef __ABI_HARD__ 873 // Allocate more stack space to accomodate all GP as well as FP registers: 874 // 4 * wordSize 875 // 8 * BytesPerLong 876 int reg_arguments = align_up((4*wordSize) + (8*BytesPerLong), StackAlignmentInBytes); 877 #else 878 // Reserve at least 4 words on the stack for loading 879 // of parameters passed on registers (R0-R3). 880 // See generate_slow_signature_handler(). 881 // It is also used for JNIEnv & class additional parameters. 882 int reg_arguments = 4 * wordSize; 883 #endif // __ABI_HARD__ 884 885 __ sub(SP, SP, reg_arguments); 886 887 888 // Note: signature handler blows R4 besides all scratch registers. 889 // See AbstractInterpreterGenerator::generate_slow_signature_handler(). 890 __ call(Rsig_handler); 891 #if R9_IS_SCRATCHED 892 __ restore_method(); 893 #endif 894 __ mov(Rresult_handler, R0); 895 896 // Pass JNIEnv and mirror for static methods 897 { 898 Label L; 899 __ ldr_u32(Rtemp, Address(Rmethod, Method::access_flags_offset())); 900 __ add(R0, Rthread, in_bytes(JavaThread::jni_environment_offset())); 901 __ tbz(Rtemp, JVM_ACC_STATIC_BIT, L); 902 __ load_mirror(Rtemp, Rmethod, Rtemp); 903 __ add(R1, FP, frame::interpreter_frame_oop_temp_offset * wordSize); 904 __ str(Rtemp, Address(R1, 0)); 905 __ bind(L); 906 } 907 908 __ set_last_Java_frame(SP, FP, true, Rtemp); 909 910 // Changing state to _thread_in_native must be the last thing to do 911 // before the jump to native code. At this moment stack must be 912 // safepoint-safe and completely prepared for stack walking. 913 #ifdef ASSERT 914 { 915 Label L; 916 __ ldr_u32(Rtemp, Address(Rthread, JavaThread::thread_state_offset())); 917 __ cmp_32(Rtemp, _thread_in_Java); 918 __ b(L, eq); 919 __ stop("invalid thread state"); 920 __ bind(L); 921 } 922 #endif 923 924 // Force all preceding writes to be observed prior to thread state change 925 __ membar(MacroAssembler::StoreStore, Rtemp); 926 927 __ mov(Rtemp, _thread_in_native); 928 __ str(Rtemp, Address(Rthread, JavaThread::thread_state_offset())); 929 930 __ call(Rnative_code); 931 #if R9_IS_SCRATCHED 932 __ restore_method(); 933 #endif 934 935 // Set FPSCR/FPCR to a known state 936 if (AlwaysRestoreFPU) { 937 __ restore_default_fp_mode(); 938 } 939 940 // Do safepoint check 941 __ mov(Rtemp, _thread_in_native_trans); 942 __ str_32(Rtemp, Address(Rthread, JavaThread::thread_state_offset())); 943 944 // Force this write out before the read below 945 __ membar(MacroAssembler::StoreLoad, Rtemp); 946 947 __ ldr_global_s32(Rtemp, SafepointSynchronize::address_of_state()); 948 949 // Protect the return value in the interleaved code: save it to callee-save registers. 950 __ mov(Rsaved_result_lo, R0); 951 __ mov(Rsaved_result_hi, R1); 952 #ifdef __ABI_HARD__ 953 // preserve native FP result in a callee-saved register 954 saved_result_fp = D8; 955 __ fcpyd(saved_result_fp, D0); 956 #else 957 saved_result_fp = fnoreg; 958 #endif // __ABI_HARD__ 959 960 { 961 __ ldr_u32(R3, Address(Rthread, JavaThread::suspend_flags_offset())); 962 __ cmp(Rtemp, SafepointSynchronize::_not_synchronized); 963 __ cond_cmp(R3, 0, eq); 964 965 __ mov(R0, Rthread, ne); 966 __ call(CAST_FROM_FN_PTR(address, JavaThread::check_special_condition_for_native_trans), relocInfo::none, ne); 967 #if R9_IS_SCRATCHED 968 __ restore_method(); 969 #endif 970 } 971 972 // Perform Native->Java thread transition 973 __ mov(Rtemp, _thread_in_Java); 974 __ str_32(Rtemp, Address(Rthread, JavaThread::thread_state_offset())); 975 976 // Zero handles and last_java_sp 977 __ reset_last_Java_frame(Rtemp); 978 __ ldr(R3, Address(Rthread, JavaThread::active_handles_offset())); 979 __ str_32(__ zero_register(Rtemp), Address(R3, JNIHandleBlock::top_offset_in_bytes())); 980 if (CheckJNICalls) { 981 __ str(__ zero_register(Rtemp), Address(Rthread, JavaThread::pending_jni_exception_check_fn_offset())); 982 } 983 984 // Unbox oop result, e.g. JNIHandles::resolve result if it's an oop. 985 { 986 Label Lnot_oop; 987 // For ARM32, Rresult_handler is -1 for oop result, 0 otherwise. 988 __ cbz(Rresult_handler, Lnot_oop); 989 Register value = Rsaved_result_lo; 990 __ resolve_jobject(value, // value 991 Rtemp, // tmp1 992 R1_tmp); // tmp2 993 // Store resolved result in frame for GC visibility. 994 __ str(value, Address(FP, frame::interpreter_frame_oop_temp_offset * wordSize)); 995 __ bind(Lnot_oop); 996 } 997 998 999 // reguard stack if StackOverflow exception happened while in native. 1000 { 1001 __ ldr_u32(Rtemp, Address(Rthread, JavaThread::stack_guard_state_offset())); 1002 __ cmp_32(Rtemp, JavaThread::stack_guard_yellow_reserved_disabled); 1003 __ call(CAST_FROM_FN_PTR(address, SharedRuntime::reguard_yellow_pages), relocInfo::none, eq); 1004 #if R9_IS_SCRATCHED 1005 __ restore_method(); 1006 #endif 1007 } 1008 1009 // check pending exceptions 1010 { 1011 __ ldr(Rtemp, Address(Rthread, Thread::pending_exception_offset())); 1012 __ cmp(Rtemp, 0); 1013 __ mov(Rexception_pc, PC, ne); 1014 __ b(StubRoutines::forward_exception_entry(), ne); 1015 } 1016 1017 if (synchronized) { 1018 // address of first monitor 1019 __ sub(R1, FP, - (frame::interpreter_frame_monitor_block_bottom_offset - frame::interpreter_frame_monitor_size()) * wordSize); 1020 __ unlock_object(R1); 1021 } 1022 1023 // jvmti/dtrace support 1024 // Note: This must happen _after_ handling/throwing any exceptions since 1025 // the exception handler code notifies the runtime of method exits 1026 // too. If this happens before, method entry/exit notifications are 1027 // not properly paired (was bug - gri 11/22/99). 1028 __ notify_method_exit(vtos, InterpreterMacroAssembler::NotifyJVMTI, true, Rsaved_result_lo, Rsaved_result_hi, saved_result_fp); 1029 1030 // Restore the result. Oop result is restored from the stack. 1031 __ cmp(Rresult_handler, 0); 1032 __ ldr(R0, Address(FP, frame::interpreter_frame_oop_temp_offset * wordSize), ne); 1033 __ mov(R0, Rsaved_result_lo, eq); 1034 __ mov(R1, Rsaved_result_hi); 1035 1036 #ifdef __ABI_HARD__ 1037 // reload native FP result 1038 __ fcpyd(D0, D8); 1039 #endif // __ABI_HARD__ 1040 1041 #ifdef ASSERT 1042 if (VerifyOops) { 1043 Label L; 1044 __ cmp(Rresult_handler, 0); 1045 __ b(L, eq); 1046 __ verify_oop(R0); 1047 __ bind(L); 1048 } 1049 #endif // ASSERT 1050 1051 // Restore FP/LR, sender_sp and return 1052 __ mov(Rtemp, FP); 1053 __ ldmia(FP, RegisterSet(FP) | RegisterSet(LR)); 1054 __ ldr(SP, Address(Rtemp, frame::interpreter_frame_sender_sp_offset * wordSize)); 1055 1056 __ ret(); 1057 1058 if (inc_counter) { 1059 // Handle overflow of counter and compile method 1060 __ bind(invocation_counter_overflow); 1061 generate_counter_overflow(continue_after_compile); 1062 } 1063 1064 return entry_point; 1065 } 1066 1067 // 1068 // Generic interpreted method entry to (asm) interpreter 1069 // 1070 address TemplateInterpreterGenerator::generate_normal_entry(bool synchronized) { 1071 // determine code generation flags 1072 bool inc_counter = UseCompiler || CountCompiledCalls || LogTouchedMethods; 1073 1074 // Rmethod: Method* 1075 // Rthread: thread 1076 // Rsender_sp: sender sp (could differ from SP if we were called via c2i) 1077 // Rparams: pointer to the last parameter in the stack 1078 1079 address entry_point = __ pc(); 1080 1081 const Register RconstMethod = R3; 1082 1083 1084 __ ldr(RconstMethod, Address(Rmethod, Method::const_offset())); 1085 1086 __ ldrh(R2, Address(RconstMethod, ConstMethod::size_of_parameters_offset())); 1087 __ ldrh(R3, Address(RconstMethod, ConstMethod::size_of_locals_offset())); 1088 1089 // setup Rlocals 1090 __ sub(Rlocals, Rparams, wordSize); 1091 __ add(Rlocals, Rlocals, AsmOperand(R2, lsl, Interpreter::logStackElementSize)); 1092 1093 __ sub(R3, R3, R2); // number of additional locals 1094 1095 1096 // see if we've got enough room on the stack for locals plus overhead. 1097 generate_stack_overflow_check(); 1098 1099 // allocate space for locals 1100 // explicitly initialize locals 1101 1102 // Loop is unrolled 4 times 1103 Label loop; 1104 __ mov(R0, 0); 1105 __ bind(loop); 1106 1107 // #1 1108 __ subs(R3, R3, 1); 1109 __ push(R0, ge); 1110 1111 // #2 1112 __ subs(R3, R3, 1, ge); 1113 __ push(R0, ge); 1114 1115 // #3 1116 __ subs(R3, R3, 1, ge); 1117 __ push(R0, ge); 1118 1119 // #4 1120 __ subs(R3, R3, 1, ge); 1121 __ push(R0, ge); 1122 1123 __ b(loop, gt); 1124 1125 // initialize fixed part of activation frame 1126 generate_fixed_frame(false); 1127 1128 __ restore_dispatch(); 1129 1130 // make sure method is not native & not abstract 1131 #ifdef ASSERT 1132 __ ldr_u32(Rtemp, Address(Rmethod, Method::access_flags_offset())); 1133 { 1134 Label L; 1135 __ tbz(Rtemp, JVM_ACC_NATIVE_BIT, L); 1136 __ stop("tried to execute native method as non-native"); 1137 __ bind(L); 1138 } 1139 { Label L; 1140 __ tbz(Rtemp, JVM_ACC_ABSTRACT_BIT, L); 1141 __ stop("tried to execute abstract method in interpreter"); 1142 __ bind(L); 1143 } 1144 #endif 1145 1146 // increment invocation count & check for overflow 1147 Label invocation_counter_overflow; 1148 Label profile_method; 1149 Label profile_method_continue; 1150 if (inc_counter) { 1151 if (synchronized) { 1152 // Avoid unlocking method's monitor in case of exception, as it has not 1153 // been locked yet. 1154 __ set_do_not_unlock_if_synchronized(true, Rtemp); 1155 } 1156 generate_counter_incr(&invocation_counter_overflow, &profile_method, &profile_method_continue); 1157 if (ProfileInterpreter) { 1158 __ bind(profile_method_continue); 1159 } 1160 } 1161 Label continue_after_compile; 1162 __ bind(continue_after_compile); 1163 1164 if (inc_counter && synchronized) { 1165 __ set_do_not_unlock_if_synchronized(false, Rtemp); 1166 } 1167 #if R9_IS_SCRATCHED 1168 __ restore_method(); 1169 #endif 1170 1171 // check for synchronized methods 1172 // Must happen AFTER invocation_counter check and stack overflow check, 1173 // so method is not locked if overflows. 1174 // 1175 if (synchronized) { 1176 // Allocate monitor and lock method 1177 lock_method(); 1178 } else { 1179 // no synchronization necessary 1180 #ifdef ASSERT 1181 { Label L; 1182 __ ldr_u32(Rtemp, Address(Rmethod, Method::access_flags_offset())); 1183 __ tbz(Rtemp, JVM_ACC_SYNCHRONIZED_BIT, L); 1184 __ stop("method needs synchronization"); 1185 __ bind(L); 1186 } 1187 #endif 1188 } 1189 1190 // start execution 1191 #ifdef ASSERT 1192 { Label L; 1193 __ ldr(Rtemp, Address(FP, frame::interpreter_frame_monitor_block_top_offset * wordSize)); 1194 __ cmp(Rtemp, Rstack_top); 1195 __ b(L, eq); 1196 __ stop("broken stack frame setup in interpreter"); 1197 __ bind(L); 1198 } 1199 #endif 1200 __ check_extended_sp(Rtemp); 1201 1202 // jvmti support 1203 __ notify_method_entry(); 1204 #if R9_IS_SCRATCHED 1205 __ restore_method(); 1206 #endif 1207 1208 __ dispatch_next(vtos); 1209 1210 // invocation counter overflow 1211 if (inc_counter) { 1212 if (ProfileInterpreter) { 1213 // We have decided to profile this method in the interpreter 1214 __ bind(profile_method); 1215 1216 __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::profile_method)); 1217 __ set_method_data_pointer_for_bcp(); 1218 1219 __ b(profile_method_continue); 1220 } 1221 1222 // Handle overflow of counter and compile method 1223 __ bind(invocation_counter_overflow); 1224 generate_counter_overflow(continue_after_compile); 1225 } 1226 1227 return entry_point; 1228 } 1229 1230 //------------------------------------------------------------------------------------------------------------------------ 1231 // Exceptions 1232 1233 void TemplateInterpreterGenerator::generate_throw_exception() { 1234 // Entry point in previous activation (i.e., if the caller was interpreted) 1235 Interpreter::_rethrow_exception_entry = __ pc(); 1236 // Rexception_obj: exception 1237 1238 // Clear interpreter_frame_last_sp. 1239 __ mov(Rtemp, 0); 1240 __ str(Rtemp, Address(FP, frame::interpreter_frame_last_sp_offset * wordSize)); 1241 1242 #if R9_IS_SCRATCHED 1243 __ restore_method(); 1244 #endif 1245 __ restore_bcp(); 1246 __ restore_dispatch(); 1247 __ restore_locals(); 1248 1249 1250 // Entry point for exceptions thrown within interpreter code 1251 Interpreter::_throw_exception_entry = __ pc(); 1252 1253 // expression stack is undefined here 1254 // Rexception_obj: exception 1255 // Rbcp: exception bcp 1256 __ verify_oop(Rexception_obj); 1257 1258 // expression stack must be empty before entering the VM in case of an exception 1259 __ empty_expression_stack(); 1260 // find exception handler address and preserve exception oop 1261 __ mov(R1, Rexception_obj); 1262 __ call_VM(Rexception_obj, CAST_FROM_FN_PTR(address, InterpreterRuntime::exception_handler_for_exception), R1); 1263 // R0: exception handler entry point 1264 // Rexception_obj: preserved exception oop 1265 // Rbcp: bcp for exception handler 1266 __ push_ptr(Rexception_obj); // push exception which is now the only value on the stack 1267 __ jump(R0); // jump to exception handler (may be _remove_activation_entry!) 1268 1269 // If the exception is not handled in the current frame the frame is removed and 1270 // the exception is rethrown (i.e. exception continuation is _rethrow_exception). 1271 // 1272 // Note: At this point the bci is still the bxi for the instruction which caused 1273 // the exception and the expression stack is empty. Thus, for any VM calls 1274 // at this point, GC will find a legal oop map (with empty expression stack). 1275 1276 // In current activation 1277 // tos: exception 1278 // Rbcp: exception bcp 1279 1280 // 1281 // JVMTI PopFrame support 1282 // 1283 Interpreter::_remove_activation_preserving_args_entry = __ pc(); 1284 1285 1286 __ empty_expression_stack(); 1287 1288 // Set the popframe_processing bit in _popframe_condition indicating that we are 1289 // currently handling popframe, so that call_VMs that may happen later do not trigger new 1290 // popframe handling cycles. 1291 1292 __ ldr_s32(Rtemp, Address(Rthread, JavaThread::popframe_condition_offset())); 1293 __ orr(Rtemp, Rtemp, (unsigned)JavaThread::popframe_processing_bit); 1294 __ str_32(Rtemp, Address(Rthread, JavaThread::popframe_condition_offset())); 1295 1296 { 1297 // Check to see whether we are returning to a deoptimized frame. 1298 // (The PopFrame call ensures that the caller of the popped frame is 1299 // either interpreted or compiled and deoptimizes it if compiled.) 1300 // In this case, we can't call dispatch_next() after the frame is 1301 // popped, but instead must save the incoming arguments and restore 1302 // them after deoptimization has occurred. 1303 // 1304 // Note that we don't compare the return PC against the 1305 // deoptimization blob's unpack entry because of the presence of 1306 // adapter frames in C2. 1307 Label caller_not_deoptimized; 1308 __ ldr(R0, Address(FP, frame::return_addr_offset * wordSize)); 1309 __ call_VM_leaf(CAST_FROM_FN_PTR(address, InterpreterRuntime::interpreter_contains), R0); 1310 __ cbnz_32(R0, caller_not_deoptimized); 1311 1312 // Compute size of arguments for saving when returning to deoptimized caller 1313 __ restore_method(); 1314 __ ldr(R0, Address(Rmethod, Method::const_offset())); 1315 __ ldrh(R0, Address(R0, ConstMethod::size_of_parameters_offset())); 1316 1317 __ logical_shift_left(R1, R0, Interpreter::logStackElementSize); 1318 // Save these arguments 1319 __ restore_locals(); 1320 __ sub(R2, Rlocals, R1); 1321 __ add(R2, R2, wordSize); 1322 __ mov(R0, Rthread); 1323 __ call_VM_leaf(CAST_FROM_FN_PTR(address, Deoptimization::popframe_preserve_args), R0, R1, R2); 1324 1325 __ remove_activation(vtos, LR, 1326 /* throw_monitor_exception */ false, 1327 /* install_monitor_exception */ false, 1328 /* notify_jvmdi */ false); 1329 1330 // Inform deoptimization that it is responsible for restoring these arguments 1331 __ mov(Rtemp, JavaThread::popframe_force_deopt_reexecution_bit); 1332 __ str_32(Rtemp, Address(Rthread, JavaThread::popframe_condition_offset())); 1333 1334 // Continue in deoptimization handler 1335 __ ret(); 1336 1337 __ bind(caller_not_deoptimized); 1338 } 1339 1340 __ remove_activation(vtos, R4, 1341 /* throw_monitor_exception */ false, 1342 /* install_monitor_exception */ false, 1343 /* notify_jvmdi */ false); 1344 1345 // Finish with popframe handling 1346 // A previous I2C followed by a deoptimization might have moved the 1347 // outgoing arguments further up the stack. PopFrame expects the 1348 // mutations to those outgoing arguments to be preserved and other 1349 // constraints basically require this frame to look exactly as 1350 // though it had previously invoked an interpreted activation with 1351 // no space between the top of the expression stack (current 1352 // last_sp) and the top of stack. Rather than force deopt to 1353 // maintain this kind of invariant all the time we call a small 1354 // fixup routine to move the mutated arguments onto the top of our 1355 // expression stack if necessary. 1356 __ mov(R1, SP); 1357 __ ldr(R2, Address(FP, frame::interpreter_frame_last_sp_offset * wordSize)); 1358 // PC must point into interpreter here 1359 __ set_last_Java_frame(SP, FP, true, Rtemp); 1360 __ mov(R0, Rthread); 1361 __ call_VM_leaf(CAST_FROM_FN_PTR(address, InterpreterRuntime::popframe_move_outgoing_args), R0, R1, R2); 1362 __ reset_last_Java_frame(Rtemp); 1363 1364 // Restore the last_sp and null it out 1365 __ ldr(SP, Address(FP, frame::interpreter_frame_last_sp_offset * wordSize)); 1366 __ mov(Rtemp, (int)NULL_WORD); 1367 __ str(Rtemp, Address(FP, frame::interpreter_frame_last_sp_offset * wordSize)); 1368 1369 __ restore_bcp(); 1370 __ restore_dispatch(); 1371 __ restore_locals(); 1372 __ restore_method(); 1373 1374 // The method data pointer was incremented already during 1375 // call profiling. We have to restore the mdp for the current bcp. 1376 if (ProfileInterpreter) { 1377 __ set_method_data_pointer_for_bcp(); 1378 } 1379 1380 // Clear the popframe condition flag 1381 assert(JavaThread::popframe_inactive == 0, "adjust this code"); 1382 __ str_32(__ zero_register(Rtemp), Address(Rthread, JavaThread::popframe_condition_offset())); 1383 1384 #if INCLUDE_JVMTI 1385 { 1386 Label L_done; 1387 1388 __ ldrb(Rtemp, Address(Rbcp, 0)); 1389 __ cmp(Rtemp, Bytecodes::_invokestatic); 1390 __ b(L_done, ne); 1391 1392 // The member name argument must be restored if _invokestatic is re-executed after a PopFrame call. 1393 // Detect such a case in the InterpreterRuntime function and return the member name argument, or NULL. 1394 1395 // get local0 1396 __ ldr(R1, Address(Rlocals, 0)); 1397 __ mov(R2, Rmethod); 1398 __ mov(R3, Rbcp); 1399 __ call_VM(R0, CAST_FROM_FN_PTR(address, InterpreterRuntime::member_name_arg_or_null), R1, R2, R3); 1400 1401 __ cbz(R0, L_done); 1402 1403 __ str(R0, Address(Rstack_top)); 1404 __ bind(L_done); 1405 } 1406 #endif // INCLUDE_JVMTI 1407 1408 __ dispatch_next(vtos); 1409 // end of PopFrame support 1410 1411 Interpreter::_remove_activation_entry = __ pc(); 1412 1413 // preserve exception over this code sequence 1414 __ pop_ptr(R0_tos); 1415 __ str(R0_tos, Address(Rthread, JavaThread::vm_result_offset())); 1416 // remove the activation (without doing throws on illegalMonitorExceptions) 1417 __ remove_activation(vtos, Rexception_pc, false, true, false); 1418 // restore exception 1419 __ get_vm_result(Rexception_obj, Rtemp); 1420 1421 // Inbetween activations - previous activation type unknown yet 1422 // compute continuation point - the continuation point expects 1423 // the following registers set up: 1424 // 1425 // Rexception_obj: exception 1426 // Rexception_pc: return address/pc that threw exception 1427 // SP: expression stack of caller 1428 // FP: frame pointer of caller 1429 __ mov(c_rarg0, Rthread); 1430 __ mov(c_rarg1, Rexception_pc); 1431 __ call_VM_leaf(CAST_FROM_FN_PTR(address, SharedRuntime::exception_handler_for_return_address), c_rarg0, c_rarg1); 1432 // Note that an "issuing PC" is actually the next PC after the call 1433 1434 __ jump(R0); // jump to exception handler of caller 1435 } 1436 1437 1438 // 1439 // JVMTI ForceEarlyReturn support 1440 // 1441 address TemplateInterpreterGenerator::generate_earlyret_entry_for(TosState state) { 1442 address entry = __ pc(); 1443 1444 1445 __ restore_bcp(); 1446 __ restore_dispatch(); 1447 __ restore_locals(); 1448 1449 __ empty_expression_stack(); 1450 1451 __ load_earlyret_value(state); 1452 1453 // Clear the earlyret state 1454 __ ldr(Rtemp, Address(Rthread, JavaThread::jvmti_thread_state_offset())); 1455 1456 assert(JvmtiThreadState::earlyret_inactive == 0, "adjust this code"); 1457 __ str_32(__ zero_register(R2), Address(Rtemp, JvmtiThreadState::earlyret_state_offset())); 1458 1459 __ remove_activation(state, LR, 1460 false, /* throw_monitor_exception */ 1461 false, /* install_monitor_exception */ 1462 true); /* notify_jvmdi */ 1463 1464 // According to interpreter calling conventions, result is returned in R0/R1, 1465 // so ftos (S0) and dtos (D0) are moved to R0/R1. 1466 // This conversion should be done after remove_activation, as it uses 1467 // push(state) & pop(state) to preserve return value. 1468 __ convert_tos_to_retval(state); 1469 __ ret(); 1470 1471 return entry; 1472 } // end of ForceEarlyReturn support 1473 1474 1475 //------------------------------------------------------------------------------------------------------------------------ 1476 // Helper for vtos entry point generation 1477 1478 void TemplateInterpreterGenerator::set_vtos_entry_points (Template* t, address& bep, address& cep, address& sep, address& aep, address& iep, address& lep, address& fep, address& dep, address& vep) { 1479 assert(t->is_valid() && t->tos_in() == vtos, "illegal template"); 1480 Label L; 1481 1482 #ifdef __SOFTFP__ 1483 dep = __ pc(); // fall through 1484 #else 1485 fep = __ pc(); __ push(ftos); __ b(L); 1486 dep = __ pc(); __ push(dtos); __ b(L); 1487 #endif // __SOFTFP__ 1488 1489 lep = __ pc(); __ push(ltos); __ b(L); 1490 1491 if (VerifyOops) { // can't share atos entry if VerifyOops 1492 aep = __ pc(); __ push(atos); __ b(L); 1493 } else { 1494 aep = __ pc(); // fall through 1495 } 1496 1497 #ifdef __SOFTFP__ 1498 fep = __ pc(); // fall through 1499 #endif // __SOFTFP__ 1500 1501 bep = cep = sep = // fall through 1502 iep = __ pc(); __ push(itos); // fall through 1503 vep = __ pc(); __ bind(L); // fall through 1504 generate_and_dispatch(t); 1505 } 1506 1507 //------------------------------------------------------------------------------------------------------------------------ 1508 1509 // Non-product code 1510 #ifndef PRODUCT 1511 address TemplateInterpreterGenerator::generate_trace_code(TosState state) { 1512 address entry = __ pc(); 1513 1514 // prepare expression stack 1515 __ push(state); // save tosca 1516 1517 // pass tosca registers as arguments 1518 __ mov(R2, R0_tos); 1519 __ mov(R3, R1_tos_hi); 1520 __ mov(R1, LR); // save return address 1521 1522 // call tracer 1523 __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::trace_bytecode), R1, R2, R3); 1524 1525 __ mov(LR, R0); // restore return address 1526 __ pop(state); // restore tosca 1527 1528 // return 1529 __ ret(); 1530 1531 return entry; 1532 } 1533 1534 1535 void TemplateInterpreterGenerator::count_bytecode() { 1536 __ inc_global_counter((address) &BytecodeCounter::_counter_value, 0, Rtemp, R2_tmp, true); 1537 } 1538 1539 1540 void TemplateInterpreterGenerator::histogram_bytecode(Template* t) { 1541 __ inc_global_counter((address)&BytecodeHistogram::_counters[0], sizeof(BytecodeHistogram::_counters[0]) * t->bytecode(), Rtemp, R2_tmp, true); 1542 } 1543 1544 1545 void TemplateInterpreterGenerator::histogram_bytecode_pair(Template* t) { 1546 const Register Rindex_addr = R2_tmp; 1547 Label Lcontinue; 1548 InlinedAddress Lcounters((address)BytecodePairHistogram::_counters); 1549 InlinedAddress Lindex((address)&BytecodePairHistogram::_index); 1550 const Register Rcounters_addr = R2_tmp; 1551 const Register Rindex = R4_tmp; 1552 1553 // calculate new index for counter: 1554 // index = (_index >> log2_number_of_codes) | (bytecode << log2_number_of_codes). 1555 // (_index >> log2_number_of_codes) is previous bytecode 1556 1557 __ ldr_literal(Rindex_addr, Lindex); 1558 __ ldr_s32(Rindex, Address(Rindex_addr)); 1559 __ mov_slow(Rtemp, ((int)t->bytecode()) << BytecodePairHistogram::log2_number_of_codes); 1560 __ orr(Rindex, Rtemp, AsmOperand(Rindex, lsr, BytecodePairHistogram::log2_number_of_codes)); 1561 __ str_32(Rindex, Address(Rindex_addr)); 1562 1563 // Rindex (R4) contains index of counter 1564 1565 __ ldr_literal(Rcounters_addr, Lcounters); 1566 __ ldr_s32(Rtemp, Address::indexed_32(Rcounters_addr, Rindex)); 1567 __ adds_32(Rtemp, Rtemp, 1); 1568 __ b(Lcontinue, mi); // avoid overflow 1569 __ str_32(Rtemp, Address::indexed_32(Rcounters_addr, Rindex)); 1570 1571 __ b(Lcontinue); 1572 1573 __ bind_literal(Lindex); 1574 __ bind_literal(Lcounters); 1575 1576 __ bind(Lcontinue); 1577 } 1578 1579 1580 void TemplateInterpreterGenerator::trace_bytecode(Template* t) { 1581 // Call a little run-time stub to avoid blow-up for each bytecode. 1582 // The run-time runtime saves the right registers, depending on 1583 // the tosca in-state for the given template. 1584 assert(Interpreter::trace_code(t->tos_in()) != NULL, 1585 "entry must have been generated"); 1586 address trace_entry = Interpreter::trace_code(t->tos_in()); 1587 __ call(trace_entry, relocInfo::none); 1588 } 1589 1590 1591 void TemplateInterpreterGenerator::stop_interpreter_at() { 1592 Label Lcontinue; 1593 const Register stop_at = R2_tmp; 1594 1595 __ ldr_global_s32(Rtemp, (address) &BytecodeCounter::_counter_value); 1596 __ mov_slow(stop_at, StopInterpreterAt); 1597 1598 // test bytecode counter 1599 __ cmp(Rtemp, stop_at); 1600 __ b(Lcontinue, ne); 1601 1602 __ trace_state("stop_interpreter_at"); 1603 __ breakpoint(); 1604 1605 __ bind(Lcontinue); 1606 } 1607 #endif // !PRODUCT