240 __ get_dispatch();
241
242 // Calculate stack limit
243 __ ldr(rscratch1, Address(rmethod, Method::const_offset()));
244 __ ldrh(rscratch1, Address(rscratch1, ConstMethod::max_stack_offset()));
245 __ add(rscratch1, rscratch1, frame::interpreter_frame_monitor_size() + 2);
246 __ ldr(rscratch2,
247 Address(rfp, frame::interpreter_frame_initial_sp_offset * wordSize));
248 __ sub(rscratch1, rscratch2, rscratch1, ext::uxtx, 3);
249 __ andr(sp, rscratch1, -16);
250
251 // Restore expression stack pointer
252 __ ldr(esp, Address(rfp, frame::interpreter_frame_last_sp_offset * wordSize));
253 // NULL last_sp until next java call
254 __ str(zr, Address(rfp, frame::interpreter_frame_last_sp_offset * wordSize));
255
256 __ dispatch_next(state, step);
257 return entry;
258 }
259
260
261 int AbstractInterpreter::BasicType_as_index(BasicType type) {
262 int i = 0;
263 switch (type) {
264 case T_BOOLEAN: i = 0; break;
265 case T_CHAR : i = 1; break;
266 case T_BYTE : i = 2; break;
267 case T_SHORT : i = 3; break;
268 case T_INT : i = 4; break;
269 case T_LONG : i = 5; break;
270 case T_VOID : i = 6; break;
271 case T_FLOAT : i = 7; break;
272 case T_DOUBLE : i = 8; break;
273 case T_OBJECT : i = 9; break;
274 case T_ARRAY : i = 9; break;
275 default : ShouldNotReachHere();
276 }
277 assert(0 <= i && i < AbstractInterpreter::number_of_result_handlers,
278 "index out of bounds");
279 return i;
280 }
281
282
283 address TemplateInterpreterGenerator::generate_result_handler_for(
284 BasicType type) {
285 address entry = __ pc();
286 switch (type) {
287 case T_BOOLEAN: __ uxtb(r0, r0); break;
288 case T_CHAR : __ uxth(r0, r0); break;
289 case T_BYTE : __ sxtb(r0, r0); break;
290 case T_SHORT : __ sxth(r0, r0); break;
291 case T_INT : __ uxtw(r0, r0); break; // FIXME: We almost certainly don't need this
292 case T_LONG : /* nothing to do */ break;
293 case T_VOID : /* nothing to do */ break;
294 case T_FLOAT : /* nothing to do */ break;
295 case T_DOUBLE : /* nothing to do */ break;
296 case T_OBJECT :
297 // retrieve result from frame
298 __ ldr(r0, Address(rfp, frame::interpreter_frame_oop_temp_offset*wordSize));
299 // and verify it
300 __ verify_oop(r0);
301 break;
302 default : ShouldNotReachHere();
1450 __ dispatch_next(vtos);
1451
1452 // invocation counter overflow
1453 if (inc_counter) {
1454 if (ProfileInterpreter) {
1455 // We have decided to profile this method in the interpreter
1456 __ bind(profile_method);
1457 __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::profile_method));
1458 __ set_method_data_pointer_for_bcp();
1459 // don't think we need this
1460 __ get_method(r1);
1461 __ b(profile_method_continue);
1462 }
1463 // Handle overflow of counter and compile method
1464 __ bind(invocation_counter_overflow);
1465 generate_counter_overflow(&continue_after_compile);
1466 }
1467
1468 return entry_point;
1469 }
1470
1471 // These should never be compiled since the interpreter will prefer
1472 // the compiled version to the intrinsic version.
1473 bool AbstractInterpreter::can_be_compiled(methodHandle m) {
1474 switch (method_kind(m)) {
1475 case Interpreter::java_lang_math_sin : // fall thru
1476 case Interpreter::java_lang_math_cos : // fall thru
1477 case Interpreter::java_lang_math_tan : // fall thru
1478 case Interpreter::java_lang_math_abs : // fall thru
1479 case Interpreter::java_lang_math_log : // fall thru
1480 case Interpreter::java_lang_math_log10 : // fall thru
1481 case Interpreter::java_lang_math_sqrt : // fall thru
1482 case Interpreter::java_lang_math_pow : // fall thru
1483 case Interpreter::java_lang_math_exp :
1484 return false;
1485 default:
1486 return true;
1487 }
1488 }
1489
1490 // How much stack a method activation needs in words.
1491 int AbstractInterpreter::size_top_interpreter_activation(Method* method) {
1492 const int entry_size = frame::interpreter_frame_monitor_size();
1493
1494 // total overhead size: entry_size + (saved rfp thru expr stack
1495 // bottom). be sure to change this if you add/subtract anything
1496 // to/from the overhead area
1497 const int overhead_size =
1498 -(frame::interpreter_frame_initial_sp_offset) + entry_size;
1499
1500 const int stub_code = frame::entry_frame_after_call_words;
1501 const int method_stack = (method->max_locals() + method->max_stack()) *
1502 Interpreter::stackElementWords;
1503 return (overhead_size + method_stack + stub_code);
1504 }
1505
1506 // asm based interpreter deoptimization helpers
1507 int AbstractInterpreter::size_activation(int max_stack,
1508 int temps,
1509 int extra_args,
1510 int monitors,
1511 int callee_params,
1512 int callee_locals,
1513 bool is_top_frame) {
1514 // Note: This calculation must exactly parallel the frame setup
1515 // in InterpreterGenerator::generate_method_entry.
1516
1517 // fixed size of an interpreter frame:
1518 int overhead = frame::sender_sp_offset -
1519 frame::interpreter_frame_initial_sp_offset;
1520 // Our locals were accounted for by the caller (or last_frame_adjust
1521 // on the transistion) Since the callee parameters already account
1522 // for the callee's params we only need to account for the extra
1523 // locals.
1524 int size = overhead +
1525 (callee_locals - callee_params)*Interpreter::stackElementWords +
1526 monitors * frame::interpreter_frame_monitor_size() +
1527 temps* Interpreter::stackElementWords + extra_args;
1528
1529 // On AArch64 we always keep the stack pointer 16-aligned, so we
1530 // must round up here.
1531 size = round_to(size, 2);
1532
1533 return size;
1534 }
1535
1536 void AbstractInterpreter::layout_activation(Method* method,
1537 int tempcount,
1538 int popframe_extra_args,
1539 int moncount,
1540 int caller_actual_parameters,
1541 int callee_param_count,
1542 int callee_locals,
1543 frame* caller,
1544 frame* interpreter_frame,
1545 bool is_top_frame,
1546 bool is_bottom_frame) {
1547 // The frame interpreter_frame is guaranteed to be the right size,
1548 // as determined by a previous call to the size_activation() method.
1549 // It is also guaranteed to be walkable even though it is in a
1550 // skeletal state
1551
1552 int max_locals = method->max_locals() * Interpreter::stackElementWords;
1553 int extra_locals = (method->max_locals() - method->size_of_parameters()) *
1554 Interpreter::stackElementWords;
1555
1556 #ifdef ASSERT
1557 assert(caller->sp() == interpreter_frame->sender_sp(), "Frame not properly walkable");
1558 #endif
1559
1560 interpreter_frame->interpreter_frame_set_method(method);
1561 // NOTE the difference in using sender_sp and
1562 // interpreter_frame_sender_sp interpreter_frame_sender_sp is
1563 // the original sp of the caller (the unextended_sp) and
1564 // sender_sp is fp+8/16 (32bit/64bit) XXX
1565 intptr_t* locals = interpreter_frame->sender_sp() + max_locals - 1;
1566
1567 #ifdef ASSERT
1568 if (caller->is_interpreted_frame()) {
1569 assert(locals < caller->fp() + frame::interpreter_frame_initial_sp_offset, "bad placement");
1570 }
1571 #endif
1572
1573 interpreter_frame->interpreter_frame_set_locals(locals);
1574 BasicObjectLock* montop = interpreter_frame->interpreter_frame_monitor_begin();
1575 BasicObjectLock* monbot = montop - moncount;
1576 interpreter_frame->interpreter_frame_set_monitor_end(monbot);
1577
1578 // Set last_sp
1579 intptr_t* esp = (intptr_t*) monbot -
1580 tempcount*Interpreter::stackElementWords -
1581 popframe_extra_args;
1582 interpreter_frame->interpreter_frame_set_last_sp(esp);
1583
1584 // All frames but the initial (oldest) interpreter frame we fill in have
1585 // a value for sender_sp that allows walking the stack but isn't
1586 // truly correct. Correct the value here.
1587 if (extra_locals != 0 &&
1588 interpreter_frame->sender_sp() ==
1589 interpreter_frame->interpreter_frame_sender_sp()) {
1590 interpreter_frame->set_interpreter_frame_sender_sp(caller->sp() +
1591 extra_locals);
1592 }
1593 *interpreter_frame->interpreter_frame_cache_addr() =
1594 method->constants()->cache();
1595 }
1596
1597
1598 //-----------------------------------------------------------------------------
1599 // Exceptions
1600
1601 void TemplateInterpreterGenerator::generate_throw_exception() {
1602 // Entry point in previous activation (i.e., if the caller was
1603 // interpreted)
1604 Interpreter::_rethrow_exception_entry = __ pc();
1605 // Restore sp to interpreter_frame_last_sp even though we are going
1606 // to empty the expression stack for the exception processing.
1607 __ str(zr, Address(rfp, frame::interpreter_frame_last_sp_offset * wordSize));
1608 // r0: exception
1609 // r3: return address/pc that threw exception
1610 __ restore_bcp(); // rbcp points to call/send
1611 __ restore_locals();
1612 __ restore_constant_pool_cache();
1613 __ reinit_heapbase(); // restore rheapbase as heapbase.
1614 __ get_dispatch();
1615
1616 #ifndef PRODUCT
|
240 __ get_dispatch();
241
242 // Calculate stack limit
243 __ ldr(rscratch1, Address(rmethod, Method::const_offset()));
244 __ ldrh(rscratch1, Address(rscratch1, ConstMethod::max_stack_offset()));
245 __ add(rscratch1, rscratch1, frame::interpreter_frame_monitor_size() + 2);
246 __ ldr(rscratch2,
247 Address(rfp, frame::interpreter_frame_initial_sp_offset * wordSize));
248 __ sub(rscratch1, rscratch2, rscratch1, ext::uxtx, 3);
249 __ andr(sp, rscratch1, -16);
250
251 // Restore expression stack pointer
252 __ ldr(esp, Address(rfp, frame::interpreter_frame_last_sp_offset * wordSize));
253 // NULL last_sp until next java call
254 __ str(zr, Address(rfp, frame::interpreter_frame_last_sp_offset * wordSize));
255
256 __ dispatch_next(state, step);
257 return entry;
258 }
259
260 address TemplateInterpreterGenerator::generate_result_handler_for(
261 BasicType type) {
262 address entry = __ pc();
263 switch (type) {
264 case T_BOOLEAN: __ uxtb(r0, r0); break;
265 case T_CHAR : __ uxth(r0, r0); break;
266 case T_BYTE : __ sxtb(r0, r0); break;
267 case T_SHORT : __ sxth(r0, r0); break;
268 case T_INT : __ uxtw(r0, r0); break; // FIXME: We almost certainly don't need this
269 case T_LONG : /* nothing to do */ break;
270 case T_VOID : /* nothing to do */ break;
271 case T_FLOAT : /* nothing to do */ break;
272 case T_DOUBLE : /* nothing to do */ break;
273 case T_OBJECT :
274 // retrieve result from frame
275 __ ldr(r0, Address(rfp, frame::interpreter_frame_oop_temp_offset*wordSize));
276 // and verify it
277 __ verify_oop(r0);
278 break;
279 default : ShouldNotReachHere();
1427 __ dispatch_next(vtos);
1428
1429 // invocation counter overflow
1430 if (inc_counter) {
1431 if (ProfileInterpreter) {
1432 // We have decided to profile this method in the interpreter
1433 __ bind(profile_method);
1434 __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::profile_method));
1435 __ set_method_data_pointer_for_bcp();
1436 // don't think we need this
1437 __ get_method(r1);
1438 __ b(profile_method_continue);
1439 }
1440 // Handle overflow of counter and compile method
1441 __ bind(invocation_counter_overflow);
1442 generate_counter_overflow(&continue_after_compile);
1443 }
1444
1445 return entry_point;
1446 }
1447
1448 //-----------------------------------------------------------------------------
1449 // Exceptions
1450
1451 void TemplateInterpreterGenerator::generate_throw_exception() {
1452 // Entry point in previous activation (i.e., if the caller was
1453 // interpreted)
1454 Interpreter::_rethrow_exception_entry = __ pc();
1455 // Restore sp to interpreter_frame_last_sp even though we are going
1456 // to empty the expression stack for the exception processing.
1457 __ str(zr, Address(rfp, frame::interpreter_frame_last_sp_offset * wordSize));
1458 // r0: exception
1459 // r3: return address/pc that threw exception
1460 __ restore_bcp(); // rbcp points to call/send
1461 __ restore_locals();
1462 __ restore_constant_pool_cache();
1463 __ reinit_heapbase(); // restore rheapbase as heapbase.
1464 __ get_dispatch();
1465
1466 #ifndef PRODUCT
|