< prev index next >

src/hotspot/cpu/aarch64/interp_masm_aarch64.cpp

Print this page

 462 // Unlock any Java monitors from synchronized blocks.
 463 // Apply stack watermark barrier.
 464 // Notify JVMTI.
 465 // Remove the activation from the stack.
 466 //
 467 // If there are locked Java monitors
 468 //    If throw_monitor_exception
 469 //       throws IllegalMonitorStateException
 470 //    Else if install_monitor_exception
 471 //       installs IllegalMonitorStateException
 472 //    Else
 473 //       no error processing
 474 void InterpreterMacroAssembler::remove_activation(TosState state,
 475                                                   bool throw_monitor_exception,
 476                                                   bool install_monitor_exception,
 477                                                   bool notify_jvmdi) {
 478   // Note: Registers r3 xmm0 may be in use for the
 479   // result check if synchronized method
 480   Label unlocked, unlock, no_unlock;
 481 








 482   // get the value of _do_not_unlock_if_synchronized into r3
 483   const Address do_not_unlock_if_synchronized(rthread,
 484     in_bytes(JavaThread::do_not_unlock_if_synchronized_offset()));
 485   ldrb(r3, do_not_unlock_if_synchronized);
 486   strb(zr, do_not_unlock_if_synchronized); // reset the flag
 487 
 488  // get method access flags
 489   ldr(r1, Address(rfp, frame::interpreter_frame_method_offset * wordSize));
 490   ldrh(r2, Address(r1, Method::access_flags_offset()));
 491   tbz(r2, exact_log2(JVM_ACC_SYNCHRONIZED), unlocked);
 492 
 493   // Don't unlock anything if the _do_not_unlock_if_synchronized flag
 494   // is set.
 495   cbnz(r3, no_unlock);
 496 
 497   // unlock monitor
 498   push(state); // save result
 499 
 500   // BasicObjectLock will be first in list, since this is a
 501   // synchronized method. However, need to check that the object has

1354   // Note: No need to save/restore rbcp & rlocals pointer since these
1355   //       are callee saved registers and no blocking/ GC can happen
1356   //       in leaf calls.
1357 #ifdef ASSERT
1358   {
1359     Label L;
1360     ldr(rscratch1, Address(rfp, frame::interpreter_frame_last_sp_offset * wordSize));
1361     cbz(rscratch1, L);
1362     stop("InterpreterMacroAssembler::call_VM_leaf_base:"
1363          " last_sp != nullptr");
1364     bind(L);
1365   }
1366 #endif /* ASSERT */
1367   // super call
1368   MacroAssembler::call_VM_leaf_base(entry_point, number_of_arguments);
1369 }
1370 
1371 void InterpreterMacroAssembler::call_VM_base(Register oop_result,
1372                                              Register java_thread,
1373                                              Register last_java_sp,

1374                                              address  entry_point,
1375                                              int      number_of_arguments,
1376                                              bool     check_exceptions) {
1377   // interpreter specific
1378   //
1379   // Note: Could avoid restoring locals ptr (callee saved) - however doesn't
1380   //       really make a difference for these runtime calls, since they are
1381   //       slow anyway. Btw., bcp must be saved/restored since it may change
1382   //       due to GC.
1383   // assert(java_thread == noreg , "not expecting a precomputed java thread");
1384   save_bcp();
1385 #ifdef ASSERT
1386   {
1387     Label L;
1388     ldr(rscratch1, Address(rfp, frame::interpreter_frame_last_sp_offset * wordSize));
1389     cbz(rscratch1, L);
1390     stop("InterpreterMacroAssembler::call_VM_base:"
1391          " last_sp != nullptr");
1392     bind(L);
1393   }
1394 #endif /* ASSERT */
1395   // super call
1396   MacroAssembler::call_VM_base(oop_result, noreg, last_java_sp,
1397                                entry_point, number_of_arguments,
1398                      check_exceptions);
1399 // interpreter specific
1400   restore_bcp();
1401   restore_locals();
1402 }
1403 
1404 void InterpreterMacroAssembler::call_VM_preemptable(Register oop_result,
1405                                                     address entry_point,
1406                                                     Register arg_1) {
1407   assert(arg_1 == c_rarg1, "");

1408   Label resume_pc, not_preempted;
1409 
1410 #ifdef ASSERT
1411   {
1412     Label L;
1413     ldr(rscratch1, Address(rthread, JavaThread::preempt_alternate_return_offset()));
1414     cbz(rscratch1, L);
1415     stop("Should not have alternate return address set");
1416     bind(L);







1417   }
1418 #endif /* ASSERT */
1419 
1420   // Force freeze slow path.
1421   push_cont_fastpath();
1422 
1423   // Make VM call. In case of preemption set last_pc to the one we want to resume to.
1424   adr(rscratch1, resume_pc);
1425   str(rscratch1, Address(rthread, JavaThread::last_Java_pc_offset()));
1426   call_VM_base(oop_result, noreg, noreg, entry_point, 1, false /*check_exceptions*/);
1427 
1428   pop_cont_fastpath();
1429 












1430   // Check if preempted.
1431   ldr(rscratch1, Address(rthread, JavaThread::preempt_alternate_return_offset()));
1432   cbz(rscratch1, not_preempted);
1433   str(zr, Address(rthread, JavaThread::preempt_alternate_return_offset()));
1434   br(rscratch1);
1435 
1436   // In case of preemption, this is where we will resume once we finally acquire the monitor.
1437   bind(resume_pc);
1438   restore_after_resume(false /* is_native */);
1439 
1440   bind(not_preempted);













































1441 }
1442 
1443 void InterpreterMacroAssembler::restore_after_resume(bool is_native) {
1444   lea(rscratch1, ExternalAddress(Interpreter::cont_resume_interpreter_adapter()));
1445   blr(rscratch1);
1446   if (is_native) {
1447     // On resume we need to set up stack as expected
1448     push(dtos);
1449     push(ltos);
1450   }
1451 }
1452 
1453 void InterpreterMacroAssembler::profile_obj_type(Register obj, const Address& mdo_addr) {
1454   assert_different_registers(obj, rscratch1, mdo_addr.base(), mdo_addr.index());
1455   Label update, next, none;
1456 
1457   verify_oop(obj);
1458 
1459   cbnz(obj, update);
1460   orptr(mdo_addr, TypeEntries::null_seen);

 462 // Unlock any Java monitors from synchronized blocks.
 463 // Apply stack watermark barrier.
 464 // Notify JVMTI.
 465 // Remove the activation from the stack.
 466 //
 467 // If there are locked Java monitors
 468 //    If throw_monitor_exception
 469 //       throws IllegalMonitorStateException
 470 //    Else if install_monitor_exception
 471 //       installs IllegalMonitorStateException
 472 //    Else
 473 //       no error processing
 474 void InterpreterMacroAssembler::remove_activation(TosState state,
 475                                                   bool throw_monitor_exception,
 476                                                   bool install_monitor_exception,
 477                                                   bool notify_jvmdi) {
 478   // Note: Registers r3 xmm0 may be in use for the
 479   // result check if synchronized method
 480   Label unlocked, unlock, no_unlock;
 481 
 482 #ifdef ASSERT
 483   Label not_preempted;
 484   ldr(rscratch1, Address(rthread, JavaThread::preempt_alternate_return_offset()));
 485   cbz(rscratch1, not_preempted);
 486   stop("remove_activation: should not have alternate return address set");
 487   bind(not_preempted);
 488 #endif /* ASSERT */
 489 
 490   // get the value of _do_not_unlock_if_synchronized into r3
 491   const Address do_not_unlock_if_synchronized(rthread,
 492     in_bytes(JavaThread::do_not_unlock_if_synchronized_offset()));
 493   ldrb(r3, do_not_unlock_if_synchronized);
 494   strb(zr, do_not_unlock_if_synchronized); // reset the flag
 495 
 496  // get method access flags
 497   ldr(r1, Address(rfp, frame::interpreter_frame_method_offset * wordSize));
 498   ldrh(r2, Address(r1, Method::access_flags_offset()));
 499   tbz(r2, exact_log2(JVM_ACC_SYNCHRONIZED), unlocked);
 500 
 501   // Don't unlock anything if the _do_not_unlock_if_synchronized flag
 502   // is set.
 503   cbnz(r3, no_unlock);
 504 
 505   // unlock monitor
 506   push(state); // save result
 507 
 508   // BasicObjectLock will be first in list, since this is a
 509   // synchronized method. However, need to check that the object has

1362   // Note: No need to save/restore rbcp & rlocals pointer since these
1363   //       are callee saved registers and no blocking/ GC can happen
1364   //       in leaf calls.
1365 #ifdef ASSERT
1366   {
1367     Label L;
1368     ldr(rscratch1, Address(rfp, frame::interpreter_frame_last_sp_offset * wordSize));
1369     cbz(rscratch1, L);
1370     stop("InterpreterMacroAssembler::call_VM_leaf_base:"
1371          " last_sp != nullptr");
1372     bind(L);
1373   }
1374 #endif /* ASSERT */
1375   // super call
1376   MacroAssembler::call_VM_leaf_base(entry_point, number_of_arguments);
1377 }
1378 
1379 void InterpreterMacroAssembler::call_VM_base(Register oop_result,
1380                                              Register java_thread,
1381                                              Register last_java_sp,
1382                                              Label*   return_pc,
1383                                              address  entry_point,
1384                                              int      number_of_arguments,
1385                                              bool     check_exceptions) {
1386   // interpreter specific
1387   //
1388   // Note: Could avoid restoring locals ptr (callee saved) - however doesn't
1389   //       really make a difference for these runtime calls, since they are
1390   //       slow anyway. Btw., bcp must be saved/restored since it may change
1391   //       due to GC.
1392   // assert(java_thread == noreg , "not expecting a precomputed java thread");
1393   save_bcp();
1394 #ifdef ASSERT
1395   {
1396     Label L;
1397     ldr(rscratch1, Address(rfp, frame::interpreter_frame_last_sp_offset * wordSize));
1398     cbz(rscratch1, L);
1399     stop("InterpreterMacroAssembler::call_VM_base:"
1400          " last_sp != nullptr");
1401     bind(L);
1402   }
1403 #endif /* ASSERT */
1404   // super call
1405   MacroAssembler::call_VM_base(oop_result, noreg, last_java_sp,
1406                                return_pc, entry_point,
1407                                number_of_arguments, check_exceptions);
1408 // interpreter specific
1409   restore_bcp();
1410   restore_locals();
1411 }
1412 
1413 void InterpreterMacroAssembler::call_VM_preemptable_helper(Register oop_result,
1414                                                            address entry_point,
1415                                                            int number_of_arguments,
1416                                                            bool check_exceptions) {
1417   assert(InterpreterRuntime::is_preemptable_call(entry_point), "VM call not preemptable, should use call_VM()");
1418   Label resume_pc, not_preempted;
1419 
1420 #ifdef ASSERT
1421   {
1422     Label L1, L2;
1423     ldr(rscratch1, Address(rthread, JavaThread::preempt_alternate_return_offset()));
1424     cbz(rscratch1, L1);
1425     stop("call_VM_preemptable_helper: Should not have alternate return address set");
1426     bind(L1);
1427     // We check this counter in patch_return_pc_with_preempt_stub() during freeze.
1428     incrementw(Address(rthread, JavaThread::interp_at_preemptable_vmcall_cnt_offset()));
1429     ldrw(rscratch1, Address(rthread, JavaThread::interp_at_preemptable_vmcall_cnt_offset()));
1430     cmpw(rscratch1, 0);
1431     br(Assembler::GT, L2);
1432     stop("call_VM_preemptable_helper: should be > 0");
1433     bind(L2);
1434   }
1435 #endif /* ASSERT */
1436 
1437   // Force freeze slow path.
1438   push_cont_fastpath();
1439 
1440   // Make VM call. In case of preemption set last_pc to the one we want to resume to.
1441   // Note: call_VM_base will use resume_pc label to set last_Java_pc.
1442   call_VM_base(noreg, noreg, noreg, &resume_pc, entry_point, number_of_arguments, false /*check_exceptions*/);

1443 
1444   pop_cont_fastpath();
1445 
1446 #ifdef ASSERT
1447   {
1448     Label L;
1449     decrementw(Address(rthread, JavaThread::interp_at_preemptable_vmcall_cnt_offset()));
1450     ldrw(rscratch1, Address(rthread, JavaThread::interp_at_preemptable_vmcall_cnt_offset()));
1451     cmpw(rscratch1, 0);
1452     br(Assembler::GE, L);
1453     stop("call_VM_preemptable_helper: should be >= 0");
1454     bind(L);
1455   }
1456 #endif /* ASSERT */
1457 
1458   // Check if preempted.
1459   ldr(rscratch1, Address(rthread, JavaThread::preempt_alternate_return_offset()));
1460   cbz(rscratch1, not_preempted);
1461   str(zr, Address(rthread, JavaThread::preempt_alternate_return_offset()));
1462   br(rscratch1);
1463 
1464   // In case of preemption, this is where we will resume once we finally acquire the monitor.
1465   bind(resume_pc);
1466   restore_after_resume(false /* is_native */);
1467 
1468   bind(not_preempted);
1469   if (check_exceptions) {
1470     // check for pending exceptions (java_thread is set upon return)
1471     ldr(rscratch1, Address(rthread, in_bytes(Thread::pending_exception_offset())));
1472     Label ok;
1473     cbz(rscratch1, ok);
1474     lea(rscratch1, RuntimeAddress(StubRoutines::forward_exception_entry()));
1475     br(rscratch1);
1476     bind(ok);
1477   }
1478 
1479   // get oop result if there is one and reset the value in the thread
1480   if (oop_result->is_valid()) {
1481     get_vm_result_oop(oop_result, rthread);
1482   }
1483 }
1484 
1485 static void pass_arg1(MacroAssembler* masm, Register arg) {
1486   if (c_rarg1 != arg ) {
1487     masm->mov(c_rarg1, arg);
1488   }
1489 }
1490 
1491 static void pass_arg2(MacroAssembler* masm, Register arg) {
1492   if (c_rarg2 != arg ) {
1493     masm->mov(c_rarg2, arg);
1494   }
1495 }
1496 
1497 void InterpreterMacroAssembler::call_VM_preemptable(Register oop_result,
1498                                          address entry_point,
1499                                          Register arg_1,
1500                                          bool check_exceptions) {
1501   pass_arg1(this, arg_1);
1502   call_VM_preemptable_helper(oop_result, entry_point, 1, check_exceptions);
1503 }
1504 
1505 void InterpreterMacroAssembler::call_VM_preemptable(Register oop_result,
1506                                          address entry_point,
1507                                          Register arg_1,
1508                                          Register arg_2,
1509                                          bool check_exceptions) {
1510   LP64_ONLY(assert_different_registers(arg_1, c_rarg2));
1511   pass_arg2(this, arg_2);
1512   pass_arg1(this, arg_1);
1513   call_VM_preemptable_helper(oop_result, entry_point, 2, check_exceptions);
1514 }
1515 
1516 void InterpreterMacroAssembler::restore_after_resume(bool is_native) {
1517   lea(rscratch1, ExternalAddress(Interpreter::cont_resume_interpreter_adapter()));
1518   blr(rscratch1);
1519   if (is_native) {
1520     // On resume we need to set up stack as expected
1521     push(dtos);
1522     push(ltos);
1523   }
1524 }
1525 
1526 void InterpreterMacroAssembler::profile_obj_type(Register obj, const Address& mdo_addr) {
1527   assert_different_registers(obj, rscratch1, mdo_addr.base(), mdo_addr.index());
1528   Label update, next, none;
1529 
1530   verify_oop(obj);
1531 
1532   cbnz(obj, update);
1533   orptr(mdo_addr, TypeEntries::null_seen);
< prev index next >