1 /* 2 * Copyright (c) 2003, 2023, Oracle and/or its affiliates. All rights reserved. 3 * Copyright 2007, 2008, 2009, 2010, 2011 Red Hat, Inc. 4 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 5 * 6 * This code is free software; you can redistribute it and/or modify it 7 * under the terms of the GNU General Public License version 2 only, as 8 * published by the Free Software Foundation. 9 * 10 * This code is distributed in the hope that it will be useful, but WITHOUT 11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 13 * version 2 for more details (a copy is included in the LICENSE file that 14 * accompanied this code). 15 * 16 * You should have received a copy of the GNU General Public License version 17 * 2 along with this work; if not, write to the Free Software Foundation, 18 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 19 * 20 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 21 * or visit www.oracle.com if you need additional information or have any 22 * questions. 23 * 24 */ 25 26 #include "precompiled.hpp" 27 #include "asm/assembler.hpp" 28 #include "interpreter/interpreter.hpp" 29 #include "interpreter/interpreterRuntime.hpp" 30 #include "interpreter/zero/bytecodeInterpreter.hpp" 31 #include "interpreter/zero/zeroInterpreter.hpp" 32 #include "interpreter/zero/zeroInterpreterGenerator.hpp" 33 #include "oops/access.inline.hpp" 34 #include "oops/cpCache.inline.hpp" 35 #include "oops/klass.inline.hpp" 36 #include "oops/methodData.hpp" 37 #include "oops/method.hpp" 38 #include "oops/oop.inline.hpp" 39 #include "prims/jvmtiExport.hpp" 40 #include "runtime/basicLock.inline.hpp" 41 #include "runtime/frame.inline.hpp" 42 #include "runtime/handles.inline.hpp" 43 #include "runtime/interfaceSupport.inline.hpp" 44 #include "runtime/jniHandles.inline.hpp" 45 #include "runtime/timer.hpp" 46 #include "runtime/timerTrace.hpp" 47 #include "utilities/debug.hpp" 48 #include "utilities/globalDefinitions.hpp" 49 #include "utilities/macros.hpp" 50 51 #include "entry_zero.hpp" 52 #include "stack_zero.inline.hpp" 53 54 void ZeroInterpreter::initialize_stub() { 55 if (_code != nullptr) return; 56 57 // generate interpreter 58 int code_size = InterpreterCodeSize; 59 NOT_PRODUCT(code_size *= 4;) // debug uses extra interpreter code space 60 _code = new StubQueue(new InterpreterCodeletInterface, code_size, nullptr, 61 "Interpreter"); 62 } 63 64 void ZeroInterpreter::initialize_code() { 65 AbstractInterpreter::initialize(); 66 67 // generate interpreter 68 { ResourceMark rm; 69 TraceTime timer("Interpreter generation", TRACETIME_LOG(Info, startuptime)); 70 ZeroInterpreterGenerator g; 71 if (PrintInterpreter) print(); 72 } 73 } 74 75 void ZeroInterpreter::invoke_method(Method* method, address entry_point, TRAPS) { 76 ((ZeroEntry *) entry_point)->invoke(method, THREAD); 77 } 78 79 void ZeroInterpreter::invoke_osr(Method* method, 80 address entry_point, 81 address osr_buf, 82 TRAPS) { 83 ((ZeroEntry *) entry_point)->invoke_osr(method, osr_buf, THREAD); 84 } 85 86 87 88 InterpreterCodelet* ZeroInterpreter::codelet_containing(address pc) { 89 // FIXME: I'm pretty sure _code is null and this is never called, which is why it's copied. 90 return (InterpreterCodelet*)_code->stub_containing(pc); 91 } 92 #define fixup_after_potential_safepoint() \ 93 method = istate->method() 94 95 #define CALL_VM_NOCHECK_NOFIX(func) \ 96 thread->set_last_Java_frame(); \ 97 func; \ 98 thread->reset_last_Java_frame(); 99 100 #define CALL_VM_NOCHECK(func) \ 101 CALL_VM_NOCHECK_NOFIX(func) \ 102 fixup_after_potential_safepoint() 103 104 int ZeroInterpreter::normal_entry(Method* method, intptr_t UNUSED, TRAPS) { 105 JavaThread *thread = THREAD; 106 107 // Allocate and initialize our frame. 108 InterpreterFrame *frame = InterpreterFrame::build(method, CHECK_0); 109 thread->push_zero_frame(frame); 110 111 // Execute those bytecodes! 112 main_loop(0, THREAD); 113 114 // No deoptimized frames on the stack 115 return 0; 116 } 117 118 int ZeroInterpreter::Reference_get_entry(Method* method, intptr_t UNUSED, TRAPS) { 119 JavaThread* thread = THREAD; 120 ZeroStack* stack = thread->zero_stack(); 121 intptr_t* topOfStack = stack->sp(); 122 123 oop ref = STACK_OBJECT(0); 124 125 // Shortcut if reference is known null 126 if (ref == nullptr) { 127 return normal_entry(method, 0, THREAD); 128 } 129 130 // Read the referent with weaker semantics, and let GCs handle the rest. 131 const int referent_offset = java_lang_ref_Reference::referent_offset(); 132 oop obj = HeapAccess<IN_HEAP | ON_WEAK_OOP_REF>::oop_load_at(ref, referent_offset); 133 134 SET_STACK_OBJECT(obj, 0); 135 136 // No deoptimized frames on the stack 137 return 0; 138 } 139 140 intptr_t narrow(BasicType type, intptr_t result) { 141 // mask integer result to narrower return type. 142 switch (type) { 143 case T_BOOLEAN: 144 return result&1; 145 case T_BYTE: 146 return (intptr_t)(jbyte)result; 147 case T_CHAR: 148 return (intptr_t)(uintptr_t)(jchar)result; 149 case T_SHORT: 150 return (intptr_t)(jshort)result; 151 case T_OBJECT: // nothing to do fall through 152 case T_ARRAY: 153 case T_LONG: 154 case T_INT: 155 case T_FLOAT: 156 case T_DOUBLE: 157 case T_VOID: 158 return result; 159 default: 160 ShouldNotReachHere(); 161 return result; // silence compiler warnings 162 } 163 } 164 165 166 void ZeroInterpreter::main_loop(int recurse, TRAPS) { 167 JavaThread *thread = THREAD; 168 ZeroStack *stack = thread->zero_stack(); 169 170 // If we are entering from a deopt we may need to call 171 // ourself a few times in order to get to our frame. 172 if (recurse) 173 main_loop(recurse - 1, THREAD); 174 175 InterpreterFrame *frame = thread->top_zero_frame()->as_interpreter_frame(); 176 interpreterState istate = frame->interpreter_state(); 177 Method* method = istate->method(); 178 179 intptr_t *result = nullptr; 180 int result_slots = 0; 181 182 while (true) { 183 // We can set up the frame anchor with everything we want at 184 // this point as we are thread_in_Java and no safepoints can 185 // occur until we go to vm mode. We do have to clear flags 186 // on return from vm but that is it. 187 thread->set_last_Java_frame(); 188 189 // Call the interpreter 190 if (JvmtiExport::can_post_interpreter_events()) { 191 if (RewriteBytecodes) { 192 BytecodeInterpreter::run<true, true>(istate); 193 } else { 194 BytecodeInterpreter::run<true, false>(istate); 195 } 196 } else { 197 if (RewriteBytecodes) { 198 BytecodeInterpreter::run<false, true>(istate); 199 } else { 200 BytecodeInterpreter::run<false, false>(istate); 201 } 202 } 203 fixup_after_potential_safepoint(); 204 205 // If we are unwinding, notify the stack watermarks machinery. 206 // Should do this before resetting the frame anchor. 207 if (istate->msg() == BytecodeInterpreter::return_from_method || 208 istate->msg() == BytecodeInterpreter::do_osr) { 209 stack_watermark_unwind_check(thread); 210 } else { 211 assert(istate->msg() == BytecodeInterpreter::call_method || 212 istate->msg() == BytecodeInterpreter::more_monitors || 213 istate->msg() == BytecodeInterpreter::throwing_exception, 214 "Should be one of these otherwise"); 215 } 216 217 // Clear the frame anchor 218 thread->reset_last_Java_frame(); 219 220 // Examine the message from the interpreter to decide what to do 221 if (istate->msg() == BytecodeInterpreter::call_method) { 222 Method* callee = istate->callee(); 223 224 // Trim back the stack to put the parameters at the top 225 stack->set_sp(istate->stack() + 1); 226 227 // Make the call 228 Interpreter::invoke_method(callee, istate->callee_entry_point(), THREAD); 229 fixup_after_potential_safepoint(); 230 231 // Convert the result 232 istate->set_stack(stack->sp() - 1); 233 234 // Restore the stack 235 stack->set_sp(istate->stack_limit() + 1); 236 237 // Resume the interpreter 238 istate->set_msg(BytecodeInterpreter::method_resume); 239 } 240 else if (istate->msg() == BytecodeInterpreter::more_monitors) { 241 int monitor_words = frame::interpreter_frame_monitor_size(); 242 243 // Allocate the space 244 stack->overflow_check(monitor_words, THREAD); 245 if (HAS_PENDING_EXCEPTION) 246 break; 247 stack->alloc(monitor_words * wordSize); 248 249 // Move the expression stack contents 250 for (intptr_t *p = istate->stack() + 1; p < istate->stack_base(); p++) 251 *(p - monitor_words) = *p; 252 253 // Move the expression stack pointers 254 istate->set_stack_limit(istate->stack_limit() - monitor_words); 255 istate->set_stack(istate->stack() - monitor_words); 256 istate->set_stack_base(istate->stack_base() - monitor_words); 257 258 // Zero the new monitor so the interpreter can find it. 259 ((BasicObjectLock *) istate->stack_base())->set_obj(nullptr); 260 261 // Resume the interpreter 262 istate->set_msg(BytecodeInterpreter::got_monitors); 263 } 264 else if (istate->msg() == BytecodeInterpreter::return_from_method) { 265 // Copy the result into the caller's frame 266 result_slots = type2size[method->result_type()]; 267 assert(result_slots >= 0 && result_slots <= 2, "what?"); 268 result = istate->stack() + result_slots; 269 break; 270 } 271 else if (istate->msg() == BytecodeInterpreter::throwing_exception) { 272 assert(HAS_PENDING_EXCEPTION, "should do"); 273 break; 274 } 275 else if (istate->msg() == BytecodeInterpreter::do_osr) { 276 // Unwind the current frame 277 thread->pop_zero_frame(); 278 279 // Remove any extension of the previous frame 280 int extra_locals = method->max_locals() - method->size_of_parameters(); 281 stack->set_sp(stack->sp() + extra_locals); 282 283 // Jump into the OSR method 284 Interpreter::invoke_osr( 285 method, istate->osr_entry(), istate->osr_buf(), THREAD); 286 return; 287 } 288 else { 289 ShouldNotReachHere(); 290 } 291 } 292 293 // Unwind the current frame 294 thread->pop_zero_frame(); 295 296 // Pop our local variables 297 stack->set_sp(stack->sp() + method->max_locals()); 298 299 // Push our result 300 for (int i = 0; i < result_slots; i++) { 301 // Adjust result to smaller 302 union { 303 intptr_t res; 304 jint res_jint; 305 }; 306 res = result[-i]; 307 if (result_slots == 1) { 308 BasicType t = method->result_type(); 309 if (is_subword_type(t)) { 310 res_jint = (jint)narrow(t, res_jint); 311 } 312 } 313 stack->push(res); 314 } 315 } 316 317 int ZeroInterpreter::native_entry(Method* method, intptr_t UNUSED, TRAPS) { 318 // Make sure method is native and not abstract 319 assert(method->is_native() && !method->is_abstract(), "should be"); 320 321 JavaThread *thread = THREAD; 322 ZeroStack *stack = thread->zero_stack(); 323 324 // Allocate and initialize our frame 325 InterpreterFrame *frame = InterpreterFrame::build(method, CHECK_0); 326 thread->push_zero_frame(frame); 327 interpreterState istate = frame->interpreter_state(); 328 intptr_t *locals = istate->locals(); 329 330 // Lock if necessary 331 BasicObjectLock *monitor; 332 monitor = nullptr; 333 if (method->is_synchronized()) { 334 monitor = (BasicObjectLock*) istate->stack_base(); 335 oop lockee = monitor->obj(); 336 bool success = false; 337 if (LockingMode == LM_LEGACY) { 338 markWord disp = lockee->mark().set_unlocked(); 339 monitor->lock()->set_displaced_header(disp); 340 success = true; 341 if (lockee->cas_set_mark(markWord::from_pointer(monitor), disp) != disp) { 342 // Is it simple recursive case? 343 if (thread->is_lock_owned((address) disp.clear_lock_bits().to_pointer())) { 344 monitor->lock()->set_displaced_header(markWord::from_pointer(nullptr)); 345 } else { 346 success = false; 347 } 348 } 349 } 350 if (!success) { 351 CALL_VM_NOCHECK(InterpreterRuntime::monitorenter(thread, monitor)); 352 if (HAS_PENDING_EXCEPTION) 353 goto unwind_and_return; 354 } 355 } 356 357 // Get the signature handler 358 InterpreterRuntime::SignatureHandler *handler; { 359 address handlerAddr = method->signature_handler(); 360 if (handlerAddr == nullptr) { 361 CALL_VM_NOCHECK(InterpreterRuntime::prepare_native_call(thread, method)); 362 if (HAS_PENDING_EXCEPTION) 363 goto unlock_unwind_and_return; 364 365 handlerAddr = method->signature_handler(); 366 assert(handlerAddr != nullptr, "eh?"); 367 } 368 if (handlerAddr == (address) InterpreterRuntime::slow_signature_handler) { 369 CALL_VM_NOCHECK(handlerAddr = 370 InterpreterRuntime::slow_signature_handler(thread, method, nullptr,nullptr)); 371 if (HAS_PENDING_EXCEPTION) 372 goto unlock_unwind_and_return; 373 } 374 handler = \ 375 InterpreterRuntime::SignatureHandler::from_handlerAddr(handlerAddr); 376 } 377 378 // Get the native function entry point 379 address function; 380 function = method->native_function(); 381 assert(function != nullptr, "should be set if signature handler is"); 382 383 // Build the argument list 384 stack->overflow_check(handler->argument_count() * 2, THREAD); 385 if (HAS_PENDING_EXCEPTION) 386 goto unlock_unwind_and_return; 387 388 void **arguments; 389 void *mirror; { 390 arguments = 391 (void **) stack->alloc(handler->argument_count() * sizeof(void **)); 392 void **dst = arguments; 393 394 void *env = thread->jni_environment(); 395 *(dst++) = &env; 396 397 if (method->is_static()) { 398 istate->set_oop_temp( 399 method->constants()->pool_holder()->java_mirror()); 400 mirror = istate->oop_temp_addr(); 401 *(dst++) = &mirror; 402 } 403 404 intptr_t *src = locals; 405 for (int i = dst - arguments; i < handler->argument_count(); i++) { 406 ffi_type *type = handler->argument_type(i); 407 if (type == &ffi_type_pointer) { 408 if (*src) { 409 stack->push((intptr_t) src); 410 *(dst++) = stack->sp(); 411 } 412 else { 413 *(dst++) = src; 414 } 415 src--; 416 } 417 else if (type->size == 4) { 418 *(dst++) = src--; 419 } 420 else if (type->size == 8) { 421 src--; 422 *(dst++) = src--; 423 } 424 else { 425 ShouldNotReachHere(); 426 } 427 } 428 } 429 430 // Set up the Java frame anchor 431 thread->set_last_Java_frame(); 432 433 // Change the thread state to _thread_in_native 434 ThreadStateTransition::transition_from_java(thread, _thread_in_native); 435 436 // Make the call 437 intptr_t result[4 - LogBytesPerWord]; 438 ffi_call(handler->cif(), (void (*)()) function, result, arguments); 439 440 // Change the thread state back to _thread_in_Java and ensure it 441 // is seen by the GC thread. 442 // ThreadStateTransition::transition_from_native() cannot be used 443 // here because it does not check for asynchronous exceptions. 444 // We have to manage the transition ourself. 445 thread->set_thread_state_fence(_thread_in_native_trans); 446 447 // Handle safepoint operations, pending suspend requests, 448 // and pending asynchronous exceptions. 449 if (SafepointMechanism::should_process(thread) || 450 thread->has_special_condition_for_native_trans()) { 451 JavaThread::check_special_condition_for_native_trans(thread); 452 CHECK_UNHANDLED_OOPS_ONLY(thread->clear_unhandled_oops()); 453 } 454 455 // Finally we can change the thread state to _thread_in_Java. 456 thread->set_thread_state(_thread_in_Java); 457 fixup_after_potential_safepoint(); 458 459 // Notify the stack watermarks machinery that we are unwinding. 460 // Should do this before resetting the frame anchor. 461 stack_watermark_unwind_check(thread); 462 463 // Clear the frame anchor 464 thread->reset_last_Java_frame(); 465 466 // If the result was an oop then unbox it and store it in 467 // oop_temp where the garbage collector can see it before 468 // we release the handle it might be protected by. 469 if (handler->result_type() == &ffi_type_pointer) { 470 if (result[0] == 0) { 471 istate->set_oop_temp(nullptr); 472 } else { 473 jobject handle = reinterpret_cast<jobject>(result[0]); 474 istate->set_oop_temp(JNIHandles::resolve(handle)); 475 } 476 } 477 478 // Reset handle block 479 thread->active_handles()->clear(); 480 481 unlock_unwind_and_return: 482 483 // Unlock if necessary 484 if (monitor) { 485 bool success = false; 486 if (LockingMode == LM_LEGACY) { 487 BasicLock* lock = monitor->lock(); 488 oop rcvr = monitor->obj(); 489 monitor->set_obj(nullptr); 490 success = true; 491 markWord header = lock->displaced_header(); 492 if (header.to_pointer() != nullptr) { // Check for recursive lock 493 markWord old_header = markWord::encode(lock); 494 if (rcvr->cas_set_mark(header, old_header) != old_header) { 495 monitor->set_obj(rcvr); 496 success = false; 497 } 498 } 499 } 500 if (!success) { 501 InterpreterRuntime::monitorexit(monitor); 502 } 503 } 504 505 unwind_and_return: 506 507 // Unwind the current activation 508 thread->pop_zero_frame(); 509 510 // Pop our parameters 511 stack->set_sp(stack->sp() + method->size_of_parameters()); 512 513 // Push our result 514 if (!HAS_PENDING_EXCEPTION) { 515 BasicType type = method->result_type(); 516 stack->set_sp(stack->sp() - type2size[type]); 517 518 switch (type) { 519 case T_VOID: 520 break; 521 522 case T_BOOLEAN: 523 #ifndef VM_LITTLE_ENDIAN 524 result[0] <<= (BitsPerWord - BitsPerByte); 525 #endif 526 SET_LOCALS_INT(*(jboolean *) result != 0, 0); 527 break; 528 529 case T_CHAR: 530 #ifndef VM_LITTLE_ENDIAN 531 result[0] <<= (BitsPerWord - BitsPerShort); 532 #endif 533 SET_LOCALS_INT(*(jchar *) result, 0); 534 break; 535 536 case T_BYTE: 537 #ifndef VM_LITTLE_ENDIAN 538 result[0] <<= (BitsPerWord - BitsPerByte); 539 #endif 540 SET_LOCALS_INT(*(jbyte *) result, 0); 541 break; 542 543 case T_SHORT: 544 #ifndef VM_LITTLE_ENDIAN 545 result[0] <<= (BitsPerWord - BitsPerShort); 546 #endif 547 SET_LOCALS_INT(*(jshort *) result, 0); 548 break; 549 550 case T_INT: 551 #ifndef VM_LITTLE_ENDIAN 552 result[0] <<= (BitsPerWord - BitsPerInt); 553 #endif 554 SET_LOCALS_INT(*(jint *) result, 0); 555 break; 556 557 case T_LONG: 558 SET_LOCALS_LONG(*(jlong *) result, 0); 559 break; 560 561 case T_FLOAT: 562 SET_LOCALS_FLOAT(*(jfloat *) result, 0); 563 break; 564 565 case T_DOUBLE: 566 SET_LOCALS_DOUBLE(*(jdouble *) result, 0); 567 break; 568 569 case T_OBJECT: 570 case T_ARRAY: 571 SET_LOCALS_OBJECT(istate->oop_temp(), 0); 572 break; 573 574 default: 575 ShouldNotReachHere(); 576 } 577 } 578 579 // Already did every pending exception check here. 580 // If HAS_PENDING_EXCEPTION is true, the interpreter would handle the rest. 581 if (CheckJNICalls) { 582 THREAD->clear_pending_jni_exception_check(); 583 } 584 585 // No deoptimized frames on the stack 586 return 0; 587 } 588 589 int ZeroInterpreter::getter_entry(Method* method, intptr_t UNUSED, TRAPS) { 590 JavaThread* thread = THREAD; 591 // Drop into the slow path if we need a safepoint check 592 if (SafepointMechanism::should_process(thread)) { 593 return normal_entry(method, 0, THREAD); 594 } 595 596 // Read the field index from the bytecode: 597 // 0: aload_0 598 // 1: getfield 599 // 2: index 600 // 3: index 601 // 4: return 602 // 603 // NB this is not raw bytecode: index is in machine order 604 605 assert(method->is_getter(), "Expect the particular bytecode shape"); 606 u1* code = method->code_base(); 607 u2 index = Bytes::get_native_u2(&code[2]); 608 609 // Get the entry from the constant pool cache, and drop into 610 // the slow path if it has not been resolved 611 ConstantPoolCache* cache = method->constants()->cache(); 612 ResolvedFieldEntry* entry = cache->resolved_field_entry_at(index); 613 if (!entry->is_resolved(Bytecodes::_getfield)) { 614 return normal_entry(method, 0, THREAD); 615 } 616 617 ZeroStack* stack = thread->zero_stack(); 618 intptr_t* topOfStack = stack->sp(); 619 620 // Load the object pointer and drop into the slow path 621 // if we have a NullPointerException 622 oop object = STACK_OBJECT(0); 623 if (object == nullptr) { 624 return normal_entry(method, 0, THREAD); 625 } 626 627 // If needed, allocate additional slot on stack: we already have one 628 // for receiver, and double/long need another one. 629 switch (entry->tos_state()) { 630 case ltos: 631 case dtos: 632 stack->overflow_check(1, CHECK_0); 633 stack->alloc(wordSize); 634 topOfStack = stack->sp(); 635 break; 636 default: 637 ; 638 } 639 640 // Read the field to stack(0) 641 int offset = entry->field_offset(); 642 if (entry->is_volatile()) { 643 if (support_IRIW_for_not_multiple_copy_atomic_cpu) { 644 OrderAccess::fence(); 645 } 646 switch (entry->tos_state()) { 647 case btos: 648 case ztos: SET_STACK_INT(object->byte_field_acquire(offset), 0); break; 649 case ctos: SET_STACK_INT(object->char_field_acquire(offset), 0); break; 650 case stos: SET_STACK_INT(object->short_field_acquire(offset), 0); break; 651 case itos: SET_STACK_INT(object->int_field_acquire(offset), 0); break; 652 case ltos: SET_STACK_LONG(object->long_field_acquire(offset), 0); break; 653 case ftos: SET_STACK_FLOAT(object->float_field_acquire(offset), 0); break; 654 case dtos: SET_STACK_DOUBLE(object->double_field_acquire(offset), 0); break; 655 case atos: SET_STACK_OBJECT(object->obj_field_acquire(offset), 0); break; 656 default: 657 ShouldNotReachHere(); 658 } 659 } else { 660 switch (entry->tos_state()) { 661 case btos: 662 case ztos: SET_STACK_INT(object->byte_field(offset), 0); break; 663 case ctos: SET_STACK_INT(object->char_field(offset), 0); break; 664 case stos: SET_STACK_INT(object->short_field(offset), 0); break; 665 case itos: SET_STACK_INT(object->int_field(offset), 0); break; 666 case ltos: SET_STACK_LONG(object->long_field(offset), 0); break; 667 case ftos: SET_STACK_FLOAT(object->float_field(offset), 0); break; 668 case dtos: SET_STACK_DOUBLE(object->double_field(offset), 0); break; 669 case atos: SET_STACK_OBJECT(object->obj_field(offset), 0); break; 670 default: 671 ShouldNotReachHere(); 672 } 673 } 674 675 // No deoptimized frames on the stack 676 return 0; 677 } 678 679 int ZeroInterpreter::setter_entry(Method* method, intptr_t UNUSED, TRAPS) { 680 JavaThread* thread = THREAD; 681 // Drop into the slow path if we need a safepoint check 682 if (SafepointMechanism::should_process(thread)) { 683 return normal_entry(method, 0, THREAD); 684 } 685 686 // Read the field index from the bytecode: 687 // 0: aload_0 688 // 1: *load_1 689 // 2: putfield 690 // 3: index 691 // 4: index 692 // 5: return 693 // 694 // NB this is not raw bytecode: index is in machine order 695 696 assert(method->is_setter(), "Expect the particular bytecode shape"); 697 u1* code = method->code_base(); 698 u2 index = Bytes::get_native_u2(&code[3]); 699 700 // Get the entry from the constant pool cache, and drop into 701 // the slow path if it has not been resolved 702 ConstantPoolCache* cache = method->constants()->cache(); 703 ResolvedFieldEntry* entry = cache->resolved_field_entry_at(index); 704 if (!entry->is_resolved(Bytecodes::_putfield)) { 705 return normal_entry(method, 0, THREAD); 706 } 707 708 ZeroStack* stack = thread->zero_stack(); 709 intptr_t* topOfStack = stack->sp(); 710 711 // Figure out where the receiver is. If there is a long/double 712 // operand on stack top, then receiver is two slots down. 713 oop object = nullptr; 714 switch (entry->tos_state()) { 715 case ltos: 716 case dtos: 717 object = STACK_OBJECT(-2); 718 break; 719 default: 720 object = STACK_OBJECT(-1); 721 break; 722 } 723 724 // Load the receiver pointer and drop into the slow path 725 // if we have a NullPointerException 726 if (object == nullptr) { 727 return normal_entry(method, 0, THREAD); 728 } 729 730 // Store the stack(0) to field 731 int offset = entry->field_offset(); 732 if (entry->is_volatile()) { 733 switch (entry->tos_state()) { 734 case btos: object->release_byte_field_put(offset, STACK_INT(0)); break; 735 case ztos: object->release_byte_field_put(offset, STACK_INT(0) & 1); break; // only store LSB 736 case ctos: object->release_char_field_put(offset, STACK_INT(0)); break; 737 case stos: object->release_short_field_put(offset, STACK_INT(0)); break; 738 case itos: object->release_int_field_put(offset, STACK_INT(0)); break; 739 case ltos: object->release_long_field_put(offset, STACK_LONG(0)); break; 740 case ftos: object->release_float_field_put(offset, STACK_FLOAT(0)); break; 741 case dtos: object->release_double_field_put(offset, STACK_DOUBLE(0)); break; 742 case atos: object->release_obj_field_put(offset, STACK_OBJECT(0)); break; 743 default: 744 ShouldNotReachHere(); 745 } 746 OrderAccess::storeload(); 747 } else { 748 switch (entry->tos_state()) { 749 case btos: object->byte_field_put(offset, STACK_INT(0)); break; 750 case ztos: object->byte_field_put(offset, STACK_INT(0) & 1); break; // only store LSB 751 case ctos: object->char_field_put(offset, STACK_INT(0)); break; 752 case stos: object->short_field_put(offset, STACK_INT(0)); break; 753 case itos: object->int_field_put(offset, STACK_INT(0)); break; 754 case ltos: object->long_field_put(offset, STACK_LONG(0)); break; 755 case ftos: object->float_field_put(offset, STACK_FLOAT(0)); break; 756 case dtos: object->double_field_put(offset, STACK_DOUBLE(0)); break; 757 case atos: object->obj_field_put(offset, STACK_OBJECT(0)); break; 758 default: 759 ShouldNotReachHere(); 760 } 761 } 762 763 // Nothing is returned, pop out parameters 764 stack->set_sp(stack->sp() + method->size_of_parameters()); 765 766 // No deoptimized frames on the stack 767 return 0; 768 } 769 770 int ZeroInterpreter::empty_entry(Method* method, intptr_t UNUSED, TRAPS) { 771 JavaThread *thread = THREAD; 772 ZeroStack *stack = thread->zero_stack(); 773 774 // Drop into the slow path if we need a safepoint check 775 if (SafepointMechanism::should_process(thread)) { 776 return normal_entry(method, 0, THREAD); 777 } 778 779 // Pop our parameters 780 stack->set_sp(stack->sp() + method->size_of_parameters()); 781 782 // No deoptimized frames on the stack 783 return 0; 784 } 785 786 InterpreterFrame *InterpreterFrame::build(Method* const method, TRAPS) { 787 JavaThread *thread = THREAD; 788 ZeroStack *stack = thread->zero_stack(); 789 790 // Calculate the size of the frame we'll build, including 791 // any adjustments to the caller's frame that we'll make. 792 int extra_locals = 0; 793 int monitor_words = 0; 794 int stack_words = 0; 795 796 if (!method->is_native()) { 797 extra_locals = method->max_locals() - method->size_of_parameters(); 798 stack_words = method->max_stack(); 799 } 800 if (method->is_synchronized()) { 801 monitor_words = frame::interpreter_frame_monitor_size(); 802 } 803 stack->overflow_check( 804 extra_locals + header_words + monitor_words + stack_words, CHECK_NULL); 805 806 // Adjust the caller's stack frame to accommodate any additional 807 // local variables we have contiguously with our parameters. 808 for (int i = 0; i < extra_locals; i++) 809 stack->push(0); 810 811 intptr_t *locals; 812 if (method->is_native()) 813 locals = stack->sp() + (method->size_of_parameters() - 1); 814 else 815 locals = stack->sp() + (method->max_locals() - 1); 816 817 stack->push(0); // next_frame, filled in later 818 intptr_t *fp = stack->sp(); 819 assert(fp - stack->sp() == next_frame_off, "should be"); 820 821 stack->push(INTERPRETER_FRAME); 822 assert(fp - stack->sp() == frame_type_off, "should be"); 823 824 interpreterState istate = 825 (interpreterState) stack->alloc(sizeof(BytecodeInterpreter)); 826 assert(fp - stack->sp() == istate_off, "should be"); 827 828 istate->set_locals(locals); 829 istate->set_method(method); 830 istate->set_mirror(method->method_holder()->java_mirror()); 831 istate->set_self_link(istate); 832 istate->set_prev_link(nullptr); 833 istate->set_thread(thread); 834 istate->set_bcp(method->is_native() ? nullptr : method->code_base()); 835 istate->set_constants(method->constants()->cache()); 836 istate->set_msg(BytecodeInterpreter::method_entry); 837 istate->set_oop_temp(nullptr); 838 istate->set_callee(nullptr); 839 840 istate->set_monitor_base((BasicObjectLock *) stack->sp()); 841 if (method->is_synchronized()) { 842 BasicObjectLock *monitor = 843 (BasicObjectLock *) stack->alloc(monitor_words * wordSize); 844 oop object; 845 if (method->is_static()) 846 object = method->constants()->pool_holder()->java_mirror(); 847 else 848 object = cast_to_oop((void*)locals[0]); 849 monitor->set_obj(object); 850 } 851 852 istate->set_stack_base(stack->sp()); 853 istate->set_stack(stack->sp() - 1); 854 if (stack_words) 855 stack->alloc(stack_words * wordSize); 856 istate->set_stack_limit(stack->sp() - 1); 857 858 return (InterpreterFrame *) fp; 859 } 860 861 InterpreterFrame *InterpreterFrame::build(int size, TRAPS) { 862 ZeroStack *stack = THREAD->zero_stack(); 863 864 int size_in_words = size >> LogBytesPerWord; 865 assert(size_in_words * wordSize == size, "unaligned"); 866 assert(size_in_words >= header_words, "too small"); 867 stack->overflow_check(size_in_words, CHECK_NULL); 868 869 stack->push(0); // next_frame, filled in later 870 intptr_t *fp = stack->sp(); 871 assert(fp - stack->sp() == next_frame_off, "should be"); 872 873 stack->push(INTERPRETER_FRAME); 874 assert(fp - stack->sp() == frame_type_off, "should be"); 875 876 interpreterState istate = 877 (interpreterState) stack->alloc(sizeof(BytecodeInterpreter)); 878 assert(fp - stack->sp() == istate_off, "should be"); 879 istate->set_self_link(nullptr); // mark invalid 880 881 stack->alloc((size_in_words - header_words) * wordSize); 882 883 return (InterpreterFrame *) fp; 884 } 885 886 address ZeroInterpreter::return_entry(TosState state, int length, Bytecodes::Code code) { 887 ShouldNotCallThis(); 888 return nullptr; 889 } 890 891 address ZeroInterpreter::deopt_entry(TosState state, int length) { 892 return nullptr; 893 } 894 895 address ZeroInterpreter::remove_activation_preserving_args_entry() { 896 // Do an uncommon trap type entry. c++ interpreter will know 897 // to pop frame and preserve the args 898 return Interpreter::deopt_entry(vtos, 0); 899 } 900 901 address ZeroInterpreter::remove_activation_early_entry(TosState state) { 902 return nullptr; 903 } 904 905 // Helper for figuring out if frames are interpreter frames 906 907 bool ZeroInterpreter::contains(address pc) { 908 return false; // make frame::print_value_on work 909 } 910 911 void ZeroInterpreter::stack_watermark_unwind_check(JavaThread* thread) { 912 // If frame pointer is in the danger zone, notify the runtime that 913 // it needs to act before continuing the unwinding. 914 uintptr_t fp = (uintptr_t)thread->last_Java_fp(); 915 uintptr_t watermark = thread->poll_data()->get_polling_word(); 916 if (fp > watermark) { 917 InterpreterRuntime::at_unwind(thread); 918 } 919 }