1 /*
2 * Copyright (c) 2016, 2021, Oracle and/or its affiliates. All rights reserved.
3 * Copyright (c) 2016, 2020 SAP SE. All rights reserved.
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/macroAssembler.inline.hpp"
28 #include "classfile/javaClasses.hpp"
29 #include "gc/shared/barrierSetAssembler.hpp"
30 #include "interpreter/abstractInterpreter.hpp"
31 #include "interpreter/bytecodeHistogram.hpp"
32 #include "interpreter/interpreter.hpp"
33 #include "interpreter/interpreterRuntime.hpp"
34 #include "interpreter/interp_masm.hpp"
35 #include "interpreter/templateInterpreterGenerator.hpp"
36 #include "interpreter/templateTable.hpp"
37 #include "oops/arrayOop.hpp"
38 #include "oops/methodData.hpp"
39 #include "oops/oop.inline.hpp"
40 #include "prims/jvmtiExport.hpp"
41 #include "prims/jvmtiThreadState.hpp"
42 #include "runtime/arguments.hpp"
43 #include "runtime/deoptimization.hpp"
44 #include "runtime/frame.inline.hpp"
45 #include "runtime/jniHandles.hpp"
46 #include "runtime/sharedRuntime.hpp"
47 #include "runtime/stubRoutines.hpp"
48 #include "runtime/synchronizer.hpp"
49 #include "runtime/timer.hpp"
50 #include "runtime/vframeArray.hpp"
51 #include "utilities/debug.hpp"
52
53
54 // Size of interpreter code. Increase if too small. Interpreter will
55 // fail with a guarantee ("not enough space for interpreter generation");
56 // if too small.
57 // Run with +PrintInterpreter to get the VM to print out the size.
58 // Max size with JVMTI
59 int TemplateInterpreter::InterpreterCodeSize = 320*K;
60
61 #undef __
62 #ifdef PRODUCT
63 #define __ _masm->
64 #else
65 #define __ _masm->
66 // #define __ (Verbose ? (_masm->block_comment(FILE_AND_LINE),_masm):_masm)->
67 #endif
68
69 #define BLOCK_COMMENT(str) __ block_comment(str)
70 #define BIND(label) __ bind(label); BLOCK_COMMENT(#label ":")
71
72 #define oop_tmp_offset _z_ijava_state_neg(oop_tmp)
73
74 //-----------------------------------------------------------------------------
75
generate_slow_signature_handler()76 address TemplateInterpreterGenerator::generate_slow_signature_handler() {
77 //
78 // New slow_signature handler that respects the z/Architecture
79 // C calling conventions.
80 //
81 // We get called by the native entry code with our output register
82 // area == 8. First we call InterpreterRuntime::get_result_handler
83 // to copy the pointer to the signature string temporarily to the
84 // first C-argument and to return the result_handler in
85 // Z_RET. Since native_entry will copy the jni-pointer to the
86 // first C-argument slot later on, it's OK to occupy this slot
87 // temporarily. Then we copy the argument list on the java
88 // expression stack into native varargs format on the native stack
89 // and load arguments into argument registers. Integer arguments in
90 // the varargs vector will be sign-extended to 8 bytes.
91 //
92 // On entry:
93 // Z_ARG1 - intptr_t* Address of java argument list in memory.
94 // Z_state - zeroInterpreter* Address of interpreter state for
95 // this method
96 // Z_method
97 //
98 // On exit (just before return instruction):
99 // Z_RET contains the address of the result_handler.
100 // Z_ARG2 is not updated for static methods and contains "this" otherwise.
101 // Z_ARG3-Z_ARG5 contain the first 3 arguments of types other than float and double.
102 // Z_FARG1-Z_FARG4 contain the first 4 arguments of type float or double.
103
104 const int LogSizeOfCase = 3;
105
106 const int max_fp_register_arguments = Argument::n_float_register_parameters;
107 const int max_int_register_arguments = Argument::n_register_parameters - 2; // First 2 are reserved.
108
109 const Register arg_java = Z_tmp_2;
110 const Register arg_c = Z_tmp_3;
111 const Register signature = Z_R1_scratch; // Is a string.
112 const Register fpcnt = Z_R0_scratch;
113 const Register argcnt = Z_tmp_4;
114 const Register intSlot = Z_tmp_1;
115 const Register sig_end = Z_tmp_1; // Assumed end of signature (only used in do_object).
116 const Register target_sp = Z_tmp_1;
117 const FloatRegister floatSlot = Z_F1;
118
119 const int d_signature = _z_abi(gpr6); // Only spill space, register contents not affected.
120 const int d_fpcnt = _z_abi(gpr7); // Only spill space, register contents not affected.
121
122 unsigned int entry_offset = __ offset();
123
124 BLOCK_COMMENT("slow_signature_handler {");
125
126 // We use target_sp for storing arguments in the C frame.
127 __ save_return_pc();
128 __ push_frame_abi160(4*BytesPerWord); // Reserve space to save the tmp_[1..4] registers.
129 __ z_stmg(Z_R10, Z_R13, frame::z_abi_160_size, Z_SP); // Save registers only after frame is pushed.
130
131 __ z_lgr(arg_java, Z_ARG1);
132
133 Register method = Z_ARG2; // Directly load into correct argument register.
134
135 __ get_method(method);
136 __ call_VM_leaf(CAST_FROM_FN_PTR(address, InterpreterRuntime::get_signature), Z_thread, method);
137
138 // Move signature to callee saved register.
139 // Don't directly write to stack. Frame is used by VM call.
140 __ z_lgr(Z_tmp_1, Z_RET);
141
142 // Reload method. Register may have been altered by VM call.
143 __ get_method(method);
144
145 // Get address of result handler.
146 __ call_VM_leaf(CAST_FROM_FN_PTR(address, InterpreterRuntime::get_result_handler), Z_thread, method);
147
148 // Save signature address to stack.
149 __ z_stg(Z_tmp_1, d_signature, Z_SP);
150
151 // Don't overwrite return value (Z_RET, Z_ARG1) in rest of the method !
152
153 {
154 Label isStatic;
155
156 // Test if static.
157 // We can test the bit directly.
158 // Path is Z_method->_access_flags._flags.
159 // We only support flag bits in the least significant byte (assert !).
160 // Therefore add 3 to address that byte within "_flags".
161 // Reload method. VM call above may have destroyed register contents
162 __ get_method(method);
163 __ testbit(method2_(method, access_flags), JVM_ACC_STATIC_BIT);
164 method = noreg; // end of life
165 __ z_btrue(isStatic);
166
167 // For non-static functions, pass "this" in Z_ARG2 and copy it to 2nd C-arg slot.
168 // Need to box the Java object here, so we use arg_java
169 // (address of current Java stack slot) as argument and
170 // don't dereference it as in case of ints, floats, etc..
171 __ z_lgr(Z_ARG2, arg_java);
172 __ add2reg(arg_java, -BytesPerWord);
173 __ bind(isStatic);
174 }
175
176 // argcnt == 0 corresponds to 3rd C argument.
177 // arg #1 (result handler) and
178 // arg #2 (this, for non-statics), unused else
179 // are reserved and pre-filled above.
180 // arg_java points to the corresponding Java argument here. It
181 // has been decremented by one argument (this) in case of non-static.
182 __ clear_reg(argcnt, true, false); // Don't set CC.
183 __ z_lg(target_sp, 0, Z_SP);
184 __ add2reg(arg_c, _z_abi(remaining_cargs), target_sp);
185 // No floating-point args parsed so far.
186 __ clear_mem(Address(Z_SP, d_fpcnt), 8);
187
188 NearLabel move_intSlot_to_ARG, move_floatSlot_to_FARG;
189 NearLabel loop_start, loop_start_restore, loop_end;
190 NearLabel do_int, do_long, do_float, do_double;
191 NearLabel do_dontreachhere, do_object, do_array, do_boxed;
192
193 #ifdef ASSERT
194 // Signature needs to point to '(' (== 0x28) at entry.
195 __ z_lg(signature, d_signature, Z_SP);
196 __ z_cli(0, signature, (int) '(');
197 __ z_brne(do_dontreachhere);
198 #endif
199
200 __ bind(loop_start_restore);
201 __ z_lg(signature, d_signature, Z_SP); // Restore signature ptr, destroyed by move_XX_to_ARG.
202
203 BIND(loop_start);
204 // Advance to next argument type token from the signature.
205 __ add2reg(signature, 1);
206
207 // Use CLI, works well on all CPU versions.
208 __ z_cli(0, signature, (int) ')');
209 __ z_bre(loop_end); // end of signature
210 __ z_cli(0, signature, (int) 'L');
211 __ z_bre(do_object); // object #9
212 __ z_cli(0, signature, (int) 'F');
213 __ z_bre(do_float); // float #7
214 __ z_cli(0, signature, (int) 'J');
215 __ z_bre(do_long); // long #6
216 __ z_cli(0, signature, (int) 'B');
217 __ z_bre(do_int); // byte #1
218 __ z_cli(0, signature, (int) 'Z');
219 __ z_bre(do_int); // boolean #2
220 __ z_cli(0, signature, (int) 'C');
221 __ z_bre(do_int); // char #3
222 __ z_cli(0, signature, (int) 'S');
223 __ z_bre(do_int); // short #4
224 __ z_cli(0, signature, (int) 'I');
225 __ z_bre(do_int); // int #5
226 __ z_cli(0, signature, (int) 'D');
227 __ z_bre(do_double); // double #8
228 __ z_cli(0, signature, (int) '[');
229 __ z_bre(do_array); // array #10
230
231 __ bind(do_dontreachhere);
232
233 __ unimplemented("ShouldNotReachHere in slow_signature_handler", 120);
234
235 // Array argument
236 BIND(do_array);
237
238 {
239 Label start_skip, end_skip;
240
241 __ bind(start_skip);
242
243 // Advance to next type tag from signature.
244 __ add2reg(signature, 1);
245
246 // Use CLI, works well on all CPU versions.
247 __ z_cli(0, signature, (int) '[');
248 __ z_bre(start_skip); // Skip further brackets.
249
250 __ z_cli(0, signature, (int) '9');
251 __ z_brh(end_skip); // no optional size
252
253 __ z_cli(0, signature, (int) '0');
254 __ z_brnl(start_skip); // Skip optional size.
255
256 __ bind(end_skip);
257
258 __ z_cli(0, signature, (int) 'L');
259 __ z_brne(do_boxed); // If not array of objects: go directly to do_boxed.
260 }
261
262 // OOP argument
263 BIND(do_object);
264 // Pass by an object's type name.
265 {
266 Label L;
267
268 __ add2reg(sig_end, 4095, signature); // Assume object type name is shorter than 4k.
269 __ load_const_optimized(Z_R0, (int) ';'); // Type name terminator (must be in Z_R0!).
270 __ MacroAssembler::search_string(sig_end, signature);
271 __ z_brl(L);
272 __ z_illtrap(); // No semicolon found: internal error or object name too long.
273 __ bind(L);
274 __ z_lgr(signature, sig_end);
275 // fallthru to do_boxed
276 }
277
278 // Need to box the Java object here, so we use arg_java
279 // (address of current Java stack slot) as argument and
280 // don't dereference it as in case of ints, floats, etc..
281
282 // UNBOX argument
283 // Load reference and check for NULL.
284 Label do_int_Entry4Boxed;
285 __ bind(do_boxed);
286 {
287 __ load_and_test_long(intSlot, Address(arg_java));
288 __ z_bre(do_int_Entry4Boxed);
289 __ z_lgr(intSlot, arg_java);
290 __ z_bru(do_int_Entry4Boxed);
291 }
292
293 // INT argument
294
295 // (also for byte, boolean, char, short)
296 // Use lgf for load (sign-extend) and stg for store.
297 BIND(do_int);
298 __ z_lgf(intSlot, 0, arg_java);
299
300 __ bind(do_int_Entry4Boxed);
301 __ add2reg(arg_java, -BytesPerWord);
302 // If argument fits into argument register, go and handle it, otherwise continue.
303 __ compare32_and_branch(argcnt, max_int_register_arguments,
304 Assembler::bcondLow, move_intSlot_to_ARG);
305 __ z_stg(intSlot, 0, arg_c);
306 __ add2reg(arg_c, BytesPerWord);
307 __ z_bru(loop_start);
308
309 // LONG argument
310
311 BIND(do_long);
312 __ add2reg(arg_java, -2*BytesPerWord); // Decrement first to have positive displacement for lg.
313 __ z_lg(intSlot, BytesPerWord, arg_java);
314 // If argument fits into argument register, go and handle it, otherwise continue.
315 __ compare32_and_branch(argcnt, max_int_register_arguments,
316 Assembler::bcondLow, move_intSlot_to_ARG);
317 __ z_stg(intSlot, 0, arg_c);
318 __ add2reg(arg_c, BytesPerWord);
319 __ z_bru(loop_start);
320
321 // FLOAT argumen
322
323 BIND(do_float);
324 __ z_le(floatSlot, 0, arg_java);
325 __ add2reg(arg_java, -BytesPerWord);
326 assert(max_fp_register_arguments <= 255, "always true"); // safety net
327 __ z_cli(d_fpcnt+7, Z_SP, max_fp_register_arguments);
328 __ z_brl(move_floatSlot_to_FARG);
329 __ z_ste(floatSlot, 4, arg_c);
330 __ add2reg(arg_c, BytesPerWord);
331 __ z_bru(loop_start);
332
333 // DOUBLE argument
334
335 BIND(do_double);
336 __ add2reg(arg_java, -2*BytesPerWord); // Decrement first to have positive displacement for lg.
337 __ z_ld(floatSlot, BytesPerWord, arg_java);
338 assert(max_fp_register_arguments <= 255, "always true"); // safety net
339 __ z_cli(d_fpcnt+7, Z_SP, max_fp_register_arguments);
340 __ z_brl(move_floatSlot_to_FARG);
341 __ z_std(floatSlot, 0, arg_c);
342 __ add2reg(arg_c, BytesPerWord);
343 __ z_bru(loop_start);
344
345 // Method exit, all arguments proocessed.
346 __ bind(loop_end);
347 __ z_lmg(Z_R10, Z_R13, frame::z_abi_160_size, Z_SP); // restore registers before frame is popped.
348 __ pop_frame();
349 __ restore_return_pc();
350 __ z_br(Z_R14);
351
352 // Copy int arguments.
353
354 Label iarg_caselist; // Distance between each case has to be a power of 2
355 // (= 1 << LogSizeOfCase).
356 __ align(16);
357 BIND(iarg_caselist);
358 __ z_lgr(Z_ARG3, intSlot); // 4 bytes
359 __ z_bru(loop_start_restore); // 4 bytes
360
361 __ z_lgr(Z_ARG4, intSlot);
362 __ z_bru(loop_start_restore);
363
364 __ z_lgr(Z_ARG5, intSlot);
365 __ z_bru(loop_start_restore);
366
367 __ align(16);
368 __ bind(move_intSlot_to_ARG);
369 __ z_stg(signature, d_signature, Z_SP); // Spill since signature == Z_R1_scratch.
370 __ z_larl(Z_R1_scratch, iarg_caselist);
371 __ z_sllg(Z_R0_scratch, argcnt, LogSizeOfCase);
372 __ add2reg(argcnt, 1);
373 __ z_agr(Z_R1_scratch, Z_R0_scratch);
374 __ z_bcr(Assembler::bcondAlways, Z_R1_scratch);
375
376 // Copy float arguments.
377
378 Label farg_caselist; // Distance between each case has to be a power of 2
379 // (= 1 << logSizeOfCase, padded with nop.
380 __ align(16);
381 BIND(farg_caselist);
382 __ z_ldr(Z_FARG1, floatSlot); // 2 bytes
383 __ z_bru(loop_start_restore); // 4 bytes
384 __ z_nop(); // 2 bytes
385
386 __ z_ldr(Z_FARG2, floatSlot);
387 __ z_bru(loop_start_restore);
388 __ z_nop();
389
390 __ z_ldr(Z_FARG3, floatSlot);
391 __ z_bru(loop_start_restore);
392 __ z_nop();
393
394 __ z_ldr(Z_FARG4, floatSlot);
395 __ z_bru(loop_start_restore);
396 __ z_nop();
397
398 __ align(16);
399 __ bind(move_floatSlot_to_FARG);
400 __ z_stg(signature, d_signature, Z_SP); // Spill since signature == Z_R1_scratch.
401 __ z_lg(Z_R0_scratch, d_fpcnt, Z_SP); // Need old value for indexing.
402 __ add2mem_64(Address(Z_SP, d_fpcnt), 1, Z_R1_scratch); // Increment index.
403 __ z_larl(Z_R1_scratch, farg_caselist);
404 __ z_sllg(Z_R0_scratch, Z_R0_scratch, LogSizeOfCase);
405 __ z_agr(Z_R1_scratch, Z_R0_scratch);
406 __ z_bcr(Assembler::bcondAlways, Z_R1_scratch);
407
408 BLOCK_COMMENT("} slow_signature_handler");
409
410 return __ addr_at(entry_offset);
411 }
412
generate_result_handler_for(BasicType type)413 address TemplateInterpreterGenerator::generate_result_handler_for (BasicType type) {
414 address entry = __ pc();
415
416 assert(Z_tos == Z_RET, "Result handler: must move result!");
417 assert(Z_ftos == Z_FRET, "Result handler: must move float result!");
418
419 switch (type) {
420 case T_BOOLEAN:
421 __ c2bool(Z_tos);
422 break;
423 case T_CHAR:
424 __ and_imm(Z_tos, 0xffff);
425 break;
426 case T_BYTE:
427 __ z_lbr(Z_tos, Z_tos);
428 break;
429 case T_SHORT:
430 __ z_lhr(Z_tos, Z_tos);
431 break;
432 case T_INT:
433 case T_LONG:
434 case T_VOID:
435 case T_FLOAT:
436 case T_DOUBLE:
437 break;
438 case T_OBJECT:
439 // Retrieve result from frame...
440 __ mem2reg_opt(Z_tos, Address(Z_fp, oop_tmp_offset));
441 // and verify it.
442 __ verify_oop(Z_tos);
443 break;
444 default:
445 ShouldNotReachHere();
446 }
447 __ z_br(Z_R14); // Return from result handler.
448 return entry;
449 }
450
451 // Abstract method entry.
452 // Attempt to execute abstract method. Throw exception.
generate_abstract_entry(void)453 address TemplateInterpreterGenerator::generate_abstract_entry(void) {
454 unsigned int entry_offset = __ offset();
455
456 // Caller could be the call_stub or a compiled method (x86 version is wrong!).
457
458 BLOCK_COMMENT("abstract_entry {");
459
460 // Implement call of InterpreterRuntime::throw_AbstractMethodError.
461 __ set_top_ijava_frame_at_SP_as_last_Java_frame(Z_SP, Z_R1);
462 __ save_return_pc(); // Save Z_R14.
463 __ push_frame_abi160(0); // Without new frame the RT call could overwrite the saved Z_R14.
464
465 __ call_VM_leaf(CAST_FROM_FN_PTR(address, InterpreterRuntime::throw_AbstractMethodErrorWithMethod),
466 Z_thread, Z_method);
467
468 __ pop_frame();
469 __ restore_return_pc(); // Restore Z_R14.
470 __ reset_last_Java_frame();
471
472 // Restore caller sp for c2i case.
473 __ resize_frame_absolute(Z_R10, Z_R0, true); // Cut the stack back to where the caller started.
474
475 // branch to SharedRuntime::generate_forward_exception() which handles all possible callers,
476 // i.e. call stub, compiled method, interpreted method.
477 __ load_absolute_address(Z_tmp_1, StubRoutines::forward_exception_entry());
478 __ z_br(Z_tmp_1);
479
480 BLOCK_COMMENT("} abstract_entry");
481
482 return __ addr_at(entry_offset);
483 }
484
generate_Reference_get_entry(void)485 address TemplateInterpreterGenerator::generate_Reference_get_entry(void) {
486 // Inputs:
487 // Z_ARG1 - receiver
488 //
489 // What we do:
490 // - Load the referent field address.
491 // - Load the value in the referent field.
492 // - Pass that value to the pre-barrier.
493 //
494 // In the case of G1 this will record the value of the
495 // referent in an SATB buffer if marking is active.
496 // This will cause concurrent marking to mark the referent
497 // field as live.
498
499 Register scratch1 = Z_tmp_2;
500 Register scratch2 = Z_tmp_3;
501 Register pre_val = Z_RET; // return value
502 // Z_esp is callers operand stack pointer, i.e. it points to the parameters.
503 Register Rargp = Z_esp;
504
505 Label slow_path;
506 address entry = __ pc();
507
508 const int referent_offset = java_lang_ref_Reference::referent_offset();
509
510 BLOCK_COMMENT("Reference_get {");
511
512 // If the receiver is null then it is OK to jump to the slow path.
513 __ load_and_test_long(pre_val, Address(Rargp, Interpreter::stackElementSize)); // Get receiver.
514 __ z_bre(slow_path);
515
516 // Load the value of the referent field.
517 __ load_heap_oop(pre_val, Address(pre_val, referent_offset), scratch1, scratch2, ON_WEAK_OOP_REF);
518
519 // Restore caller sp for c2i case.
520 __ resize_frame_absolute(Z_R10, Z_R0, true); // Cut the stack back to where the caller started.
521 __ z_br(Z_R14);
522
523 // Branch to previously generated regular method entry.
524 __ bind(slow_path);
525
526 address meth_entry = Interpreter::entry_for_kind(Interpreter::zerolocals);
527 __ jump_to_entry(meth_entry, Z_R1);
528
529 BLOCK_COMMENT("} Reference_get");
530
531 return entry;
532 }
533
generate_StackOverflowError_handler()534 address TemplateInterpreterGenerator::generate_StackOverflowError_handler() {
535 address entry = __ pc();
536
537 DEBUG_ONLY(__ verify_esp(Z_esp, Z_ARG5));
538
539 // Restore bcp under the assumption that the current frame is still
540 // interpreted.
541 __ restore_bcp();
542
543 // Expression stack must be empty before entering the VM if an
544 // exception happened.
545 __ empty_expression_stack();
546 // Throw exception.
547 __ call_VM(noreg,
548 CAST_FROM_FN_PTR(address, InterpreterRuntime::throw_StackOverflowError));
549 return entry;
550 }
551
552 //
553 // Args:
554 // Z_ARG2: oop of array
555 // Z_ARG3: aberrant index
556 //
generate_ArrayIndexOutOfBounds_handler()557 address TemplateInterpreterGenerator::generate_ArrayIndexOutOfBounds_handler() {
558 address entry = __ pc();
559 address excp = CAST_FROM_FN_PTR(address, InterpreterRuntime::throw_ArrayIndexOutOfBoundsException);
560
561 // Expression stack must be empty before entering the VM if an
562 // exception happened.
563 __ empty_expression_stack();
564
565 // Setup parameters.
566 // Pass register with array to create more detailed exceptions.
567 __ call_VM(noreg, excp, Z_ARG2, Z_ARG3);
568 return entry;
569 }
570
generate_ClassCastException_handler()571 address TemplateInterpreterGenerator::generate_ClassCastException_handler() {
572 address entry = __ pc();
573
574 // Object is at TOS.
575 __ pop_ptr(Z_ARG2);
576
577 // Expression stack must be empty before entering the VM if an
578 // exception happened.
579 __ empty_expression_stack();
580
581 __ call_VM(Z_ARG1,
582 CAST_FROM_FN_PTR(address, InterpreterRuntime::throw_ClassCastException),
583 Z_ARG2);
584
585 DEBUG_ONLY(__ should_not_reach_here();)
586
587 return entry;
588 }
589
generate_exception_handler_common(const char * name,const char * message,bool pass_oop)590 address TemplateInterpreterGenerator::generate_exception_handler_common(const char* name, const char* message, bool pass_oop) {
591 assert(!pass_oop || message == NULL, "either oop or message but not both");
592 address entry = __ pc();
593
594 BLOCK_COMMENT("exception_handler_common {");
595
596 // Expression stack must be empty before entering the VM if an
597 // exception happened.
598 __ empty_expression_stack();
599 if (name != NULL) {
600 __ load_absolute_address(Z_ARG2, (address)name);
601 } else {
602 __ clear_reg(Z_ARG2, true, false);
603 }
604
605 if (pass_oop) {
606 __ call_VM(Z_tos,
607 CAST_FROM_FN_PTR(address, InterpreterRuntime::create_klass_exception),
608 Z_ARG2, Z_tos /*object (see TT::aastore())*/);
609 } else {
610 if (message != NULL) {
611 __ load_absolute_address(Z_ARG3, (address)message);
612 } else {
613 __ clear_reg(Z_ARG3, true, false);
614 }
615 __ call_VM(Z_tos,
616 CAST_FROM_FN_PTR(address, InterpreterRuntime::create_exception),
617 Z_ARG2, Z_ARG3);
618 }
619 // Throw exception.
620 __ load_absolute_address(Z_R1_scratch, Interpreter::throw_exception_entry());
621 __ z_br(Z_R1_scratch);
622
623 BLOCK_COMMENT("} exception_handler_common");
624
625 return entry;
626 }
627
generate_return_entry_for(TosState state,int step,size_t index_size)628 address TemplateInterpreterGenerator::generate_return_entry_for (TosState state, int step, size_t index_size) {
629 address entry = __ pc();
630
631 BLOCK_COMMENT("return_entry {");
632
633 // Pop i2c extension or revert top-2-parent-resize done by interpreted callees.
634 Register sp_before_i2c_extension = Z_bcp;
635 __ z_lg(Z_fp, _z_abi(callers_sp), Z_SP); // Restore frame pointer.
636 __ z_lg(sp_before_i2c_extension, Address(Z_fp, _z_ijava_state_neg(top_frame_sp)));
637 __ resize_frame_absolute(sp_before_i2c_extension, Z_locals/*tmp*/, true/*load_fp*/);
638
639 // TODO(ZASM): necessary??
640 // // and NULL it as marker that esp is now tos until next java call
641 // __ movptr(Address(rbp, frame::interpreter_frame_last_sp_offset * wordSize), (int32_t)NULL_WORD);
642
643 __ restore_bcp();
644 __ restore_locals();
645 __ restore_esp();
646
647 if (state == atos) {
648 __ profile_return_type(Z_tmp_1, Z_tos, Z_tmp_2);
649 }
650
651 Register cache = Z_tmp_1;
652 Register size = Z_tmp_1;
653 Register offset = Z_tmp_2;
654 const int flags_offset = in_bytes(ConstantPoolCache::base_offset() +
655 ConstantPoolCacheEntry::flags_offset());
656 __ get_cache_and_index_at_bcp(cache, offset, 1, index_size);
657
658 // #args is in rightmost byte of the _flags field.
659 __ z_llgc(size, Address(cache, offset, flags_offset+(sizeof(size_t)-1)));
660 __ z_sllg(size, size, Interpreter::logStackElementSize); // Each argument size in bytes.
661 __ z_agr(Z_esp, size); // Pop arguments.
662
663 __ check_and_handle_popframe(Z_thread);
664 __ check_and_handle_earlyret(Z_thread);
665
666 __ dispatch_next(state, step);
667
668 BLOCK_COMMENT("} return_entry");
669
670 return entry;
671 }
672
generate_deopt_entry_for(TosState state,int step,address continuation)673 address TemplateInterpreterGenerator::generate_deopt_entry_for(TosState state,
674 int step,
675 address continuation) {
676 address entry = __ pc();
677
678 BLOCK_COMMENT("deopt_entry {");
679
680 // TODO(ZASM): necessary? NULL last_sp until next java call
681 // __ movptr(Address(rbp, frame::interpreter_frame_last_sp_offset * wordSize), (int32_t)NULL_WORD);
682 __ z_lg(Z_fp, _z_abi(callers_sp), Z_SP); // Restore frame pointer.
683 __ restore_bcp();
684 __ restore_locals();
685 __ restore_esp();
686
687 // Handle exceptions.
688 {
689 Label L;
690 __ load_and_test_long(Z_R0/*pending_exception*/, thread_(pending_exception));
691 __ z_bre(L);
692 __ call_VM(noreg,
693 CAST_FROM_FN_PTR(address,
694 InterpreterRuntime::throw_pending_exception));
695 __ should_not_reach_here();
696 __ bind(L);
697 }
698 if (continuation == NULL) {
699 __ dispatch_next(state, step);
700 } else {
701 __ jump_to_entry(continuation, Z_R1_scratch);
702 }
703
704 BLOCK_COMMENT("} deopt_entry");
705
706 return entry;
707 }
708
generate_safept_entry_for(TosState state,address runtime_entry)709 address TemplateInterpreterGenerator::generate_safept_entry_for (TosState state,
710 address runtime_entry) {
711 address entry = __ pc();
712 __ push(state);
713 __ call_VM(noreg, runtime_entry);
714 __ dispatch_via(vtos, Interpreter::_normal_table.table_for (vtos));
715 return entry;
716 }
717
718 //
719 // Helpers for commoning out cases in the various type of method entries.
720 //
721
722 // Increment invocation count & check for overflow.
723 //
724 // Note: checking for negative value instead of overflow
725 // so we have a 'sticky' overflow test.
726 //
727 // Z_ARG2: method (see generate_fixed_frame())
728 //
generate_counter_incr(Label * overflow)729 void TemplateInterpreterGenerator::generate_counter_incr(Label* overflow) {
730 Label done;
731 Register method = Z_ARG2; // Generate_fixed_frame() copies Z_method into Z_ARG2.
732 Register m_counters = Z_ARG4;
733
734 BLOCK_COMMENT("counter_incr {");
735
736 // Note: In tiered we increment either counters in method or in MDO depending
737 // if we are profiling or not.
738 int increment = InvocationCounter::count_increment;
739 if (ProfileInterpreter) {
740 NearLabel no_mdo;
741 Register mdo = m_counters;
742 // Are we profiling?
743 __ load_and_test_long(mdo, method2_(method, method_data));
744 __ branch_optimized(Assembler::bcondZero, no_mdo);
745 // Increment counter in the MDO.
746 const Address mdo_invocation_counter(mdo, MethodData::invocation_counter_offset() +
747 InvocationCounter::counter_offset());
748 const Address mask(mdo, MethodData::invoke_mask_offset());
749 __ increment_mask_and_jump(mdo_invocation_counter, increment, mask,
750 Z_R1_scratch, false, Assembler::bcondZero,
751 overflow);
752 __ z_bru(done);
753 __ bind(no_mdo);
754 }
755
756 // Increment counter in MethodCounters.
757 const Address invocation_counter(m_counters,
758 MethodCounters::invocation_counter_offset() +
759 InvocationCounter::counter_offset());
760 // Get address of MethodCounters object.
761 __ get_method_counters(method, m_counters, done);
762 const Address mask(m_counters, MethodCounters::invoke_mask_offset());
763 __ increment_mask_and_jump(invocation_counter,
764 increment, mask,
765 Z_R1_scratch, false, Assembler::bcondZero,
766 overflow);
767
768 __ bind(done);
769
770 BLOCK_COMMENT("} counter_incr");
771 }
772
generate_counter_overflow(Label & do_continue)773 void TemplateInterpreterGenerator::generate_counter_overflow(Label& do_continue) {
774 // InterpreterRuntime::frequency_counter_overflow takes two
775 // arguments, the first (thread) is passed by call_VM, the second
776 // indicates if the counter overflow occurs at a backwards branch
777 // (NULL bcp). We pass zero for it. The call returns the address
778 // of the verified entry point for the method or NULL if the
779 // compilation did not complete (either went background or bailed
780 // out).
781 __ clear_reg(Z_ARG2);
782 __ call_VM(noreg,
783 CAST_FROM_FN_PTR(address, InterpreterRuntime::frequency_counter_overflow),
784 Z_ARG2);
785 __ z_bru(do_continue);
786 }
787
generate_stack_overflow_check(Register frame_size,Register tmp1)788 void TemplateInterpreterGenerator::generate_stack_overflow_check(Register frame_size, Register tmp1) {
789 Register tmp2 = Z_R1_scratch;
790 const int page_size = os::vm_page_size();
791 NearLabel after_frame_check;
792
793 BLOCK_COMMENT("stack_overflow_check {");
794
795 assert_different_registers(frame_size, tmp1);
796
797 // Stack banging is sufficient overflow check if frame_size < page_size.
798 if (Immediate::is_uimm(page_size, 15)) {
799 __ z_chi(frame_size, page_size);
800 __ z_brl(after_frame_check);
801 } else {
802 __ load_const_optimized(tmp1, page_size);
803 __ compareU32_and_branch(frame_size, tmp1, Assembler::bcondLow, after_frame_check);
804 }
805
806 // Get the stack base, and in debug, verify it is non-zero.
807 __ z_lg(tmp1, thread_(stack_base));
808 #ifdef ASSERT
809 address reentry = NULL;
810 NearLabel base_not_zero;
811 __ compareU64_and_branch(tmp1, (intptr_t)0L, Assembler::bcondNotEqual, base_not_zero);
812 reentry = __ stop_chain_static(reentry, "stack base is zero in generate_stack_overflow_check");
813 __ bind(base_not_zero);
814 #endif
815
816 // Get the stack size, and in debug, verify it is non-zero.
817 assert(sizeof(size_t) == sizeof(intptr_t), "wrong load size");
818 __ z_lg(tmp2, thread_(stack_size));
819 #ifdef ASSERT
820 NearLabel size_not_zero;
821 __ compareU64_and_branch(tmp2, (intptr_t)0L, Assembler::bcondNotEqual, size_not_zero);
822 reentry = __ stop_chain_static(reentry, "stack size is zero in generate_stack_overflow_check");
823 __ bind(size_not_zero);
824 #endif
825
826 // Compute the beginning of the protected zone minus the requested frame size.
827 __ z_sgr(tmp1, tmp2);
828 __ add2reg(tmp1, StackOverflow::stack_guard_zone_size());
829
830 // Add in the size of the frame (which is the same as subtracting it from the
831 // SP, which would take another register.
832 __ z_agr(tmp1, frame_size);
833
834 // The frame is greater than one page in size, so check against
835 // the bottom of the stack.
836 __ compareU64_and_branch(Z_SP, tmp1, Assembler::bcondHigh, after_frame_check);
837
838 // The stack will overflow, throw an exception.
839
840 // Restore SP to sender's sp. This is necessary if the sender's frame is an
841 // extended compiled frame (see gen_c2i_adapter()) and safer anyway in case of
842 // JSR292 adaptations.
843 __ resize_frame_absolute(Z_R10, tmp1, true/*load_fp*/);
844
845 // Note also that the restored frame is not necessarily interpreted.
846 // Use the shared runtime version of the StackOverflowError.
847 assert(StubRoutines::throw_StackOverflowError_entry() != NULL, "stub not yet generated");
848 AddressLiteral stub(StubRoutines::throw_StackOverflowError_entry());
849 __ load_absolute_address(tmp1, StubRoutines::throw_StackOverflowError_entry());
850 __ z_br(tmp1);
851
852 // If you get to here, then there is enough stack space.
853 __ bind(after_frame_check);
854
855 BLOCK_COMMENT("} stack_overflow_check");
856 }
857
858 // Allocate monitor and lock method (asm interpreter).
859 //
860 // Args:
861 // Z_locals: locals
862
lock_method(void)863 void TemplateInterpreterGenerator::lock_method(void) {
864
865 BLOCK_COMMENT("lock_method {");
866
867 // Synchronize method.
868 const Register method = Z_tmp_2;
869 __ get_method(method);
870
871 #ifdef ASSERT
872 address reentry = NULL;
873 {
874 Label L;
875 __ testbit(method2_(method, access_flags), JVM_ACC_SYNCHRONIZED_BIT);
876 __ z_btrue(L);
877 reentry = __ stop_chain_static(reentry, "method doesn't need synchronization");
878 __ bind(L);
879 }
880 #endif // ASSERT
881
882 // Get synchronization object.
883 const Register object = Z_tmp_2;
884
885 {
886 Label done;
887 Label static_method;
888
889 __ testbit(method2_(method, access_flags), JVM_ACC_STATIC_BIT);
890 __ z_btrue(static_method);
891
892 // non-static method: Load receiver obj from stack.
893 __ mem2reg_opt(object, Address(Z_locals, Interpreter::local_offset_in_bytes(0)));
894 __ z_bru(done);
895
896 __ bind(static_method);
897
898 // Lock the java mirror.
899 // Load mirror from interpreter frame.
900 __ z_lg(object, _z_ijava_state_neg(mirror), Z_fp);
901
902 #ifdef ASSERT
903 {
904 NearLabel L;
905 __ compare64_and_branch(object, (intptr_t) 0, Assembler::bcondNotEqual, L);
906 reentry = __ stop_chain_static(reentry, "synchronization object is NULL");
907 __ bind(L);
908 }
909 #endif // ASSERT
910
911 __ bind(done);
912 }
913
914 __ add_monitor_to_stack(true, Z_ARG3, Z_ARG4, Z_ARG5); // Allocate monitor elem.
915 // Store object and lock it.
916 __ get_monitors(Z_tmp_1);
917 __ reg2mem_opt(object, Address(Z_tmp_1, BasicObjectLock::obj_offset_in_bytes()));
918 __ lock_object(Z_tmp_1, object);
919
920 BLOCK_COMMENT("} lock_method");
921 }
922
923 // Generate a fixed interpreter frame. This is identical setup for
924 // interpreted methods and for native methods hence the shared code.
925 //
926 // Registers alive
927 // Z_thread - JavaThread*
928 // Z_SP - old stack pointer
929 // Z_method - callee's method
930 // Z_esp - parameter list (slot 'above' last param)
931 // Z_R14 - return pc, to be stored in caller's frame
932 // Z_R10 - sender sp, note: Z_tmp_1 is Z_R10!
933 //
934 // Registers updated
935 // Z_SP - new stack pointer
936 // Z_esp - callee's operand stack pointer
937 // points to the slot above the value on top
938 // Z_locals - used to access locals: locals[i] := *(Z_locals - i*BytesPerWord)
939 // Z_bcp - the bytecode pointer
940 // Z_fp - the frame pointer, thereby killing Z_method
941 // Z_ARG2 - copy of Z_method
942 //
generate_fixed_frame(bool native_call)943 void TemplateInterpreterGenerator::generate_fixed_frame(bool native_call) {
944
945 // stack layout
946 //
947 // F1 [TOP_IJAVA_FRAME_ABI] <-- Z_SP, Z_R10 (see note below)
948 // [F1's operand stack (unused)]
949 // [F1's outgoing Java arguments] <-- Z_esp
950 // [F1's operand stack (non args)]
951 // [monitors] (optional)
952 // [IJAVA_STATE]
953 //
954 // F2 [PARENT_IJAVA_FRAME_ABI]
955 // ...
956 //
957 // 0x000
958 //
959 // Note: Z_R10, the sender sp, will be below Z_SP if F1 was extended by a c2i adapter.
960
961 //=============================================================================
962 // Allocate space for locals other than the parameters, the
963 // interpreter state, monitors, and the expression stack.
964
965 const Register local_count = Z_ARG5;
966 const Register fp = Z_tmp_2;
967 const Register const_method = Z_ARG1;
968
969 BLOCK_COMMENT("generate_fixed_frame {");
970 {
971 // local registers
972 const Register top_frame_size = Z_ARG2;
973 const Register sp_after_resize = Z_ARG3;
974 const Register max_stack = Z_ARG4;
975
976 __ z_lg(const_method, Address(Z_method, Method::const_offset()));
977 __ z_llgh(max_stack, Address(const_method, ConstMethod::size_of_parameters_offset()));
978 __ z_sllg(Z_locals /*parameter_count bytes*/, max_stack /*parameter_count*/, LogBytesPerWord);
979
980 if (native_call) {
981 // If we're calling a native method, we replace max_stack (which is
982 // zero) with space for the worst-case signature handler varargs
983 // vector, which is:
984 // max_stack = max(Argument::n_register_parameters, parameter_count+2);
985 //
986 // We add two slots to the parameter_count, one for the jni
987 // environment and one for a possible native mirror. We allocate
988 // space for at least the number of ABI registers, even though
989 // InterpreterRuntime::slow_signature_handler won't write more than
990 // parameter_count+2 words when it creates the varargs vector at the
991 // top of the stack. The generated slow signature handler will just
992 // load trash into registers beyond the necessary number. We're
993 // still going to cut the stack back by the ABI register parameter
994 // count so as to get SP+16 pointing at the ABI outgoing parameter
995 // area, so we need to allocate at least that much even though we're
996 // going to throw it away.
997 //
998 __ add2reg(max_stack, 2);
999
1000 NearLabel passing_args_on_stack;
1001
1002 // max_stack in bytes
1003 __ z_sllg(max_stack, max_stack, LogBytesPerWord);
1004
1005 int argument_registers_in_bytes = Argument::n_register_parameters << LogBytesPerWord;
1006 __ compare64_and_branch(max_stack, argument_registers_in_bytes, Assembler::bcondNotLow, passing_args_on_stack);
1007
1008 __ load_const_optimized(max_stack, argument_registers_in_bytes);
1009
1010 __ bind(passing_args_on_stack);
1011 } else {
1012 // !native_call
1013 // local_count = method->constMethod->max_locals();
1014 __ z_llgh(local_count, Address(const_method, ConstMethod::size_of_locals_offset()));
1015
1016 // Calculate number of non-parameter locals (in slots):
1017 __ z_sgr(local_count, max_stack);
1018
1019 // max_stack = method->max_stack();
1020 __ z_llgh(max_stack, Address(const_method, ConstMethod::max_stack_offset()));
1021 // max_stack in bytes
1022 __ z_sllg(max_stack, max_stack, LogBytesPerWord);
1023 }
1024
1025 // Resize (i.e. normally shrink) the top frame F1 ...
1026 // F1 [TOP_IJAVA_FRAME_ABI] <-- Z_SP, Z_R10
1027 // F1's operand stack (free)
1028 // ...
1029 // F1's operand stack (free) <-- Z_esp
1030 // F1's outgoing Java arg m
1031 // ...
1032 // F1's outgoing Java arg 0
1033 // ...
1034 //
1035 // ... into a parent frame (Z_R10 holds F1's SP before any modification, see also above)
1036 //
1037 // +......................+
1038 // : : <-- Z_R10, saved below as F0's z_ijava_state.sender_sp
1039 // : :
1040 // F1 [PARENT_IJAVA_FRAME_ABI] <-- Z_SP \
1041 // F0's non arg local | = delta
1042 // ... |
1043 // F0's non arg local <-- Z_esp /
1044 // F1's outgoing Java arg m
1045 // ...
1046 // F1's outgoing Java arg 0
1047 // ...
1048 //
1049 // then push the new top frame F0.
1050 //
1051 // F0 [TOP_IJAVA_FRAME_ABI] = frame::z_top_ijava_frame_abi_size \
1052 // [operand stack] = max_stack | = top_frame_size
1053 // [IJAVA_STATE] = frame::z_ijava_state_size /
1054
1055 // sp_after_resize = Z_esp - delta
1056 //
1057 // delta = PARENT_IJAVA_FRAME_ABI + (locals_count - params_count)
1058
1059 __ add2reg(sp_after_resize, (Interpreter::stackElementSize) - (frame::z_parent_ijava_frame_abi_size), Z_esp);
1060 if (!native_call) {
1061 __ z_sllg(Z_R0_scratch, local_count, LogBytesPerWord); // Params have already been subtracted from local_count.
1062 __ z_slgr(sp_after_resize, Z_R0_scratch);
1063 }
1064
1065 // top_frame_size = TOP_IJAVA_FRAME_ABI + max_stack + size of interpreter state
1066 __ add2reg(top_frame_size,
1067 frame::z_top_ijava_frame_abi_size +
1068 frame::z_ijava_state_size,
1069 max_stack);
1070
1071 if (!native_call) {
1072 // Stack overflow check.
1073 // Native calls don't need the stack size check since they have no
1074 // expression stack and the arguments are already on the stack and
1075 // we only add a handful of words to the stack.
1076 Register frame_size = max_stack; // Reuse the register for max_stack.
1077 __ z_lgr(frame_size, Z_SP);
1078 __ z_sgr(frame_size, sp_after_resize);
1079 __ z_agr(frame_size, top_frame_size);
1080 generate_stack_overflow_check(frame_size, fp/*tmp1*/);
1081 }
1082
1083 DEBUG_ONLY(__ z_cg(Z_R14, _z_abi16(return_pc), Z_SP));
1084 __ asm_assert_eq("killed Z_R14", 0);
1085 __ resize_frame_absolute(sp_after_resize, fp, true);
1086 __ save_return_pc(Z_R14);
1087
1088 // ... and push the new frame F0.
1089 __ push_frame(top_frame_size, fp, true /*copy_sp*/, false);
1090 }
1091
1092 //=============================================================================
1093 // Initialize the new frame F0: initialize interpreter state.
1094
1095 {
1096 // locals
1097 const Register local_addr = Z_ARG4;
1098
1099 BLOCK_COMMENT("generate_fixed_frame: initialize interpreter state {");
1100
1101 #ifdef ASSERT
1102 // Set the magic number (using local_addr as tmp register).
1103 __ load_const_optimized(local_addr, frame::z_istate_magic_number);
1104 __ z_stg(local_addr, _z_ijava_state_neg(magic), fp);
1105 #endif
1106
1107 // Save sender SP from F1 (i.e. before it was potentially modified by an
1108 // adapter) into F0's interpreter state. We use it as well to revert
1109 // resizing the frame above.
1110 __ z_stg(Z_R10, _z_ijava_state_neg(sender_sp), fp);
1111
1112 // Load cp cache and save it at the end of this block.
1113 __ z_lg(Z_R1_scratch, Address(const_method, ConstMethod::constants_offset()));
1114 __ z_lg(Z_R1_scratch, Address(Z_R1_scratch, ConstantPool::cache_offset_in_bytes()));
1115
1116 // z_ijava_state->method = method;
1117 __ z_stg(Z_method, _z_ijava_state_neg(method), fp);
1118
1119 // Point locals at the first argument. Method's locals are the
1120 // parameters on top of caller's expression stack.
1121 // Tos points past last Java argument.
1122
1123 __ z_agr(Z_locals, Z_esp);
1124 // z_ijava_state->locals - i*BytesPerWord points to i-th Java local (i starts at 0)
1125 // z_ijava_state->locals = Z_esp + parameter_count bytes
1126 __ z_stg(Z_locals, _z_ijava_state_neg(locals), fp);
1127
1128 // z_ijava_state->oop_temp = NULL;
1129 __ store_const(Address(fp, oop_tmp_offset), 0);
1130
1131 // Initialize z_ijava_state->mdx.
1132 Register Rmdp = Z_bcp;
1133 // native_call: assert that mdo == NULL
1134 const bool check_for_mdo = !native_call DEBUG_ONLY(|| native_call);
1135 if (ProfileInterpreter && check_for_mdo) {
1136 Label get_continue;
1137
1138 __ load_and_test_long(Rmdp, method_(method_data));
1139 __ z_brz(get_continue);
1140 DEBUG_ONLY(if (native_call) __ stop("native methods don't have a mdo"));
1141 __ add2reg(Rmdp, in_bytes(MethodData::data_offset()));
1142 __ bind(get_continue);
1143 }
1144 __ z_stg(Rmdp, _z_ijava_state_neg(mdx), fp);
1145
1146 // Initialize z_ijava_state->bcp and Z_bcp.
1147 if (native_call) {
1148 __ clear_reg(Z_bcp); // Must initialize. Will get written into frame where GC reads it.
1149 } else {
1150 __ add2reg(Z_bcp, in_bytes(ConstMethod::codes_offset()), const_method);
1151 }
1152 __ z_stg(Z_bcp, _z_ijava_state_neg(bcp), fp);
1153
1154 // no monitors and empty operand stack
1155 // => z_ijava_state->monitors points to the top slot in IJAVA_STATE.
1156 // => Z_ijava_state->esp points one slot above into the operand stack.
1157 // z_ijava_state->monitors = fp - frame::z_ijava_state_size - Interpreter::stackElementSize;
1158 // z_ijava_state->esp = Z_esp = z_ijava_state->monitors;
1159 __ add2reg(Z_esp, -frame::z_ijava_state_size, fp);
1160 __ z_stg(Z_esp, _z_ijava_state_neg(monitors), fp);
1161 __ add2reg(Z_esp, -Interpreter::stackElementSize);
1162 __ z_stg(Z_esp, _z_ijava_state_neg(esp), fp);
1163
1164 // z_ijava_state->cpoolCache = Z_R1_scratch (see load above);
1165 __ z_stg(Z_R1_scratch, _z_ijava_state_neg(cpoolCache), fp);
1166
1167 // Get mirror and store it in the frame as GC root for this Method*.
1168 __ load_mirror_from_const_method(Z_R1_scratch, const_method);
1169 __ z_stg(Z_R1_scratch, _z_ijava_state_neg(mirror), fp);
1170
1171 BLOCK_COMMENT("} generate_fixed_frame: initialize interpreter state");
1172
1173 //=============================================================================
1174 if (!native_call) {
1175 // Local_count is already num_locals_slots - num_param_slots.
1176 // Start of locals: local_addr = Z_locals - locals size + 1 slot
1177 __ z_llgh(Z_R0_scratch, Address(const_method, ConstMethod::size_of_locals_offset()));
1178 __ add2reg(local_addr, BytesPerWord, Z_locals);
1179 __ z_sllg(Z_R0_scratch, Z_R0_scratch, LogBytesPerWord);
1180 __ z_sgr(local_addr, Z_R0_scratch);
1181
1182 __ Clear_Array(local_count, local_addr, Z_ARG2);
1183 }
1184
1185 }
1186 // Finally set the frame pointer, destroying Z_method.
1187 assert(Z_fp == Z_method, "maybe set Z_fp earlier if other register than Z_method");
1188 // Oprofile analysis suggests to keep a copy in a register to be used by
1189 // generate_counter_incr().
1190 __ z_lgr(Z_ARG2, Z_method);
1191 __ z_lgr(Z_fp, fp);
1192
1193 BLOCK_COMMENT("} generate_fixed_frame");
1194 }
1195
1196 // Various method entries
1197
1198 // Math function, frame manager must set up an interpreter state, etc.
generate_math_entry(AbstractInterpreter::MethodKind kind)1199 address TemplateInterpreterGenerator::generate_math_entry(AbstractInterpreter::MethodKind kind) {
1200
1201 // Decide what to do: Use same platform specific instructions and runtime calls as compilers.
1202 bool use_instruction = false;
1203 address runtime_entry = NULL;
1204 int num_args = 1;
1205 bool double_precision = true;
1206
1207 // s390 specific:
1208 switch (kind) {
1209 case Interpreter::java_lang_math_sqrt:
1210 case Interpreter::java_lang_math_abs: use_instruction = true; break;
1211 case Interpreter::java_lang_math_fmaF:
1212 case Interpreter::java_lang_math_fmaD: use_instruction = UseFMA; break;
1213 default: break; // Fall back to runtime call.
1214 }
1215
1216 switch (kind) {
1217 case Interpreter::java_lang_math_sin : runtime_entry = CAST_FROM_FN_PTR(address, SharedRuntime::dsin); break;
1218 case Interpreter::java_lang_math_cos : runtime_entry = CAST_FROM_FN_PTR(address, SharedRuntime::dcos); break;
1219 case Interpreter::java_lang_math_tan : runtime_entry = CAST_FROM_FN_PTR(address, SharedRuntime::dtan); break;
1220 case Interpreter::java_lang_math_abs : /* run interpreted */ break;
1221 case Interpreter::java_lang_math_sqrt : /* runtime_entry = CAST_FROM_FN_PTR(address, SharedRuntime::dsqrt); not available */ break;
1222 case Interpreter::java_lang_math_log : runtime_entry = CAST_FROM_FN_PTR(address, SharedRuntime::dlog); break;
1223 case Interpreter::java_lang_math_log10: runtime_entry = CAST_FROM_FN_PTR(address, SharedRuntime::dlog10); break;
1224 case Interpreter::java_lang_math_pow : runtime_entry = CAST_FROM_FN_PTR(address, SharedRuntime::dpow); num_args = 2; break;
1225 case Interpreter::java_lang_math_exp : runtime_entry = CAST_FROM_FN_PTR(address, SharedRuntime::dexp); break;
1226 case Interpreter::java_lang_math_fmaF : /* run interpreted */ num_args = 3; double_precision = false; break;
1227 case Interpreter::java_lang_math_fmaD : /* run interpreted */ num_args = 3; break;
1228 default: ShouldNotReachHere();
1229 }
1230
1231 // Use normal entry if neither instruction nor runtime call is used.
1232 if (!use_instruction && runtime_entry == NULL) return NULL;
1233
1234 address entry = __ pc();
1235
1236 if (use_instruction) {
1237 switch (kind) {
1238 case Interpreter::java_lang_math_sqrt:
1239 // Can use memory operand directly.
1240 __ z_sqdb(Z_FRET, Interpreter::stackElementSize, Z_esp);
1241 break;
1242 case Interpreter::java_lang_math_abs:
1243 // Load operand from stack.
1244 __ mem2freg_opt(Z_FRET, Address(Z_esp, Interpreter::stackElementSize));
1245 __ z_lpdbr(Z_FRET);
1246 break;
1247 case Interpreter::java_lang_math_fmaF:
1248 __ mem2freg_opt(Z_FRET, Address(Z_esp, Interpreter::stackElementSize)); // result reg = arg3
1249 __ mem2freg_opt(Z_FARG2, Address(Z_esp, 3 * Interpreter::stackElementSize)); // arg1
1250 __ z_maeb(Z_FRET, Z_FARG2, Address(Z_esp, 2 * Interpreter::stackElementSize));
1251 break;
1252 case Interpreter::java_lang_math_fmaD:
1253 __ mem2freg_opt(Z_FRET, Address(Z_esp, Interpreter::stackElementSize)); // result reg = arg3
1254 __ mem2freg_opt(Z_FARG2, Address(Z_esp, 5 * Interpreter::stackElementSize)); // arg1
1255 __ z_madb(Z_FRET, Z_FARG2, Address(Z_esp, 3 * Interpreter::stackElementSize));
1256 break;
1257 default: ShouldNotReachHere();
1258 }
1259 } else {
1260 // Load arguments
1261 assert(num_args <= 4, "passed in registers");
1262 if (double_precision) {
1263 int offset = (2 * num_args - 1) * Interpreter::stackElementSize;
1264 for (int i = 0; i < num_args; ++i) {
1265 __ mem2freg_opt(as_FloatRegister(Z_FARG1->encoding() + 2 * i), Address(Z_esp, offset));
1266 offset -= 2 * Interpreter::stackElementSize;
1267 }
1268 } else {
1269 int offset = num_args * Interpreter::stackElementSize;
1270 for (int i = 0; i < num_args; ++i) {
1271 __ mem2freg_opt(as_FloatRegister(Z_FARG1->encoding() + 2 * i), Address(Z_esp, offset));
1272 offset -= Interpreter::stackElementSize;
1273 }
1274 }
1275 // Call runtime
1276 __ save_return_pc(); // Save Z_R14.
1277 __ push_frame_abi160(0); // Without new frame the RT call could overwrite the saved Z_R14.
1278
1279 __ call_VM_leaf(runtime_entry);
1280
1281 __ pop_frame();
1282 __ restore_return_pc(); // Restore Z_R14.
1283 }
1284
1285 // Pop c2i arguments (if any) off when we return.
1286 __ resize_frame_absolute(Z_R10, Z_R0, true); // Cut the stack back to where the caller started.
1287
1288 __ z_br(Z_R14);
1289
1290 return entry;
1291 }
1292
1293 // Interpreter stub for calling a native method. (asm interpreter).
1294 // This sets up a somewhat different looking stack for calling the
1295 // native method than the typical interpreter frame setup.
generate_native_entry(bool synchronized)1296 address TemplateInterpreterGenerator::generate_native_entry(bool synchronized) {
1297 // Determine code generation flags.
1298 bool inc_counter = UseCompiler || CountCompiledCalls || LogTouchedMethods;
1299
1300 // Interpreter entry for ordinary Java methods.
1301 //
1302 // Registers alive
1303 // Z_SP - stack pointer
1304 // Z_thread - JavaThread*
1305 // Z_method - callee's method (method to be invoked)
1306 // Z_esp - operand (or expression) stack pointer of caller. one slot above last arg.
1307 // Z_R10 - sender sp (before modifications, e.g. by c2i adapter
1308 // and as well by generate_fixed_frame below)
1309 // Z_R14 - return address to caller (call_stub or c2i_adapter)
1310 //
1311 // Registers updated
1312 // Z_SP - stack pointer
1313 // Z_fp - callee's framepointer
1314 // Z_esp - callee's operand stack pointer
1315 // points to the slot above the value on top
1316 // Z_locals - used to access locals: locals[i] := *(Z_locals - i*BytesPerWord)
1317 // Z_tos - integer result, if any
1318 // z_ftos - floating point result, if any
1319 //
1320 // Stack layout at this point:
1321 //
1322 // F1 [TOP_IJAVA_FRAME_ABI] <-- Z_SP, Z_R10 (Z_R10 will be below Z_SP if
1323 // frame was extended by c2i adapter)
1324 // [outgoing Java arguments] <-- Z_esp
1325 // ...
1326 // PARENT [PARENT_IJAVA_FRAME_ABI]
1327 // ...
1328 //
1329
1330 address entry_point = __ pc();
1331
1332 // Make sure registers are different!
1333 assert_different_registers(Z_thread, Z_method, Z_esp);
1334
1335 BLOCK_COMMENT("native_entry {");
1336
1337 // Make sure method is native and not abstract.
1338 #ifdef ASSERT
1339 address reentry = NULL;
1340 { Label L;
1341 __ testbit(method_(access_flags), JVM_ACC_NATIVE_BIT);
1342 __ z_btrue(L);
1343 reentry = __ stop_chain_static(reentry, "tried to execute non-native method as native");
1344 __ bind(L);
1345 }
1346 { Label L;
1347 __ testbit(method_(access_flags), JVM_ACC_ABSTRACT_BIT);
1348 __ z_bfalse(L);
1349 reentry = __ stop_chain_static(reentry, "tried to execute abstract method as non-abstract");
1350 __ bind(L);
1351 }
1352 #endif // ASSERT
1353
1354 #ifdef ASSERT
1355 // Save the return PC into the callers frame for assertion in generate_fixed_frame.
1356 __ save_return_pc(Z_R14);
1357 #endif
1358
1359 // Generate the code to allocate the interpreter stack frame.
1360 generate_fixed_frame(true);
1361
1362 const Address do_not_unlock_if_synchronized(Z_thread, JavaThread::do_not_unlock_if_synchronized_offset());
1363 // Since at this point in the method invocation the exception handler
1364 // would try to exit the monitor of synchronized methods which hasn't
1365 // been entered yet, we set the thread local variable
1366 // _do_not_unlock_if_synchronized to true. If any exception was thrown by
1367 // runtime, exception handling i.e. unlock_if_synchronized_method will
1368 // check this thread local flag.
1369 __ z_mvi(do_not_unlock_if_synchronized, true);
1370
1371 // Increment invocation count and check for overflow.
1372 NearLabel invocation_counter_overflow;
1373 if (inc_counter) {
1374 generate_counter_incr(&invocation_counter_overflow);
1375 }
1376
1377 Label continue_after_compile;
1378 __ bind(continue_after_compile);
1379
1380 bang_stack_shadow_pages(true);
1381
1382 // Reset the _do_not_unlock_if_synchronized flag.
1383 __ z_mvi(do_not_unlock_if_synchronized, false);
1384
1385 // Check for synchronized methods.
1386 // This mst happen AFTER invocation_counter check and stack overflow check,
1387 // so method is not locked if overflows.
1388 if (synchronized) {
1389 lock_method();
1390 } else {
1391 // No synchronization necessary.
1392 #ifdef ASSERT
1393 { Label L;
1394 __ get_method(Z_R1_scratch);
1395 __ testbit(method2_(Z_R1_scratch, access_flags), JVM_ACC_SYNCHRONIZED_BIT);
1396 __ z_bfalse(L);
1397 reentry = __ stop_chain_static(reentry, "method needs synchronization");
1398 __ bind(L);
1399 }
1400 #endif // ASSERT
1401 }
1402
1403 // start execution
1404
1405 // jvmti support
1406 __ notify_method_entry();
1407
1408 //=============================================================================
1409 // Get and call the signature handler.
1410 const Register Rmethod = Z_tmp_2;
1411 const Register signature_handler_entry = Z_tmp_1;
1412 const Register Rresult_handler = Z_tmp_3;
1413 Label call_signature_handler;
1414
1415 assert_different_registers(Z_fp, Rmethod, signature_handler_entry, Rresult_handler);
1416 assert(Rresult_handler->is_nonvolatile(), "Rresult_handler must be in a non-volatile register");
1417
1418 // Reload method.
1419 __ get_method(Rmethod);
1420
1421 // Check for signature handler.
1422 __ load_and_test_long(signature_handler_entry, method2_(Rmethod, signature_handler));
1423 __ z_brne(call_signature_handler);
1424
1425 // Method has never been called. Either generate a specialized
1426 // handler or point to the slow one.
1427 __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::prepare_native_call),
1428 Rmethod);
1429
1430 // Reload method.
1431 __ get_method(Rmethod);
1432
1433 // Reload signature handler, it must have been created/assigned in the meantime.
1434 __ z_lg(signature_handler_entry, method2_(Rmethod, signature_handler));
1435
1436 __ bind(call_signature_handler);
1437
1438 // We have a TOP_IJAVA_FRAME here, which belongs to us.
1439 __ set_top_ijava_frame_at_SP_as_last_Java_frame(Z_SP, Z_R1/*tmp*/);
1440
1441 // Call signature handler and pass locals address in Z_ARG1.
1442 __ z_lgr(Z_ARG1, Z_locals);
1443 __ call_stub(signature_handler_entry);
1444 // Save result handler returned by signature handler.
1445 __ z_lgr(Rresult_handler, Z_RET);
1446
1447 // Reload method (the slow signature handler may block for GC).
1448 __ get_method(Rmethod);
1449
1450 // Pass mirror handle if static call.
1451 {
1452 Label method_is_not_static;
1453 __ testbit(method2_(Rmethod, access_flags), JVM_ACC_STATIC_BIT);
1454 __ z_bfalse(method_is_not_static);
1455 // Load mirror from interpreter frame.
1456 __ z_lg(Z_R1, _z_ijava_state_neg(mirror), Z_fp);
1457 // z_ijava_state.oop_temp = pool_holder->klass_part()->java_mirror();
1458 __ z_stg(Z_R1, oop_tmp_offset, Z_fp);
1459 // Pass handle to mirror as 2nd argument to JNI method.
1460 __ add2reg(Z_ARG2, oop_tmp_offset, Z_fp);
1461 __ bind(method_is_not_static);
1462 }
1463
1464 // Pass JNIEnv address as first parameter.
1465 __ add2reg(Z_ARG1, in_bytes(JavaThread::jni_environment_offset()), Z_thread);
1466
1467 // Note: last java frame has been set above already. The pc from there
1468 // is precise enough.
1469
1470 // Get native function entry point before we change the thread state.
1471 __ z_lg(Z_R1/*native_method_entry*/, method2_(Rmethod, native_function));
1472
1473 //=============================================================================
1474 // Transition from _thread_in_Java to _thread_in_native. As soon as
1475 // we make this change the safepoint code needs to be certain that
1476 // the last Java frame we established is good. The pc in that frame
1477 // just need to be near here not an actual return address.
1478 #ifdef ASSERT
1479 {
1480 NearLabel L;
1481 __ mem2reg_opt(Z_R14, Address(Z_thread, JavaThread::thread_state_offset()), false /*32 bits*/);
1482 __ compareU32_and_branch(Z_R14, _thread_in_Java, Assembler::bcondEqual, L);
1483 reentry = __ stop_chain_static(reentry, "Wrong thread state in native stub");
1484 __ bind(L);
1485 }
1486 #endif
1487
1488 // Memory ordering: Z does not reorder store/load with subsequent load. That's strong enough.
1489 __ set_thread_state(_thread_in_native);
1490
1491 //=============================================================================
1492 // Call the native method. Argument registers must not have been
1493 // overwritten since "__ call_stub(signature_handler);" (except for
1494 // ARG1 and ARG2 for static methods).
1495
1496 __ call_c(Z_R1/*native_method_entry*/);
1497
1498 // NOTE: frame::interpreter_frame_result() depends on these stores.
1499 __ z_stg(Z_RET, _z_ijava_state_neg(lresult), Z_fp);
1500 __ freg2mem_opt(Z_FRET, Address(Z_fp, _z_ijava_state_neg(fresult)));
1501 const Register Rlresult = signature_handler_entry;
1502 assert(Rlresult->is_nonvolatile(), "Rlresult must be in a non-volatile register");
1503 __ z_lgr(Rlresult, Z_RET);
1504
1505 // Z_method may no longer be valid, because of GC.
1506
1507 // Block, if necessary, before resuming in _thread_in_Java state.
1508 // In order for GC to work, don't clear the last_Java_sp until after
1509 // blocking.
1510
1511 //=============================================================================
1512 // Switch thread to "native transition" state before reading the
1513 // synchronization state. This additional state is necessary
1514 // because reading and testing the synchronization state is not
1515 // atomic w.r.t. GC, as this scenario demonstrates: Java thread A,
1516 // in _thread_in_native state, loads _not_synchronized and is
1517 // preempted. VM thread changes sync state to synchronizing and
1518 // suspends threads for GC. Thread A is resumed to finish this
1519 // native method, but doesn't block here since it didn't see any
1520 // synchronization is progress, and escapes.
1521
1522 __ set_thread_state(_thread_in_native_trans);
1523 __ z_fence();
1524
1525 // Now before we return to java we must look for a current safepoint
1526 // (a new safepoint can not start since we entered native_trans).
1527 // We must check here because a current safepoint could be modifying
1528 // the callers registers right this moment.
1529
1530 // Check for safepoint operation in progress and/or pending suspend requests.
1531 {
1532 Label Continue, do_safepoint;
1533 __ safepoint_poll(do_safepoint, Z_R1);
1534 // Check for suspend.
1535 __ load_and_test_int(Z_R0/*suspend_flags*/, thread_(suspend_flags));
1536 __ z_bre(Continue); // 0 -> no flag set -> not suspended
1537 __ bind(do_safepoint);
1538 __ z_lgr(Z_ARG1, Z_thread);
1539 __ call_c(CAST_FROM_FN_PTR(address, JavaThread::check_special_condition_for_native_trans));
1540 __ bind(Continue);
1541 }
1542
1543 //=============================================================================
1544 // Back in Interpreter Frame.
1545
1546 // We are in thread_in_native_trans here and back in the normal
1547 // interpreter frame. We don't have to do anything special about
1548 // safepoints and we can switch to Java mode anytime we are ready.
1549
1550 // Note: frame::interpreter_frame_result has a dependency on how the
1551 // method result is saved across the call to post_method_exit. For
1552 // native methods it assumes that the non-FPU/non-void result is
1553 // saved in z_ijava_state.lresult and a FPU result in z_ijava_state.fresult. If
1554 // this changes then the interpreter_frame_result implementation
1555 // will need to be updated too.
1556
1557 //=============================================================================
1558 // Back in Java.
1559
1560 // Memory ordering: Z does not reorder store/load with subsequent
1561 // load. That's strong enough.
1562 __ set_thread_state(_thread_in_Java);
1563
1564 __ reset_last_Java_frame();
1565
1566 // We reset the JNI handle block only after unboxing the result; see below.
1567
1568 // The method register is junk from after the thread_in_native transition
1569 // until here. Also can't call_VM until the bcp has been
1570 // restored. Need bcp for throwing exception below so get it now.
1571 __ get_method(Rmethod);
1572
1573 // Restore Z_bcp to have legal interpreter frame,
1574 // i.e., bci == 0 <=> Z_bcp == code_base().
1575 __ z_lg(Z_bcp, Address(Rmethod, Method::const_offset())); // get constMethod
1576 __ add2reg(Z_bcp, in_bytes(ConstMethod::codes_offset())); // get codebase
1577
1578 if (CheckJNICalls) {
1579 // clear_pending_jni_exception_check
1580 __ clear_mem(Address(Z_thread, JavaThread::pending_jni_exception_check_fn_offset()), sizeof(oop));
1581 }
1582
1583 // Check if the native method returns an oop, and if so, move it
1584 // from the jni handle to z_ijava_state.oop_temp. This is
1585 // necessary, because we reset the jni handle block below.
1586 // NOTE: frame::interpreter_frame_result() depends on this, too.
1587 { NearLabel no_oop_result;
1588 __ load_absolute_address(Z_R1, AbstractInterpreter::result_handler(T_OBJECT));
1589 __ compareU64_and_branch(Z_R1, Rresult_handler, Assembler::bcondNotEqual, no_oop_result);
1590 __ resolve_jobject(Rlresult, /* tmp1 */ Rmethod, /* tmp2 */ Z_R1);
1591 __ z_stg(Rlresult, oop_tmp_offset, Z_fp);
1592 __ bind(no_oop_result);
1593 }
1594
1595 // Reset handle block.
1596 __ z_lg(Z_R1/*active_handles*/, thread_(active_handles));
1597 __ clear_mem(Address(Z_R1, JNIHandleBlock::top_offset_in_bytes()), 4);
1598
1599 // Handle exceptions (exception handling will handle unlocking!).
1600 {
1601 Label L;
1602 __ load_and_test_long(Z_R0/*pending_exception*/, thread_(pending_exception));
1603 __ z_bre(L);
1604 __ MacroAssembler::call_VM(noreg,
1605 CAST_FROM_FN_PTR(address,
1606 InterpreterRuntime::throw_pending_exception));
1607 __ should_not_reach_here();
1608 __ bind(L);
1609 }
1610
1611 if (synchronized) {
1612 Register Rfirst_monitor = Z_ARG2;
1613 __ add2reg(Rfirst_monitor, -(frame::z_ijava_state_size + (int)sizeof(BasicObjectLock)), Z_fp);
1614 #ifdef ASSERT
1615 NearLabel ok;
1616 __ z_lg(Z_R1, _z_ijava_state_neg(monitors), Z_fp);
1617 __ compareU64_and_branch(Rfirst_monitor, Z_R1, Assembler::bcondEqual, ok);
1618 reentry = __ stop_chain_static(reentry, "native_entry:unlock: inconsistent z_ijava_state.monitors");
1619 __ bind(ok);
1620 #endif
1621 __ unlock_object(Rfirst_monitor);
1622 }
1623
1624 // JVMTI support. Result has already been saved above to the frame.
1625 __ notify_method_exit(true/*native_method*/, ilgl, InterpreterMacroAssembler::NotifyJVMTI);
1626
1627 // Move native method result back into proper registers and return.
1628 __ mem2freg_opt(Z_FRET, Address(Z_fp, _z_ijava_state_neg(fresult)));
1629 __ mem2reg_opt(Z_RET, Address(Z_fp, _z_ijava_state_neg(lresult)));
1630 __ call_stub(Rresult_handler);
1631
1632 // Pop the native method's interpreter frame.
1633 __ pop_interpreter_frame(Z_R14 /*return_pc*/, Z_ARG2/*tmp1*/, Z_ARG3/*tmp2*/);
1634
1635 // Return to caller.
1636 __ z_br(Z_R14);
1637
1638 if (inc_counter) {
1639 // Handle overflow of counter and compile method.
1640 __ bind(invocation_counter_overflow);
1641 generate_counter_overflow(continue_after_compile);
1642 }
1643
1644 BLOCK_COMMENT("} native_entry");
1645
1646 return entry_point;
1647 }
1648
1649 //
1650 // Generic interpreted method entry to template interpreter.
1651 //
generate_normal_entry(bool synchronized)1652 address TemplateInterpreterGenerator::generate_normal_entry(bool synchronized) {
1653 address entry_point = __ pc();
1654
1655 bool inc_counter = UseCompiler || CountCompiledCalls || LogTouchedMethods;
1656
1657 // Interpreter entry for ordinary Java methods.
1658 //
1659 // Registers alive
1660 // Z_SP - stack pointer
1661 // Z_thread - JavaThread*
1662 // Z_method - callee's method (method to be invoked)
1663 // Z_esp - operand (or expression) stack pointer of caller. one slot above last arg.
1664 // Z_R10 - sender sp (before modifications, e.g. by c2i adapter
1665 // and as well by generate_fixed_frame below)
1666 // Z_R14 - return address to caller (call_stub or c2i_adapter)
1667 //
1668 // Registers updated
1669 // Z_SP - stack pointer
1670 // Z_fp - callee's framepointer
1671 // Z_esp - callee's operand stack pointer
1672 // points to the slot above the value on top
1673 // Z_locals - used to access locals: locals[i] := *(Z_locals - i*BytesPerWord)
1674 // Z_tos - integer result, if any
1675 // z_ftos - floating point result, if any
1676 //
1677 //
1678 // stack layout at this point:
1679 //
1680 // F1 [TOP_IJAVA_FRAME_ABI] <-- Z_SP, Z_R10 (Z_R10 will be below Z_SP if
1681 // frame was extended by c2i adapter)
1682 // [outgoing Java arguments] <-- Z_esp
1683 // ...
1684 // PARENT [PARENT_IJAVA_FRAME_ABI]
1685 // ...
1686 //
1687 // stack layout before dispatching the first bytecode:
1688 //
1689 // F0 [TOP_IJAVA_FRAME_ABI] <-- Z_SP
1690 // [operand stack] <-- Z_esp
1691 // monitor (optional, can grow)
1692 // [IJAVA_STATE]
1693 // F1 [PARENT_IJAVA_FRAME_ABI] <-- Z_fp (== *Z_SP)
1694 // [F0's locals] <-- Z_locals
1695 // [F1's operand stack]
1696 // [F1's monitors] (optional)
1697 // [IJAVA_STATE]
1698
1699 // Make sure registers are different!
1700 assert_different_registers(Z_thread, Z_method, Z_esp);
1701
1702 BLOCK_COMMENT("normal_entry {");
1703
1704 // Make sure method is not native and not abstract.
1705 // Rethink these assertions - they can be simplified and shared.
1706 #ifdef ASSERT
1707 address reentry = NULL;
1708 { Label L;
1709 __ testbit(method_(access_flags), JVM_ACC_NATIVE_BIT);
1710 __ z_bfalse(L);
1711 reentry = __ stop_chain_static(reentry, "tried to execute native method as non-native");
1712 __ bind(L);
1713 }
1714 { Label L;
1715 __ testbit(method_(access_flags), JVM_ACC_ABSTRACT_BIT);
1716 __ z_bfalse(L);
1717 reentry = __ stop_chain_static(reentry, "tried to execute abstract method as non-abstract");
1718 __ bind(L);
1719 }
1720 #endif // ASSERT
1721
1722 #ifdef ASSERT
1723 // Save the return PC into the callers frame for assertion in generate_fixed_frame.
1724 __ save_return_pc(Z_R14);
1725 #endif
1726
1727 // Generate the code to allocate the interpreter stack frame.
1728 generate_fixed_frame(false);
1729
1730 const Address do_not_unlock_if_synchronized(Z_thread, JavaThread::do_not_unlock_if_synchronized_offset());
1731 // Since at this point in the method invocation the exception handler
1732 // would try to exit the monitor of synchronized methods which hasn't
1733 // been entered yet, we set the thread local variable
1734 // _do_not_unlock_if_synchronized to true. If any exception was thrown by
1735 // runtime, exception handling i.e. unlock_if_synchronized_method will
1736 // check this thread local flag.
1737 __ z_mvi(do_not_unlock_if_synchronized, true);
1738
1739 __ profile_parameters_type(Z_tmp_2, Z_ARG3, Z_ARG4);
1740
1741 // Increment invocation counter and check for overflow.
1742 //
1743 // Note: checking for negative value instead of overflow so we have a 'sticky'
1744 // overflow test (may be of importance as soon as we have true MT/MP).
1745 NearLabel invocation_counter_overflow;
1746 NearLabel Lcontinue;
1747 if (inc_counter) {
1748 generate_counter_incr(&invocation_counter_overflow);
1749 }
1750 __ bind(Lcontinue);
1751
1752 bang_stack_shadow_pages(false);
1753
1754 // Reset the _do_not_unlock_if_synchronized flag.
1755 __ z_mvi(do_not_unlock_if_synchronized, false);
1756
1757 // Check for synchronized methods.
1758 // Must happen AFTER invocation_counter check and stack overflow check,
1759 // so method is not locked if overflows.
1760 if (synchronized) {
1761 // Allocate monitor and lock method.
1762 lock_method();
1763 } else {
1764 #ifdef ASSERT
1765 { Label L;
1766 __ get_method(Z_R1_scratch);
1767 __ testbit(method2_(Z_R1_scratch, access_flags), JVM_ACC_SYNCHRONIZED_BIT);
1768 __ z_bfalse(L);
1769 reentry = __ stop_chain_static(reentry, "method needs synchronization");
1770 __ bind(L);
1771 }
1772 #endif // ASSERT
1773 }
1774
1775 // start execution
1776
1777 #ifdef ASSERT
1778 __ verify_esp(Z_esp, Z_R1_scratch);
1779
1780 __ verify_thread();
1781 #endif
1782
1783 // jvmti support
1784 __ notify_method_entry();
1785
1786 // Start executing instructions.
1787 __ dispatch_next(vtos);
1788 // Dispatch_next does not return.
1789 DEBUG_ONLY(__ should_not_reach_here());
1790
1791 // Invocation counter overflow.
1792 if (inc_counter) {
1793 // Handle invocation counter overflow.
1794 __ bind(invocation_counter_overflow);
1795 generate_counter_overflow(Lcontinue);
1796 }
1797
1798 BLOCK_COMMENT("} normal_entry");
1799
1800 return entry_point;
1801 }
1802
1803
1804 /**
1805 * Method entry for static native methods:
1806 * int java.util.zip.CRC32.update(int crc, int b)
1807 */
generate_CRC32_update_entry()1808 address TemplateInterpreterGenerator::generate_CRC32_update_entry() {
1809
1810 if (UseCRC32Intrinsics) {
1811 uint64_t entry_off = __ offset();
1812 Label slow_path;
1813
1814 // If we need a safepoint check, generate full interpreter entry.
1815 __ safepoint_poll(slow_path, Z_R1);
1816
1817 BLOCK_COMMENT("CRC32_update {");
1818
1819 // We don't generate local frame and don't align stack because
1820 // we not even call stub code (we generate the code inline)
1821 // and there is no safepoint on this path.
1822
1823 // Load java parameters.
1824 // Z_esp is callers operand stack pointer, i.e. it points to the parameters.
1825 const Register argP = Z_esp;
1826 const Register crc = Z_ARG1; // crc value
1827 const Register data = Z_ARG2; // address of java byte value (kernel_crc32 needs address)
1828 const Register dataLen = Z_ARG3; // source data len (1 byte). Not used because calling the single-byte emitter.
1829 const Register table = Z_ARG4; // address of crc32 table
1830
1831 // Arguments are reversed on java expression stack.
1832 __ z_la(data, 3+1*wordSize, argP); // byte value (stack address).
1833 // Being passed as an int, the single byte is at offset +3.
1834 __ z_llgf(crc, 2 * wordSize, argP); // Current crc state, zero extend to 64 bit to have a clean register.
1835
1836 StubRoutines::zarch::generate_load_crc_table_addr(_masm, table);
1837 __ kernel_crc32_singleByte(crc, data, dataLen, table, Z_R1, true);
1838
1839 // Restore caller sp for c2i case.
1840 __ resize_frame_absolute(Z_R10, Z_R0, true); // Cut the stack back to where the caller started.
1841
1842 __ z_br(Z_R14);
1843
1844 BLOCK_COMMENT("} CRC32_update");
1845
1846 // Use a previously generated vanilla native entry as the slow path.
1847 BIND(slow_path);
1848 __ jump_to_entry(Interpreter::entry_for_kind(Interpreter::native), Z_R1);
1849 return __ addr_at(entry_off);
1850 }
1851
1852 return NULL;
1853 }
1854
1855
1856 /**
1857 * Method entry for static native methods:
1858 * int java.util.zip.CRC32.updateBytes( int crc, byte[] b, int off, int len)
1859 * int java.util.zip.CRC32.updateByteBuffer(int crc, long* buf, int off, int len)
1860 */
generate_CRC32_updateBytes_entry(AbstractInterpreter::MethodKind kind)1861 address TemplateInterpreterGenerator::generate_CRC32_updateBytes_entry(AbstractInterpreter::MethodKind kind) {
1862
1863 if (UseCRC32Intrinsics) {
1864 uint64_t entry_off = __ offset();
1865 Label slow_path;
1866
1867 // If we need a safepoint check, generate full interpreter entry.
1868 __ safepoint_poll(slow_path, Z_R1);
1869
1870 // We don't generate local frame and don't align stack because
1871 // we call stub code and there is no safepoint on this path.
1872
1873 // Load parameters.
1874 // Z_esp is callers operand stack pointer, i.e. it points to the parameters.
1875 const Register argP = Z_esp;
1876 const Register crc = Z_ARG1; // crc value
1877 const Register data = Z_ARG2; // address of java byte array
1878 const Register dataLen = Z_ARG3; // source data len
1879 const Register table = Z_ARG4; // address of crc32 table
1880 const Register t0 = Z_R10; // work reg for kernel* emitters
1881 const Register t1 = Z_R11; // work reg for kernel* emitters
1882 const Register t2 = Z_R12; // work reg for kernel* emitters
1883 const Register t3 = Z_R13; // work reg for kernel* emitters
1884
1885 // Arguments are reversed on java expression stack.
1886 // Calculate address of start element.
1887 if (kind == Interpreter::java_util_zip_CRC32_updateByteBuffer) { // Used for "updateByteBuffer direct".
1888 // crc @ (SP + 5W) (32bit)
1889 // buf @ (SP + 3W) (64bit ptr to long array)
1890 // off @ (SP + 2W) (32bit)
1891 // dataLen @ (SP + 1W) (32bit)
1892 // data = buf + off
1893 BLOCK_COMMENT("CRC32_updateByteBuffer {");
1894 __ z_llgf(crc, 5*wordSize, argP); // current crc state
1895 __ z_lg(data, 3*wordSize, argP); // start of byte buffer
1896 __ z_agf(data, 2*wordSize, argP); // Add byte buffer offset.
1897 __ z_lgf(dataLen, 1*wordSize, argP); // #bytes to process
1898 } else { // Used for "updateBytes update".
1899 // crc @ (SP + 4W) (32bit)
1900 // buf @ (SP + 3W) (64bit ptr to byte array)
1901 // off @ (SP + 2W) (32bit)
1902 // dataLen @ (SP + 1W) (32bit)
1903 // data = buf + off + base_offset
1904 BLOCK_COMMENT("CRC32_updateBytes {");
1905 __ z_llgf(crc, 4*wordSize, argP); // current crc state
1906 __ z_lg(data, 3*wordSize, argP); // start of byte buffer
1907 __ z_agf(data, 2*wordSize, argP); // Add byte buffer offset.
1908 __ z_lgf(dataLen, 1*wordSize, argP); // #bytes to process
1909 __ z_aghi(data, arrayOopDesc::base_offset_in_bytes(T_BYTE));
1910 }
1911
1912 StubRoutines::zarch::generate_load_crc_table_addr(_masm, table);
1913
1914 __ resize_frame(-(6*8), Z_R0, true); // Resize frame to provide add'l space to spill 5 registers.
1915 __ z_stmg(t0, t3, 1*8, Z_SP); // Spill regs 10..13 to make them available as work registers.
1916 __ kernel_crc32_1word(crc, data, dataLen, table, t0, t1, t2, t3, true);
1917 __ z_lmg(t0, t3, 1*8, Z_SP); // Spill regs 10..13 back from stack.
1918
1919 // Restore caller sp for c2i case.
1920 __ resize_frame_absolute(Z_R10, Z_R0, true); // Cut the stack back to where the caller started.
1921
1922 __ z_br(Z_R14);
1923
1924 BLOCK_COMMENT("} CRC32_update{Bytes|ByteBuffer}");
1925
1926 // Use a previously generated vanilla native entry as the slow path.
1927 BIND(slow_path);
1928 __ jump_to_entry(Interpreter::entry_for_kind(Interpreter::native), Z_R1);
1929 return __ addr_at(entry_off);
1930 }
1931
1932 return NULL;
1933 }
1934
1935
1936 /**
1937 * Method entry for intrinsic-candidate (non-native) methods:
1938 * int java.util.zip.CRC32C.updateBytes( int crc, byte[] b, int off, int end)
1939 * int java.util.zip.CRC32C.updateDirectByteBuffer(int crc, long* buf, int off, int end)
1940 * Unlike CRC32, CRC32C does not have any methods marked as native
1941 * CRC32C also uses an "end" variable instead of the length variable CRC32 uses
1942 */
generate_CRC32C_updateBytes_entry(AbstractInterpreter::MethodKind kind)1943 address TemplateInterpreterGenerator::generate_CRC32C_updateBytes_entry(AbstractInterpreter::MethodKind kind) {
1944
1945 if (UseCRC32CIntrinsics) {
1946 uint64_t entry_off = __ offset();
1947
1948 // We don't generate local frame and don't align stack because
1949 // we call stub code and there is no safepoint on this path.
1950
1951 // Load parameters.
1952 // Z_esp is callers operand stack pointer, i.e. it points to the parameters.
1953 const Register argP = Z_esp;
1954 const Register crc = Z_ARG1; // crc value
1955 const Register data = Z_ARG2; // address of java byte array
1956 const Register dataLen = Z_ARG3; // source data len
1957 const Register table = Z_ARG4; // address of crc32 table
1958 const Register t0 = Z_R10; // work reg for kernel* emitters
1959 const Register t1 = Z_R11; // work reg for kernel* emitters
1960 const Register t2 = Z_R12; // work reg for kernel* emitters
1961 const Register t3 = Z_R13; // work reg for kernel* emitters
1962
1963 // Arguments are reversed on java expression stack.
1964 // Calculate address of start element.
1965 if (kind == Interpreter::java_util_zip_CRC32C_updateDirectByteBuffer) { // Used for "updateByteBuffer direct".
1966 // crc @ (SP + 5W) (32bit)
1967 // buf @ (SP + 3W) (64bit ptr to long array)
1968 // off @ (SP + 2W) (32bit)
1969 // dataLen @ (SP + 1W) (32bit)
1970 // data = buf + off
1971 BLOCK_COMMENT("CRC32C_updateDirectByteBuffer {");
1972 __ z_llgf(crc, 5*wordSize, argP); // current crc state
1973 __ z_lg(data, 3*wordSize, argP); // start of byte buffer
1974 __ z_agf(data, 2*wordSize, argP); // Add byte buffer offset.
1975 __ z_lgf(dataLen, 1*wordSize, argP); // #bytes to process, calculated as
1976 __ z_sgf(dataLen, Address(argP, 2*wordSize)); // (end_index - offset)
1977 } else { // Used for "updateBytes update".
1978 // crc @ (SP + 4W) (32bit)
1979 // buf @ (SP + 3W) (64bit ptr to byte array)
1980 // off @ (SP + 2W) (32bit)
1981 // dataLen @ (SP + 1W) (32bit)
1982 // data = buf + off + base_offset
1983 BLOCK_COMMENT("CRC32C_updateBytes {");
1984 __ z_llgf(crc, 4*wordSize, argP); // current crc state
1985 __ z_lg(data, 3*wordSize, argP); // start of byte buffer
1986 __ z_agf(data, 2*wordSize, argP); // Add byte buffer offset.
1987 __ z_lgf(dataLen, 1*wordSize, argP); // #bytes to process, calculated as
1988 __ z_sgf(dataLen, Address(argP, 2*wordSize)); // (end_index - offset)
1989 __ z_aghi(data, arrayOopDesc::base_offset_in_bytes(T_BYTE));
1990 }
1991
1992 StubRoutines::zarch::generate_load_crc32c_table_addr(_masm, table);
1993
1994 __ resize_frame(-(6*8), Z_R0, true); // Resize frame to provide add'l space to spill 5 registers.
1995 __ z_stmg(t0, t3, 1*8, Z_SP); // Spill regs 10..13 to make them available as work registers.
1996 __ kernel_crc32_1word(crc, data, dataLen, table, t0, t1, t2, t3, false);
1997 __ z_lmg(t0, t3, 1*8, Z_SP); // Spill regs 10..13 back from stack.
1998
1999 // Restore caller sp for c2i case.
2000 __ resize_frame_absolute(Z_R10, Z_R0, true); // Cut the stack back to where the caller started.
2001
2002 __ z_br(Z_R14);
2003
2004 BLOCK_COMMENT("} CRC32C_update{Bytes|DirectByteBuffer}");
2005 return __ addr_at(entry_off);
2006 }
2007
2008 return NULL;
2009 }
2010
bang_stack_shadow_pages(bool native_call)2011 void TemplateInterpreterGenerator::bang_stack_shadow_pages(bool native_call) {
2012 // Quick & dirty stack overflow checking: bang the stack & handle trap.
2013 // Note that we do the banging after the frame is setup, since the exception
2014 // handling code expects to find a valid interpreter frame on the stack.
2015 // Doing the banging earlier fails if the caller frame is not an interpreter
2016 // frame.
2017 // (Also, the exception throwing code expects to unlock any synchronized
2018 // method receiver, so do the banging after locking the receiver.)
2019
2020 // Bang each page in the shadow zone. We can't assume it's been done for
2021 // an interpreter frame with greater than a page of locals, so each page
2022 // needs to be checked. Only true for non-native. For native, we only bang the last page.
2023 const int page_size = os::vm_page_size();
2024 const int n_shadow_pages = (int)(StackOverflow::stack_shadow_zone_size()/page_size);
2025 const int start_page_num = native_call ? n_shadow_pages : 1;
2026 for (int pages = start_page_num; pages <= n_shadow_pages; pages++) {
2027 __ bang_stack_with_offset(pages*page_size);
2028 }
2029 }
2030
2031 //-----------------------------------------------------------------------------
2032 // Exceptions
2033
generate_throw_exception()2034 void TemplateInterpreterGenerator::generate_throw_exception() {
2035
2036 BLOCK_COMMENT("throw_exception {");
2037
2038 // Entry point in previous activation (i.e., if the caller was interpreted).
2039 Interpreter::_rethrow_exception_entry = __ pc();
2040 __ z_lg(Z_fp, _z_abi(callers_sp), Z_SP); // Frame accessors use Z_fp.
2041 // Z_ARG1 (==Z_tos): exception
2042 // Z_ARG2 : Return address/pc that threw exception.
2043 __ restore_bcp(); // R13 points to call/send.
2044 __ restore_locals();
2045
2046 // Fallthrough, no need to restore Z_esp.
2047
2048 // Entry point for exceptions thrown within interpreter code.
2049 Interpreter::_throw_exception_entry = __ pc();
2050 // Expression stack is undefined here.
2051 // Z_ARG1 (==Z_tos): exception
2052 // Z_bcp: exception bcp
2053 __ verify_oop(Z_ARG1);
2054 __ z_lgr(Z_ARG2, Z_ARG1);
2055
2056 // Expression stack must be empty before entering the VM in case of
2057 // an exception.
2058 __ empty_expression_stack();
2059 // Find exception handler address and preserve exception oop.
2060 const Register Rpreserved_exc_oop = Z_tmp_1;
2061 __ call_VM(Rpreserved_exc_oop,
2062 CAST_FROM_FN_PTR(address, InterpreterRuntime::exception_handler_for_exception),
2063 Z_ARG2);
2064 // Z_RET: exception handler entry point
2065 // Z_bcp: bcp for exception handler
2066 __ push_ptr(Rpreserved_exc_oop); // Push exception which is now the only value on the stack.
2067 __ z_br(Z_RET); // Jump to exception handler (may be _remove_activation_entry!).
2068
2069 // If the exception is not handled in the current frame the frame is
2070 // removed and the exception is rethrown (i.e. exception
2071 // continuation is _rethrow_exception).
2072 //
2073 // Note: At this point the bci is still the bci for the instruction
2074 // which caused the exception and the expression stack is
2075 // empty. Thus, for any VM calls at this point, GC will find a legal
2076 // oop map (with empty expression stack).
2077
2078 //
2079 // JVMTI PopFrame support
2080 //
2081
2082 Interpreter::_remove_activation_preserving_args_entry = __ pc();
2083 __ z_lg(Z_fp, _z_parent_ijava_frame_abi(callers_sp), Z_SP);
2084 __ empty_expression_stack();
2085 // Set the popframe_processing bit in pending_popframe_condition
2086 // indicating that we are currently handling popframe, so that
2087 // call_VMs that may happen later do not trigger new popframe
2088 // handling cycles.
2089 __ load_sized_value(Z_tmp_1, Address(Z_thread, JavaThread::popframe_condition_offset()), 4, false /*signed*/);
2090 __ z_oill(Z_tmp_1, JavaThread::popframe_processing_bit);
2091 __ z_sty(Z_tmp_1, thread_(popframe_condition));
2092
2093 {
2094 // Check to see whether we are returning to a deoptimized frame.
2095 // (The PopFrame call ensures that the caller of the popped frame is
2096 // either interpreted or compiled and deoptimizes it if compiled.)
2097 // In this case, we can't call dispatch_next() after the frame is
2098 // popped, but instead must save the incoming arguments and restore
2099 // them after deoptimization has occurred.
2100 //
2101 // Note that we don't compare the return PC against the
2102 // deoptimization blob's unpack entry because of the presence of
2103 // adapter frames in C2.
2104 NearLabel caller_not_deoptimized;
2105 __ z_lg(Z_ARG1, _z_parent_ijava_frame_abi(return_pc), Z_fp);
2106 __ call_VM_leaf(CAST_FROM_FN_PTR(address, InterpreterRuntime::interpreter_contains), Z_ARG1);
2107 __ compareU64_and_branch(Z_RET, (intptr_t)0, Assembler::bcondNotEqual, caller_not_deoptimized);
2108
2109 // Compute size of arguments for saving when returning to
2110 // deoptimized caller.
2111 __ get_method(Z_ARG2);
2112 __ z_lg(Z_ARG2, Address(Z_ARG2, Method::const_offset()));
2113 __ z_llgh(Z_ARG2, Address(Z_ARG2, ConstMethod::size_of_parameters_offset()));
2114 __ z_sllg(Z_ARG2, Z_ARG2, Interpreter::logStackElementSize); // slots 2 bytes
2115 __ restore_locals();
2116 // Compute address of args to be saved.
2117 __ z_lgr(Z_ARG3, Z_locals);
2118 __ z_slgr(Z_ARG3, Z_ARG2);
2119 __ add2reg(Z_ARG3, wordSize);
2120 // Save these arguments.
2121 __ call_VM_leaf(CAST_FROM_FN_PTR(address, Deoptimization::popframe_preserve_args),
2122 Z_thread, Z_ARG2, Z_ARG3);
2123
2124 __ remove_activation(vtos, Z_R14,
2125 /* throw_monitor_exception */ false,
2126 /* install_monitor_exception */ false,
2127 /* notify_jvmdi */ false);
2128
2129 // Inform deoptimization that it is responsible for restoring
2130 // these arguments.
2131 __ store_const(thread_(popframe_condition),
2132 JavaThread::popframe_force_deopt_reexecution_bit,
2133 Z_tmp_1, false);
2134
2135 // Continue in deoptimization handler.
2136 __ z_br(Z_R14);
2137
2138 __ bind(caller_not_deoptimized);
2139 }
2140
2141 // Clear the popframe condition flag.
2142 __ clear_mem(thread_(popframe_condition), sizeof(int));
2143
2144 __ remove_activation(vtos,
2145 noreg, // Retaddr is not used.
2146 false, // throw_monitor_exception
2147 false, // install_monitor_exception
2148 false); // notify_jvmdi
2149 __ z_lg(Z_fp, _z_abi(callers_sp), Z_SP); // Restore frame pointer.
2150 __ restore_bcp();
2151 __ restore_locals();
2152 __ restore_esp();
2153 // The method data pointer was incremented already during
2154 // call profiling. We have to restore the mdp for the current bcp.
2155 if (ProfileInterpreter) {
2156 __ set_method_data_pointer_for_bcp();
2157 }
2158 #if INCLUDE_JVMTI
2159 {
2160 Label L_done;
2161
2162 __ z_cli(0, Z_bcp, Bytecodes::_invokestatic);
2163 __ z_brc(Assembler::bcondNotEqual, L_done);
2164
2165 // The member name argument must be restored if _invokestatic is
2166 // re-executed after a PopFrame call. Detect such a case in the
2167 // InterpreterRuntime function and return the member name
2168 // argument, or NULL.
2169 __ z_lg(Z_ARG2, Address(Z_locals));
2170 __ get_method(Z_ARG3);
2171 __ call_VM(Z_tmp_1,
2172 CAST_FROM_FN_PTR(address, InterpreterRuntime::member_name_arg_or_null),
2173 Z_ARG2, Z_ARG3, Z_bcp);
2174
2175 __ z_ltgr(Z_tmp_1, Z_tmp_1);
2176 __ z_brc(Assembler::bcondEqual, L_done);
2177
2178 __ z_stg(Z_tmp_1, Address(Z_esp, wordSize));
2179 __ bind(L_done);
2180 }
2181 #endif // INCLUDE_JVMTI
2182 __ dispatch_next(vtos);
2183 // End of PopFrame support.
2184 Interpreter::_remove_activation_entry = __ pc();
2185
2186 // In between activations - previous activation type unknown yet
2187 // compute continuation point - the continuation point expects the
2188 // following registers set up:
2189 //
2190 // Z_ARG1 (==Z_tos): exception
2191 // Z_ARG2 : return address/pc that threw exception
2192
2193 Register return_pc = Z_tmp_1;
2194 Register handler = Z_tmp_2;
2195 assert(return_pc->is_nonvolatile(), "use non-volatile reg. to preserve exception pc");
2196 assert(handler->is_nonvolatile(), "use non-volatile reg. to handler pc");
2197 __ asm_assert_ijava_state_magic(return_pc/*tmp*/); // The top frame should be an interpreter frame.
2198 __ z_lg(return_pc, _z_parent_ijava_frame_abi(return_pc), Z_fp);
2199
2200 // Moved removing the activation after VM call, because the new top
2201 // frame does not necessarily have the z_abi_160 required for a VM
2202 // call (e.g. if it is compiled).
2203
2204 __ super_call_VM_leaf(CAST_FROM_FN_PTR(address,
2205 SharedRuntime::exception_handler_for_return_address),
2206 Z_thread, return_pc);
2207 __ z_lgr(handler, Z_RET); // Save exception handler.
2208
2209 // Preserve exception over this code sequence.
2210 __ pop_ptr(Z_ARG1);
2211 __ set_vm_result(Z_ARG1);
2212 // Remove the activation (without doing throws on illegalMonitorExceptions).
2213 __ remove_activation(vtos, noreg/*ret.pc already loaded*/, false/*throw exc*/, true/*install exc*/, false/*notify jvmti*/);
2214 __ z_lg(Z_fp, _z_abi(callers_sp), Z_SP); // Restore frame pointer.
2215
2216 __ get_vm_result(Z_ARG1); // Restore exception.
2217 __ verify_oop(Z_ARG1);
2218 __ z_lgr(Z_ARG2, return_pc); // Restore return address.
2219
2220 #ifdef ASSERT
2221 // The return_pc in the new top frame is dead... at least that's my
2222 // current understanding. To assert this I overwrite it.
2223 // Note: for compiled frames the handler is the deopt blob
2224 // which writes Z_ARG2 into the return_pc slot.
2225 __ load_const_optimized(return_pc, 0xb00b1);
2226 __ z_stg(return_pc, _z_parent_ijava_frame_abi(return_pc), Z_SP);
2227 #endif
2228
2229 // Z_ARG1 (==Z_tos): exception
2230 // Z_ARG2 : return address/pc that threw exception
2231
2232 // Note that an "issuing PC" is actually the next PC after the call.
2233 __ z_br(handler); // Jump to exception handler of caller.
2234
2235 BLOCK_COMMENT("} throw_exception");
2236 }
2237
2238 //
2239 // JVMTI ForceEarlyReturn support
2240 //
generate_earlyret_entry_for(TosState state)2241 address TemplateInterpreterGenerator::generate_earlyret_entry_for (TosState state) {
2242 address entry = __ pc();
2243
2244 BLOCK_COMMENT("earlyret_entry {");
2245
2246 __ z_lg(Z_fp, _z_parent_ijava_frame_abi(callers_sp), Z_SP);
2247 __ restore_bcp();
2248 __ restore_locals();
2249 __ restore_esp();
2250 __ empty_expression_stack();
2251 __ load_earlyret_value(state);
2252
2253 Register RjvmtiState = Z_tmp_1;
2254 __ z_lg(RjvmtiState, thread_(jvmti_thread_state));
2255 __ store_const(Address(RjvmtiState, JvmtiThreadState::earlyret_state_offset()),
2256 JvmtiThreadState::earlyret_inactive, 4, 4, Z_R0_scratch);
2257
2258 if (state == itos) {
2259 // Narrow result if state is itos but result type is smaller.
2260 // Need to narrow in the return bytecode rather than in generate_return_entry
2261 // since compiled code callers expect the result to already be narrowed.
2262 __ narrow(Z_tos, Z_tmp_1); /* fall through */
2263 }
2264 __ remove_activation(state,
2265 Z_tmp_1, // retaddr
2266 false, // throw_monitor_exception
2267 false, // install_monitor_exception
2268 true); // notify_jvmdi
2269 __ z_br(Z_tmp_1);
2270
2271 BLOCK_COMMENT("} earlyret_entry");
2272
2273 return entry;
2274 }
2275
2276 //-----------------------------------------------------------------------------
2277 // Helper for vtos entry point generation.
2278
set_vtos_entry_points(Template * t,address & bep,address & cep,address & sep,address & aep,address & iep,address & lep,address & fep,address & dep,address & vep)2279 void TemplateInterpreterGenerator::set_vtos_entry_points(Template* t,
2280 address& bep,
2281 address& cep,
2282 address& sep,
2283 address& aep,
2284 address& iep,
2285 address& lep,
2286 address& fep,
2287 address& dep,
2288 address& vep) {
2289 assert(t->is_valid() && t->tos_in() == vtos, "illegal template");
2290 Label L;
2291 aep = __ pc(); __ push_ptr(); __ z_bru(L);
2292 fep = __ pc(); __ push_f(); __ z_bru(L);
2293 dep = __ pc(); __ push_d(); __ z_bru(L);
2294 lep = __ pc(); __ push_l(); __ z_bru(L);
2295 bep = cep = sep =
2296 iep = __ pc(); __ push_i();
2297 vep = __ pc();
2298 __ bind(L);
2299 generate_and_dispatch(t);
2300 }
2301
2302 //-----------------------------------------------------------------------------
2303
2304 #ifndef PRODUCT
generate_trace_code(TosState state)2305 address TemplateInterpreterGenerator::generate_trace_code(TosState state) {
2306 address entry = __ pc();
2307 NearLabel counter_below_trace_threshold;
2308
2309 if (TraceBytecodesAt > 0) {
2310 // Skip runtime call, if the trace threshold is not yet reached.
2311 __ load_absolute_address(Z_tmp_1, (address)&BytecodeCounter::_counter_value);
2312 __ load_absolute_address(Z_tmp_2, (address)&TraceBytecodesAt);
2313 __ load_sized_value(Z_tmp_1, Address(Z_tmp_1), 4, false /*signed*/);
2314 __ load_sized_value(Z_tmp_2, Address(Z_tmp_2), 8, false /*signed*/);
2315 __ compareU64_and_branch(Z_tmp_1, Z_tmp_2, Assembler::bcondLow, counter_below_trace_threshold);
2316 }
2317
2318 int offset2 = state == ltos || state == dtos ? 2 : 1;
2319
2320 __ push(state);
2321 // Preserved return pointer is in Z_R14.
2322 // InterpreterRuntime::trace_bytecode() preserved and returns the value passed as second argument.
2323 __ z_lgr(Z_ARG2, Z_R14);
2324 __ z_lg(Z_ARG3, Address(Z_esp, Interpreter::expr_offset_in_bytes(0)));
2325 if (WizardMode) {
2326 __ z_lgr(Z_ARG4, Z_esp); // Trace Z_esp in WizardMode.
2327 } else {
2328 __ z_lg(Z_ARG4, Address(Z_esp, Interpreter::expr_offset_in_bytes(offset2)));
2329 }
2330 __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::trace_bytecode), Z_ARG2, Z_ARG3, Z_ARG4);
2331 __ z_lgr(Z_R14, Z_RET); // Estore return address (see above).
2332 __ pop(state);
2333
2334 __ bind(counter_below_trace_threshold);
2335 __ z_br(Z_R14); // return
2336
2337 return entry;
2338 }
2339
2340 // Make feasible for old CPUs.
count_bytecode()2341 void TemplateInterpreterGenerator::count_bytecode() {
2342 __ load_absolute_address(Z_R1_scratch, (address) &BytecodeCounter::_counter_value);
2343 __ add2mem_32(Address(Z_R1_scratch), 1, Z_R0_scratch);
2344 }
2345
histogram_bytecode(Template * t)2346 void TemplateInterpreterGenerator::histogram_bytecode(Template * t) {
2347 __ load_absolute_address(Z_R1_scratch, (address)&BytecodeHistogram::_counters[ t->bytecode() ]);
2348 __ add2mem_32(Address(Z_R1_scratch), 1, Z_tmp_1);
2349 }
2350
histogram_bytecode_pair(Template * t)2351 void TemplateInterpreterGenerator::histogram_bytecode_pair(Template * t) {
2352 Address index_addr(Z_tmp_1, (intptr_t) 0);
2353 Register index = Z_tmp_2;
2354
2355 // Load previous index.
2356 __ load_absolute_address(Z_tmp_1, (address) &BytecodePairHistogram::_index);
2357 __ mem2reg_opt(index, index_addr, false);
2358
2359 // Mask with current bytecode and store as new previous index.
2360 __ z_srl(index, BytecodePairHistogram::log2_number_of_codes);
2361 __ load_const_optimized(Z_R0_scratch,
2362 (int)t->bytecode() << BytecodePairHistogram::log2_number_of_codes);
2363 __ z_or(index, Z_R0_scratch);
2364 __ reg2mem_opt(index, index_addr, false);
2365
2366 // Load counter array's address.
2367 __ z_lgfr(index, index); // Sign extend for addressing.
2368 __ z_sllg(index, index, LogBytesPerInt); // index2bytes
2369 __ load_absolute_address(Z_R1_scratch,
2370 (address) &BytecodePairHistogram::_counters);
2371 // Add index and increment counter.
2372 __ z_agr(Z_R1_scratch, index);
2373 __ add2mem_32(Address(Z_R1_scratch), 1, Z_tmp_1);
2374 }
2375
trace_bytecode(Template * t)2376 void TemplateInterpreterGenerator::trace_bytecode(Template* t) {
2377 // Call a little run-time stub to avoid blow-up for each bytecode.
2378 // The run-time runtime saves the right registers, depending on
2379 // the tosca in-state for the given template.
2380 address entry = Interpreter::trace_code(t->tos_in());
2381 guarantee(entry != NULL, "entry must have been generated");
2382 __ call_stub(entry);
2383 }
2384
stop_interpreter_at()2385 void TemplateInterpreterGenerator::stop_interpreter_at() {
2386 NearLabel L;
2387
2388 __ load_absolute_address(Z_tmp_1, (address)&BytecodeCounter::_counter_value);
2389 __ load_absolute_address(Z_tmp_2, (address)&StopInterpreterAt);
2390 __ load_sized_value(Z_tmp_1, Address(Z_tmp_1), 4, false /*signed*/);
2391 __ load_sized_value(Z_tmp_2, Address(Z_tmp_2), 8, false /*signed*/);
2392 __ compareU64_and_branch(Z_tmp_1, Z_tmp_2, Assembler::bcondLow, L);
2393 assert(Z_tmp_1->is_nonvolatile(), "must be nonvolatile to preserve Z_tos");
2394 assert(Z_F8->is_nonvolatile(), "must be nonvolatile to preserve Z_ftos");
2395 __ z_lgr(Z_tmp_1, Z_tos); // Save tos.
2396 __ z_lgr(Z_tmp_2, Z_bytecode); // Save Z_bytecode.
2397 __ z_ldr(Z_F8, Z_ftos); // Save ftos.
2398 // Use -XX:StopInterpreterAt=<num> to set the limit
2399 // and break at breakpoint().
2400 __ call_VM(noreg, CAST_FROM_FN_PTR(address, breakpoint), false);
2401 __ z_lgr(Z_tos, Z_tmp_1); // Restore tos.
2402 __ z_lgr(Z_bytecode, Z_tmp_2); // Save Z_bytecode.
2403 __ z_ldr(Z_ftos, Z_F8); // Restore ftos.
2404 __ bind(L);
2405 }
2406
2407 #endif // !PRODUCT
2408