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