1 /*
2 * Copyright (c) 2003, 2022, Oracle and/or its affiliates. All rights reserved.
3 * Copyright (c) 2014, Red Hat Inc. 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 "compiler/compilerDefinitions.inline.hpp"
29 #include "gc/shared/barrierSetAssembler.hpp"
30 #include "gc/shared/collectedHeap.hpp"
31 #include "gc/shared/tlab_globals.hpp"
32 #include "interpreter/interpreter.hpp"
33 #include "interpreter/interpreterRuntime.hpp"
34 #include "interpreter/interp_masm.hpp"
35 #include "interpreter/templateTable.hpp"
36 #include "memory/universe.hpp"
37 #include "oops/methodData.hpp"
38 #include "oops/method.hpp"
39 #include "oops/objArrayKlass.hpp"
40 #include "oops/oop.inline.hpp"
41 #include "prims/jvmtiExport.hpp"
42 #include "prims/methodHandles.hpp"
43 #include "runtime/frame.inline.hpp"
44 #include "runtime/sharedRuntime.hpp"
45 #include "runtime/stubRoutines.hpp"
46 #include "runtime/synchronizer.hpp"
47 #include "utilities/powerOfTwo.hpp"
48
49 #define __ _masm->
50
51 // Address computation: local variables
52
53 static inline Address iaddress(int n) {
54 return Address(rlocals, Interpreter::local_offset_in_bytes(n));
55 }
56
57 static inline Address laddress(int n) {
58 return iaddress(n + 1);
59 }
60
61 static inline Address faddress(int n) {
62 return iaddress(n);
63 }
64
65 static inline Address daddress(int n) {
66 return laddress(n);
67 }
68
69 static inline Address aaddress(int n) {
70 return iaddress(n);
71 }
72
73 static inline Address iaddress(Register r) {
74 return Address(rlocals, r, Address::lsl(3));
75 }
76
77 static inline Address laddress(Register r, Register scratch,
78 InterpreterMacroAssembler* _masm) {
79 __ lea(scratch, Address(rlocals, r, Address::lsl(3)));
80 return Address(scratch, Interpreter::local_offset_in_bytes(1));
81 }
82
83 static inline Address faddress(Register r) {
84 return iaddress(r);
85 }
86
87 static inline Address daddress(Register r, Register scratch,
88 InterpreterMacroAssembler* _masm) {
89 return laddress(r, scratch, _masm);
90 }
91
92 static inline Address aaddress(Register r) {
93 return iaddress(r);
94 }
95
96 static inline Address at_rsp() {
97 return Address(esp, 0);
98 }
99
100 // At top of Java expression stack which may be different than esp(). It
101 // isn't for category 1 objects.
102 static inline Address at_tos () {
103 return Address(esp, Interpreter::expr_offset_in_bytes(0));
104 }
105
106 static inline Address at_tos_p1() {
107 return Address(esp, Interpreter::expr_offset_in_bytes(1));
108 }
109
110 static inline Address at_tos_p2() {
111 return Address(esp, Interpreter::expr_offset_in_bytes(2));
112 }
113
114 static inline Address at_tos_p3() {
115 return Address(esp, Interpreter::expr_offset_in_bytes(3));
116 }
117
118 static inline Address at_tos_p4() {
119 return Address(esp, Interpreter::expr_offset_in_bytes(4));
120 }
121
122 static inline Address at_tos_p5() {
123 return Address(esp, Interpreter::expr_offset_in_bytes(5));
124 }
125
126 // Condition conversion
127 static Assembler::Condition j_not(TemplateTable::Condition cc) {
128 switch (cc) {
129 case TemplateTable::equal : return Assembler::NE;
130 case TemplateTable::not_equal : return Assembler::EQ;
131 case TemplateTable::less : return Assembler::GE;
132 case TemplateTable::less_equal : return Assembler::GT;
133 case TemplateTable::greater : return Assembler::LE;
134 case TemplateTable::greater_equal: return Assembler::LT;
135 }
136 ShouldNotReachHere();
137 return Assembler::EQ;
138 }
139
140
141 // Miscellaneous helper routines
142 // Store an oop (or NULL) at the Address described by obj.
143 // If val == noreg this means store a NULL
144 static void do_oop_store(InterpreterMacroAssembler* _masm,
145 Address dst,
146 Register val,
147 DecoratorSet decorators) {
148 assert(val == noreg || val == r0, "parameter is just for looks");
149 __ store_heap_oop(dst, val, r10, r11, r3, decorators);
150 }
151
152 static void do_oop_load(InterpreterMacroAssembler* _masm,
153 Address src,
154 Register dst,
155 DecoratorSet decorators) {
156 __ load_heap_oop(dst, src, r10, r11, decorators);
157 }
158
159 Address TemplateTable::at_bcp(int offset) {
160 assert(_desc->uses_bcp(), "inconsistent uses_bcp information");
161 return Address(rbcp, offset);
162 }
163
164 void TemplateTable::patch_bytecode(Bytecodes::Code bc, Register bc_reg,
165 Register temp_reg, bool load_bc_into_bc_reg/*=true*/,
166 int byte_no)
167 {
168 if (!RewriteBytecodes) return;
169 Label L_patch_done;
170
171 switch (bc) {
172 case Bytecodes::_fast_qputfield:
173 case Bytecodes::_fast_aputfield:
174 case Bytecodes::_fast_bputfield:
175 case Bytecodes::_fast_zputfield:
176 case Bytecodes::_fast_cputfield:
177 case Bytecodes::_fast_dputfield:
178 case Bytecodes::_fast_fputfield:
179 case Bytecodes::_fast_iputfield:
180 case Bytecodes::_fast_lputfield:
181 case Bytecodes::_fast_sputfield:
182 {
183 // We skip bytecode quickening for putfield instructions when
184 // the put_code written to the constant pool cache is zero.
185 // This is required so that every execution of this instruction
186 // calls out to InterpreterRuntime::resolve_get_put to do
187 // additional, required work.
188 assert(byte_no == f1_byte || byte_no == f2_byte, "byte_no out of range");
189 assert(load_bc_into_bc_reg, "we use bc_reg as temp");
190 __ get_cache_and_index_and_bytecode_at_bcp(temp_reg, bc_reg, temp_reg, byte_no, 1);
191 __ movw(bc_reg, bc);
192 __ cbzw(temp_reg, L_patch_done); // don't patch
193 }
194 break;
195 default:
196 assert(byte_no == -1, "sanity");
197 // the pair bytecodes have already done the load.
198 if (load_bc_into_bc_reg) {
199 __ movw(bc_reg, bc);
200 }
201 }
202
203 if (JvmtiExport::can_post_breakpoint()) {
204 Label L_fast_patch;
205 // if a breakpoint is present we can't rewrite the stream directly
206 __ load_unsigned_byte(temp_reg, at_bcp(0));
207 __ cmpw(temp_reg, Bytecodes::_breakpoint);
208 __ br(Assembler::NE, L_fast_patch);
209 // Let breakpoint table handling rewrite to quicker bytecode
210 __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::set_original_bytecode_at), rmethod, rbcp, bc_reg);
211 __ b(L_patch_done);
212 __ bind(L_fast_patch);
213 }
214
215 #ifdef ASSERT
216 Label L_okay;
217 __ load_unsigned_byte(temp_reg, at_bcp(0));
218 __ cmpw(temp_reg, (int) Bytecodes::java_code(bc));
219 __ br(Assembler::EQ, L_okay);
220 __ cmpw(temp_reg, bc_reg);
221 __ br(Assembler::EQ, L_okay);
222 __ stop("patching the wrong bytecode");
223 __ bind(L_okay);
224 #endif
225
226 // patch bytecode
227 __ strb(bc_reg, at_bcp(0));
228 __ bind(L_patch_done);
229 }
230
231
232 // Individual instructions
233
234 void TemplateTable::nop() {
235 transition(vtos, vtos);
236 // nothing to do
237 }
238
239 void TemplateTable::shouldnotreachhere() {
240 transition(vtos, vtos);
241 __ stop("shouldnotreachhere bytecode");
242 }
243
244 void TemplateTable::aconst_null()
245 {
246 transition(vtos, atos);
247 __ mov(r0, 0);
248 }
249
250 void TemplateTable::iconst(int value)
251 {
252 transition(vtos, itos);
253 __ mov(r0, value);
254 }
255
256 void TemplateTable::lconst(int value)
257 {
258 __ mov(r0, value);
259 }
260
261 void TemplateTable::fconst(int value)
262 {
263 transition(vtos, ftos);
264 switch (value) {
265 case 0:
266 __ fmovs(v0, 0.0);
267 break;
268 case 1:
269 __ fmovs(v0, 1.0);
270 break;
271 case 2:
272 __ fmovs(v0, 2.0);
273 break;
274 default:
275 ShouldNotReachHere();
276 break;
277 }
278 }
279
280 void TemplateTable::dconst(int value)
281 {
282 transition(vtos, dtos);
283 switch (value) {
284 case 0:
285 __ fmovd(v0, 0.0);
286 break;
287 case 1:
288 __ fmovd(v0, 1.0);
289 break;
290 case 2:
291 __ fmovd(v0, 2.0);
292 break;
293 default:
294 ShouldNotReachHere();
295 break;
296 }
297 }
298
299 void TemplateTable::bipush()
300 {
301 transition(vtos, itos);
302 __ load_signed_byte32(r0, at_bcp(1));
303 }
304
305 void TemplateTable::sipush()
306 {
307 transition(vtos, itos);
308 __ load_unsigned_short(r0, at_bcp(1));
309 __ revw(r0, r0);
310 __ asrw(r0, r0, 16);
311 }
312
313 void TemplateTable::ldc(LdcType type)
314 {
315 transition(vtos, vtos);
316 Label call_ldc, notFloat, notClass, notInt, Done;
317
318 if (is_ldc_wide(type)) {
319 __ get_unsigned_2_byte_index_at_bcp(r1, 1);
320 } else {
321 __ load_unsigned_byte(r1, at_bcp(1));
322 }
323 __ get_cpool_and_tags(r2, r0);
324
325 const int base_offset = ConstantPool::header_size() * wordSize;
326 const int tags_offset = Array<u1>::base_offset_in_bytes();
327
328 // get type
329 __ add(r3, r1, tags_offset);
330 __ lea(r3, Address(r0, r3));
331 __ ldarb(r3, r3);
332 __ andr(r3, r3, ~JVM_CONSTANT_QDescBit);
333
334 // unresolved class - get the resolved class
335 __ cmp(r3, (u1)JVM_CONSTANT_UnresolvedClass);
336 __ br(Assembler::EQ, call_ldc);
337
338 // unresolved class in error state - call into runtime to throw the error
339 // from the first resolution attempt
340 __ cmp(r3, (u1)JVM_CONSTANT_UnresolvedClassInError);
341 __ br(Assembler::EQ, call_ldc);
342
343 // resolved class - need to call vm to get java mirror of the class
344 __ cmp(r3, (u1)JVM_CONSTANT_Class);
345 __ br(Assembler::NE, notClass);
346
347 __ bind(call_ldc);
348 __ mov(c_rarg1, is_ldc_wide(type) ? 1 : 0);
349 call_VM(r0, CAST_FROM_FN_PTR(address, InterpreterRuntime::ldc), c_rarg1);
350 __ push_ptr(r0);
351 __ verify_oop(r0);
352 __ b(Done);
353
354 __ bind(notClass);
355 __ cmp(r3, (u1)JVM_CONSTANT_Float);
356 __ br(Assembler::NE, notFloat);
357 // ftos
358 __ adds(r1, r2, r1, Assembler::LSL, 3);
359 __ ldrs(v0, Address(r1, base_offset));
360 __ push_f();
361 __ b(Done);
362
363 __ bind(notFloat);
364
365 __ cmp(r3, (u1)JVM_CONSTANT_Integer);
366 __ br(Assembler::NE, notInt);
367
368 // itos
369 __ adds(r1, r2, r1, Assembler::LSL, 3);
370 __ ldrw(r0, Address(r1, base_offset));
371 __ push_i(r0);
372 __ b(Done);
373
374 __ bind(notInt);
375 condy_helper(Done);
376
377 __ bind(Done);
378 }
379
380 // Fast path for caching oop constants.
381 void TemplateTable::fast_aldc(LdcType type)
382 {
383 transition(vtos, atos);
384
385 Register result = r0;
386 Register tmp = r1;
387 Register rarg = r2;
388
389 int index_size = is_ldc_wide(type) ? sizeof(u2) : sizeof(u1);
390
391 Label resolved;
392
393 // We are resolved if the resolved reference cache entry contains a
394 // non-null object (String, MethodType, etc.)
395 assert_different_registers(result, tmp);
396 __ get_cache_index_at_bcp(tmp, 1, index_size);
397 __ load_resolved_reference_at_index(result, tmp);
398 __ cbnz(result, resolved);
399
400 address entry = CAST_FROM_FN_PTR(address, InterpreterRuntime::resolve_ldc);
401
402 // first time invocation - must resolve first
403 __ mov(rarg, (int)bytecode());
404 __ call_VM(result, entry, rarg);
405
406 __ bind(resolved);
407
408 { // Check for the null sentinel.
409 // If we just called the VM, it already did the mapping for us,
410 // but it's harmless to retry.
411 Label notNull;
412
413 // Stash null_sentinel address to get its value later
414 __ movptr(rarg, (uintptr_t)Universe::the_null_sentinel_addr());
415 __ ldr(tmp, Address(rarg));
416 __ resolve_oop_handle(tmp, r5, rscratch2);
417 __ cmpoop(result, tmp);
418 __ br(Assembler::NE, notNull);
419 __ mov(result, 0); // NULL object reference
420 __ bind(notNull);
421 }
422
423 if (VerifyOops) {
424 // Safe to call with 0 result
425 __ verify_oop(result);
426 }
427 }
428
429 void TemplateTable::ldc2_w()
430 {
431 transition(vtos, vtos);
432 Label notDouble, notLong, Done;
433 __ get_unsigned_2_byte_index_at_bcp(r0, 1);
434
435 __ get_cpool_and_tags(r1, r2);
436 const int base_offset = ConstantPool::header_size() * wordSize;
437 const int tags_offset = Array<u1>::base_offset_in_bytes();
438
439 // get type
440 __ lea(r2, Address(r2, r0, Address::lsl(0)));
441 __ load_unsigned_byte(r2, Address(r2, tags_offset));
442 __ cmpw(r2, (int)JVM_CONSTANT_Double);
443 __ br(Assembler::NE, notDouble);
444
445 // dtos
446 __ lea (r2, Address(r1, r0, Address::lsl(3)));
447 __ ldrd(v0, Address(r2, base_offset));
448 __ push_d();
449 __ b(Done);
450
451 __ bind(notDouble);
452 __ cmpw(r2, (int)JVM_CONSTANT_Long);
453 __ br(Assembler::NE, notLong);
454
455 // ltos
456 __ lea(r0, Address(r1, r0, Address::lsl(3)));
457 __ ldr(r0, Address(r0, base_offset));
458 __ push_l();
459 __ b(Done);
460
461 __ bind(notLong);
462 condy_helper(Done);
463
464 __ bind(Done);
465 }
466
467 void TemplateTable::condy_helper(Label& Done)
468 {
469 Register obj = r0;
470 Register rarg = r1;
471 Register flags = r2;
472 Register off = r3;
473
474 address entry = CAST_FROM_FN_PTR(address, InterpreterRuntime::resolve_ldc);
475
476 __ mov(rarg, (int) bytecode());
477 __ call_VM(obj, entry, rarg);
478
479 __ get_vm_result_2(flags, rthread);
480
481 // VMr = obj = base address to find primitive value to push
482 // VMr2 = flags = (tos, off) using format of CPCE::_flags
483 __ mov(off, flags);
484 __ andw(off, off, ConstantPoolCacheEntry::field_index_mask);
485
486 const Address field(obj, off);
487
488 // What sort of thing are we loading?
489 // x86 uses a shift and mask or wings it with a shift plus assert
490 // the mask is not needed. aarch64 just uses bitfield extract
491 __ ubfxw(flags, flags, ConstantPoolCacheEntry::tos_state_shift,
492 ConstantPoolCacheEntry::tos_state_bits);
493
494 switch (bytecode()) {
495 case Bytecodes::_ldc:
496 case Bytecodes::_ldc_w:
497 {
498 // tos in (itos, ftos, stos, btos, ctos, ztos)
499 Label notInt, notFloat, notShort, notByte, notChar, notBool;
500 __ cmpw(flags, itos);
501 __ br(Assembler::NE, notInt);
502 // itos
503 __ ldrw(r0, field);
504 __ push(itos);
505 __ b(Done);
506
507 __ bind(notInt);
508 __ cmpw(flags, ftos);
509 __ br(Assembler::NE, notFloat);
510 // ftos
511 __ load_float(field);
512 __ push(ftos);
513 __ b(Done);
514
515 __ bind(notFloat);
516 __ cmpw(flags, stos);
517 __ br(Assembler::NE, notShort);
518 // stos
519 __ load_signed_short(r0, field);
520 __ push(stos);
521 __ b(Done);
522
523 __ bind(notShort);
524 __ cmpw(flags, btos);
525 __ br(Assembler::NE, notByte);
526 // btos
527 __ load_signed_byte(r0, field);
528 __ push(btos);
529 __ b(Done);
530
531 __ bind(notByte);
532 __ cmpw(flags, ctos);
533 __ br(Assembler::NE, notChar);
534 // ctos
535 __ load_unsigned_short(r0, field);
536 __ push(ctos);
537 __ b(Done);
538
539 __ bind(notChar);
540 __ cmpw(flags, ztos);
541 __ br(Assembler::NE, notBool);
542 // ztos
543 __ load_signed_byte(r0, field);
544 __ push(ztos);
545 __ b(Done);
546
547 __ bind(notBool);
548 break;
549 }
550
551 case Bytecodes::_ldc2_w:
552 {
553 Label notLong, notDouble;
554 __ cmpw(flags, ltos);
555 __ br(Assembler::NE, notLong);
556 // ltos
557 __ ldr(r0, field);
558 __ push(ltos);
559 __ b(Done);
560
561 __ bind(notLong);
562 __ cmpw(flags, dtos);
563 __ br(Assembler::NE, notDouble);
564 // dtos
565 __ load_double(field);
566 __ push(dtos);
567 __ b(Done);
568
569 __ bind(notDouble);
570 break;
571 }
572
573 default:
574 ShouldNotReachHere();
575 }
576
577 __ stop("bad ldc/condy");
578 }
579
580 void TemplateTable::locals_index(Register reg, int offset)
581 {
582 __ ldrb(reg, at_bcp(offset));
583 __ neg(reg, reg);
584 }
585
586 void TemplateTable::iload() {
587 iload_internal();
588 }
589
590 void TemplateTable::nofast_iload() {
591 iload_internal(may_not_rewrite);
592 }
593
594 void TemplateTable::iload_internal(RewriteControl rc) {
595 transition(vtos, itos);
596 if (RewriteFrequentPairs && rc == may_rewrite) {
597 Label rewrite, done;
598 Register bc = r4;
599
600 // get next bytecode
601 __ load_unsigned_byte(r1, at_bcp(Bytecodes::length_for(Bytecodes::_iload)));
602
603 // if _iload, wait to rewrite to iload2. We only want to rewrite the
604 // last two iloads in a pair. Comparing against fast_iload means that
605 // the next bytecode is neither an iload or a caload, and therefore
606 // an iload pair.
607 __ cmpw(r1, Bytecodes::_iload);
608 __ br(Assembler::EQ, done);
609
610 // if _fast_iload rewrite to _fast_iload2
611 __ cmpw(r1, Bytecodes::_fast_iload);
612 __ movw(bc, Bytecodes::_fast_iload2);
613 __ br(Assembler::EQ, rewrite);
614
615 // if _caload rewrite to _fast_icaload
616 __ cmpw(r1, Bytecodes::_caload);
617 __ movw(bc, Bytecodes::_fast_icaload);
618 __ br(Assembler::EQ, rewrite);
619
620 // else rewrite to _fast_iload
621 __ movw(bc, Bytecodes::_fast_iload);
622
623 // rewrite
624 // bc: new bytecode
625 __ bind(rewrite);
626 patch_bytecode(Bytecodes::_iload, bc, r1, false);
627 __ bind(done);
628
629 }
630
631 // do iload, get the local value into tos
632 locals_index(r1);
633 __ ldr(r0, iaddress(r1));
634
635 }
636
637 void TemplateTable::fast_iload2()
638 {
639 transition(vtos, itos);
640 locals_index(r1);
641 __ ldr(r0, iaddress(r1));
642 __ push(itos);
643 locals_index(r1, 3);
644 __ ldr(r0, iaddress(r1));
645 }
646
647 void TemplateTable::fast_iload()
648 {
649 transition(vtos, itos);
650 locals_index(r1);
651 __ ldr(r0, iaddress(r1));
652 }
653
654 void TemplateTable::lload()
655 {
656 transition(vtos, ltos);
657 __ ldrb(r1, at_bcp(1));
658 __ sub(r1, rlocals, r1, ext::uxtw, LogBytesPerWord);
659 __ ldr(r0, Address(r1, Interpreter::local_offset_in_bytes(1)));
660 }
661
662 void TemplateTable::fload()
663 {
664 transition(vtos, ftos);
665 locals_index(r1);
666 // n.b. we use ldrd here because this is a 64 bit slot
667 // this is comparable to the iload case
668 __ ldrd(v0, faddress(r1));
669 }
670
671 void TemplateTable::dload()
672 {
673 transition(vtos, dtos);
674 __ ldrb(r1, at_bcp(1));
675 __ sub(r1, rlocals, r1, ext::uxtw, LogBytesPerWord);
676 __ ldrd(v0, Address(r1, Interpreter::local_offset_in_bytes(1)));
677 }
678
679 void TemplateTable::aload()
680 {
681 transition(vtos, atos);
682 locals_index(r1);
683 __ ldr(r0, iaddress(r1));
684 }
685
686 void TemplateTable::locals_index_wide(Register reg) {
687 __ ldrh(reg, at_bcp(2));
688 __ rev16w(reg, reg);
689 __ neg(reg, reg);
690 }
691
692 void TemplateTable::wide_iload() {
693 transition(vtos, itos);
694 locals_index_wide(r1);
695 __ ldr(r0, iaddress(r1));
696 }
697
698 void TemplateTable::wide_lload()
699 {
700 transition(vtos, ltos);
701 __ ldrh(r1, at_bcp(2));
702 __ rev16w(r1, r1);
703 __ sub(r1, rlocals, r1, ext::uxtw, LogBytesPerWord);
704 __ ldr(r0, Address(r1, Interpreter::local_offset_in_bytes(1)));
705 }
706
707 void TemplateTable::wide_fload()
708 {
709 transition(vtos, ftos);
710 locals_index_wide(r1);
711 // n.b. we use ldrd here because this is a 64 bit slot
712 // this is comparable to the iload case
713 __ ldrd(v0, faddress(r1));
714 }
715
716 void TemplateTable::wide_dload()
717 {
718 transition(vtos, dtos);
719 __ ldrh(r1, at_bcp(2));
720 __ rev16w(r1, r1);
721 __ sub(r1, rlocals, r1, ext::uxtw, LogBytesPerWord);
722 __ ldrd(v0, Address(r1, Interpreter::local_offset_in_bytes(1)));
723 }
724
725 void TemplateTable::wide_aload()
726 {
727 transition(vtos, atos);
728 locals_index_wide(r1);
729 __ ldr(r0, aaddress(r1));
730 }
731
732 void TemplateTable::index_check(Register array, Register index)
733 {
734 // destroys r1, rscratch1
735 // check array
736 __ null_check(array, arrayOopDesc::length_offset_in_bytes());
737 // sign extend index for use by indexed load
738 // __ movl2ptr(index, index);
739 // check index
740 Register length = rscratch1;
741 __ ldrw(length, Address(array, arrayOopDesc::length_offset_in_bytes()));
742 __ cmpw(index, length);
743 if (index != r1) {
744 // ??? convention: move aberrant index into r1 for exception message
745 assert(r1 != array, "different registers");
746 __ mov(r1, index);
747 }
748 Label ok;
749 __ br(Assembler::LO, ok);
750 // ??? convention: move array into r3 for exception message
751 __ mov(r3, array);
752 __ mov(rscratch1, Interpreter::_throw_ArrayIndexOutOfBoundsException_entry);
753 __ br(rscratch1);
754 __ bind(ok);
755 }
756
757 void TemplateTable::iaload()
758 {
759 transition(itos, itos);
760 __ mov(r1, r0);
761 __ pop_ptr(r0);
762 // r0: array
763 // r1: index
764 index_check(r0, r1); // leaves index in r1, kills rscratch1
765 __ add(r1, r1, arrayOopDesc::base_offset_in_bytes(T_INT) >> 2);
766 __ access_load_at(T_INT, IN_HEAP | IS_ARRAY, r0, Address(r0, r1, Address::uxtw(2)), noreg, noreg);
767 }
768
769 void TemplateTable::laload()
770 {
771 transition(itos, ltos);
772 __ mov(r1, r0);
773 __ pop_ptr(r0);
774 // r0: array
775 // r1: index
776 index_check(r0, r1); // leaves index in r1, kills rscratch1
777 __ add(r1, r1, arrayOopDesc::base_offset_in_bytes(T_LONG) >> 3);
778 __ access_load_at(T_LONG, IN_HEAP | IS_ARRAY, r0, Address(r0, r1, Address::uxtw(3)), noreg, noreg);
779 }
780
781 void TemplateTable::faload()
782 {
783 transition(itos, ftos);
784 __ mov(r1, r0);
785 __ pop_ptr(r0);
786 // r0: array
787 // r1: index
788 index_check(r0, r1); // leaves index in r1, kills rscratch1
789 __ add(r1, r1, arrayOopDesc::base_offset_in_bytes(T_FLOAT) >> 2);
790 __ access_load_at(T_FLOAT, IN_HEAP | IS_ARRAY, r0, Address(r0, r1, Address::uxtw(2)), noreg, noreg);
791 }
792
793 void TemplateTable::daload()
794 {
795 transition(itos, dtos);
796 __ mov(r1, r0);
797 __ pop_ptr(r0);
798 // r0: array
799 // r1: index
800 index_check(r0, r1); // leaves index in r1, kills rscratch1
801 __ add(r1, r1, arrayOopDesc::base_offset_in_bytes(T_DOUBLE) >> 3);
802 __ access_load_at(T_DOUBLE, IN_HEAP | IS_ARRAY, r0, Address(r0, r1, Address::uxtw(3)), noreg, noreg);
803 }
804
805 void TemplateTable::aaload()
806 {
807 transition(itos, atos);
808 __ mov(r1, r0);
809 __ pop_ptr(r0);
810 // r0: array
811 // r1: index
812 index_check(r0, r1); // leaves index in r1, kills rscratch1
813 __ profile_array(r2, r0, r4);
814 if (UseFlatArray) {
815 Label is_flat_array, done;
816
817 __ test_flattened_array_oop(r0, r8 /*temp*/, is_flat_array);
818 __ add(r1, r1, arrayOopDesc::base_offset_in_bytes(T_OBJECT) >> LogBytesPerHeapOop);
819 do_oop_load(_masm, Address(r0, r1, Address::uxtw(LogBytesPerHeapOop)), r0, IS_ARRAY);
820
821 __ b(done);
822 __ bind(is_flat_array);
823 __ call_VM(r0, CAST_FROM_FN_PTR(address, InterpreterRuntime::value_array_load), r0, r1);
824 __ bind(done);
825 } else {
826 __ add(r1, r1, arrayOopDesc::base_offset_in_bytes(T_OBJECT) >> LogBytesPerHeapOop);
827 do_oop_load(_masm, Address(r0, r1, Address::uxtw(LogBytesPerHeapOop)), r0, IS_ARRAY);
828 }
829 __ profile_element(r2, r0, r4);
830 }
831
832 void TemplateTable::baload()
833 {
834 transition(itos, itos);
835 __ mov(r1, r0);
836 __ pop_ptr(r0);
837 // r0: array
838 // r1: index
839 index_check(r0, r1); // leaves index in r1, kills rscratch1
840 __ add(r1, r1, arrayOopDesc::base_offset_in_bytes(T_BYTE) >> 0);
841 __ access_load_at(T_BYTE, IN_HEAP | IS_ARRAY, r0, Address(r0, r1, Address::uxtw(0)), noreg, noreg);
842 }
843
844 void TemplateTable::caload()
845 {
846 transition(itos, itos);
847 __ mov(r1, r0);
848 __ pop_ptr(r0);
849 // r0: array
850 // r1: index
851 index_check(r0, r1); // leaves index in r1, kills rscratch1
852 __ add(r1, r1, arrayOopDesc::base_offset_in_bytes(T_CHAR) >> 1);
853 __ access_load_at(T_CHAR, IN_HEAP | IS_ARRAY, r0, Address(r0, r1, Address::uxtw(1)), noreg, noreg);
854 }
855
856 // iload followed by caload frequent pair
857 void TemplateTable::fast_icaload()
858 {
859 transition(vtos, itos);
860 // load index out of locals
861 locals_index(r2);
862 __ ldr(r1, iaddress(r2));
863
864 __ pop_ptr(r0);
865
866 // r0: array
867 // r1: index
868 index_check(r0, r1); // leaves index in r1, kills rscratch1
869 __ add(r1, r1, arrayOopDesc::base_offset_in_bytes(T_CHAR) >> 1);
870 __ access_load_at(T_CHAR, IN_HEAP | IS_ARRAY, r0, Address(r0, r1, Address::uxtw(1)), noreg, noreg);
871 }
872
873 void TemplateTable::saload()
874 {
875 transition(itos, itos);
876 __ mov(r1, r0);
877 __ pop_ptr(r0);
878 // r0: array
879 // r1: index
880 index_check(r0, r1); // leaves index in r1, kills rscratch1
881 __ add(r1, r1, arrayOopDesc::base_offset_in_bytes(T_SHORT) >> 1);
882 __ access_load_at(T_SHORT, IN_HEAP | IS_ARRAY, r0, Address(r0, r1, Address::uxtw(1)), noreg, noreg);
883 }
884
885 void TemplateTable::iload(int n)
886 {
887 transition(vtos, itos);
888 __ ldr(r0, iaddress(n));
889 }
890
891 void TemplateTable::lload(int n)
892 {
893 transition(vtos, ltos);
894 __ ldr(r0, laddress(n));
895 }
896
897 void TemplateTable::fload(int n)
898 {
899 transition(vtos, ftos);
900 __ ldrs(v0, faddress(n));
901 }
902
903 void TemplateTable::dload(int n)
904 {
905 transition(vtos, dtos);
906 __ ldrd(v0, daddress(n));
907 }
908
909 void TemplateTable::aload(int n)
910 {
911 transition(vtos, atos);
912 __ ldr(r0, iaddress(n));
913 }
914
915 void TemplateTable::aload_0() {
916 aload_0_internal();
917 }
918
919 void TemplateTable::nofast_aload_0() {
920 aload_0_internal(may_not_rewrite);
921 }
922
923 void TemplateTable::aload_0_internal(RewriteControl rc) {
924 // According to bytecode histograms, the pairs:
925 //
926 // _aload_0, _fast_igetfield
927 // _aload_0, _fast_agetfield
928 // _aload_0, _fast_fgetfield
929 //
930 // occur frequently. If RewriteFrequentPairs is set, the (slow)
931 // _aload_0 bytecode checks if the next bytecode is either
932 // _fast_igetfield, _fast_agetfield or _fast_fgetfield and then
933 // rewrites the current bytecode into a pair bytecode; otherwise it
934 // rewrites the current bytecode into _fast_aload_0 that doesn't do
935 // the pair check anymore.
936 //
937 // Note: If the next bytecode is _getfield, the rewrite must be
938 // delayed, otherwise we may miss an opportunity for a pair.
939 //
940 // Also rewrite frequent pairs
941 // aload_0, aload_1
942 // aload_0, iload_1
943 // These bytecodes with a small amount of code are most profitable
944 // to rewrite
945 if (RewriteFrequentPairs && rc == may_rewrite) {
946 Label rewrite, done;
947 const Register bc = r4;
948
949 // get next bytecode
950 __ load_unsigned_byte(r1, at_bcp(Bytecodes::length_for(Bytecodes::_aload_0)));
951
952 // if _getfield then wait with rewrite
953 __ cmpw(r1, Bytecodes::Bytecodes::_getfield);
954 __ br(Assembler::EQ, done);
955
956 // if _igetfield then rewrite to _fast_iaccess_0
957 assert(Bytecodes::java_code(Bytecodes::_fast_iaccess_0) == Bytecodes::_aload_0, "fix bytecode definition");
958 __ cmpw(r1, Bytecodes::_fast_igetfield);
959 __ movw(bc, Bytecodes::_fast_iaccess_0);
960 __ br(Assembler::EQ, rewrite);
961
962 // if _agetfield then rewrite to _fast_aaccess_0
963 assert(Bytecodes::java_code(Bytecodes::_fast_aaccess_0) == Bytecodes::_aload_0, "fix bytecode definition");
964 __ cmpw(r1, Bytecodes::_fast_agetfield);
965 __ movw(bc, Bytecodes::_fast_aaccess_0);
966 __ br(Assembler::EQ, rewrite);
967
968 // if _fgetfield then rewrite to _fast_faccess_0
969 assert(Bytecodes::java_code(Bytecodes::_fast_faccess_0) == Bytecodes::_aload_0, "fix bytecode definition");
970 __ cmpw(r1, Bytecodes::_fast_fgetfield);
971 __ movw(bc, Bytecodes::_fast_faccess_0);
972 __ br(Assembler::EQ, rewrite);
973
974 // else rewrite to _fast_aload0
975 assert(Bytecodes::java_code(Bytecodes::_fast_aload_0) == Bytecodes::_aload_0, "fix bytecode definition");
976 __ movw(bc, Bytecodes::Bytecodes::_fast_aload_0);
977
978 // rewrite
979 // bc: new bytecode
980 __ bind(rewrite);
981 patch_bytecode(Bytecodes::_aload_0, bc, r1, false);
982
983 __ bind(done);
984 }
985
986 // Do actual aload_0 (must do this after patch_bytecode which might call VM and GC might change oop).
987 aload(0);
988 }
989
990 void TemplateTable::istore()
991 {
992 transition(itos, vtos);
993 locals_index(r1);
994 // FIXME: We're being very pernickerty here storing a jint in a
995 // local with strw, which costs an extra instruction over what we'd
996 // be able to do with a simple str. We should just store the whole
997 // word.
998 __ lea(rscratch1, iaddress(r1));
999 __ strw(r0, Address(rscratch1));
1000 }
1001
1002 void TemplateTable::lstore()
1003 {
1004 transition(ltos, vtos);
1005 locals_index(r1);
1006 __ str(r0, laddress(r1, rscratch1, _masm));
1007 }
1008
1009 void TemplateTable::fstore() {
1010 transition(ftos, vtos);
1011 locals_index(r1);
1012 __ lea(rscratch1, iaddress(r1));
1013 __ strs(v0, Address(rscratch1));
1014 }
1015
1016 void TemplateTable::dstore() {
1017 transition(dtos, vtos);
1018 locals_index(r1);
1019 __ strd(v0, daddress(r1, rscratch1, _masm));
1020 }
1021
1022 void TemplateTable::astore()
1023 {
1024 transition(vtos, vtos);
1025 __ pop_ptr(r0);
1026 locals_index(r1);
1027 __ str(r0, aaddress(r1));
1028 }
1029
1030 void TemplateTable::wide_istore() {
1031 transition(vtos, vtos);
1032 __ pop_i();
1033 locals_index_wide(r1);
1034 __ lea(rscratch1, iaddress(r1));
1035 __ strw(r0, Address(rscratch1));
1036 }
1037
1038 void TemplateTable::wide_lstore() {
1039 transition(vtos, vtos);
1040 __ pop_l();
1041 locals_index_wide(r1);
1042 __ str(r0, laddress(r1, rscratch1, _masm));
1043 }
1044
1045 void TemplateTable::wide_fstore() {
1046 transition(vtos, vtos);
1047 __ pop_f();
1048 locals_index_wide(r1);
1049 __ lea(rscratch1, faddress(r1));
1050 __ strs(v0, rscratch1);
1051 }
1052
1053 void TemplateTable::wide_dstore() {
1054 transition(vtos, vtos);
1055 __ pop_d();
1056 locals_index_wide(r1);
1057 __ strd(v0, daddress(r1, rscratch1, _masm));
1058 }
1059
1060 void TemplateTable::wide_astore() {
1061 transition(vtos, vtos);
1062 __ pop_ptr(r0);
1063 locals_index_wide(r1);
1064 __ str(r0, aaddress(r1));
1065 }
1066
1067 void TemplateTable::iastore() {
1068 transition(itos, vtos);
1069 __ pop_i(r1);
1070 __ pop_ptr(r3);
1071 // r0: value
1072 // r1: index
1073 // r3: array
1074 index_check(r3, r1); // prefer index in r1
1075 __ add(r1, r1, arrayOopDesc::base_offset_in_bytes(T_INT) >> 2);
1076 __ access_store_at(T_INT, IN_HEAP | IS_ARRAY, Address(r3, r1, Address::uxtw(2)), r0, noreg, noreg, noreg);
1077 }
1078
1079 void TemplateTable::lastore() {
1080 transition(ltos, vtos);
1081 __ pop_i(r1);
1082 __ pop_ptr(r3);
1083 // r0: value
1084 // r1: index
1085 // r3: array
1086 index_check(r3, r1); // prefer index in r1
1087 __ add(r1, r1, arrayOopDesc::base_offset_in_bytes(T_LONG) >> 3);
1088 __ access_store_at(T_LONG, IN_HEAP | IS_ARRAY, Address(r3, r1, Address::uxtw(3)), r0, noreg, noreg, noreg);
1089 }
1090
1091 void TemplateTable::fastore() {
1092 transition(ftos, vtos);
1093 __ pop_i(r1);
1094 __ pop_ptr(r3);
1095 // v0: value
1096 // r1: index
1097 // r3: array
1098 index_check(r3, r1); // prefer index in r1
1099 __ add(r1, r1, arrayOopDesc::base_offset_in_bytes(T_FLOAT) >> 2);
1100 __ access_store_at(T_FLOAT, IN_HEAP | IS_ARRAY, Address(r3, r1, Address::uxtw(2)), noreg /* ftos */, noreg, noreg, noreg);
1101 }
1102
1103 void TemplateTable::dastore() {
1104 transition(dtos, vtos);
1105 __ pop_i(r1);
1106 __ pop_ptr(r3);
1107 // v0: value
1108 // r1: index
1109 // r3: array
1110 index_check(r3, r1); // prefer index in r1
1111 __ add(r1, r1, arrayOopDesc::base_offset_in_bytes(T_DOUBLE) >> 3);
1112 __ access_store_at(T_DOUBLE, IN_HEAP | IS_ARRAY, Address(r3, r1, Address::uxtw(3)), noreg /* dtos */, noreg, noreg, noreg);
1113 }
1114
1115 void TemplateTable::aastore() {
1116 Label is_null, is_flat_array, ok_is_subtype, done;
1117 transition(vtos, vtos);
1118 // stack: ..., array, index, value
1119 __ ldr(r0, at_tos()); // value
1120 __ ldr(r2, at_tos_p1()); // index
1121 __ ldr(r3, at_tos_p2()); // array
1122
1123 index_check(r3, r2); // kills r1
1124
1125 __ profile_array(r4, r3, r5);
1126 __ profile_element(r4, r0, r5);
1127
1128 __ add(r4, r2, arrayOopDesc::base_offset_in_bytes(T_OBJECT) >> LogBytesPerHeapOop);
1129 Address element_address(r3, r4, Address::uxtw(LogBytesPerHeapOop));
1130 // Be careful not to clobber r4 below
1131
1132 // do array store check - check for NULL value first
1133 __ cbz(r0, is_null);
1134
1135 // Move array class to r5
1136 __ load_klass(r5, r3);
1137
1138 if (UseFlatArray) {
1139 __ ldrw(r6, Address(r5, Klass::layout_helper_offset()));
1140 __ test_flattened_array_layout(r6, is_flat_array);
1141 }
1142
1143 // Move subklass into r1
1144 __ load_klass(r1, r0);
1145
1146 // Move array element superklass into r0
1147 __ ldr(r0, Address(r5, ObjArrayKlass::element_klass_offset()));
1148 // Compress array + index*oopSize + 12 into a single register. Frees r2.
1149
1150 // Generate subtype check. Blows r2, r5
1151 // Superklass in r0. Subklass in r1.
1152
1153 // is "r1 <: r0" ? (value subclass <: array element superclass)
1154 __ gen_subtype_check(r1, ok_is_subtype, false);
1155
1156 // Come here on failure
1157 // object is at TOS
1158 __ b(Interpreter::_throw_ArrayStoreException_entry);
1159
1160 // Come here on success
1161 __ bind(ok_is_subtype);
1162
1163 // Get the value we will store
1164 __ ldr(r0, at_tos());
1165 // Now store using the appropriate barrier
1166 do_oop_store(_masm, element_address, r0, IS_ARRAY);
1167 __ b(done);
1168
1169 // Have a NULL in r0, r3=array, r2=index. Store NULL at ary[idx]
1170 __ bind(is_null);
1171 if (EnablePrimitiveClasses) {
1172 Label is_null_into_value_array_npe, store_null;
1173
1174 // No way to store null in flat null-free array
1175 __ test_null_free_array_oop(r3, r8, is_null_into_value_array_npe);
1176 __ b(store_null);
1177
1178 __ bind(is_null_into_value_array_npe);
1179 __ b(ExternalAddress(Interpreter::_throw_NullPointerException_entry));
1180
1181 __ bind(store_null);
1182 }
1183
1184 // Store a NULL
1185 do_oop_store(_masm, element_address, noreg, IS_ARRAY);
1186 __ b(done);
1187
1188 if (UseFlatArray) {
1189 Label is_type_ok;
1190 __ bind(is_flat_array); // Store non-null value to flat
1191
1192 // Simplistic type check...
1193 // r0 - value, r2 - index, r3 - array.
1194
1195 // Profile the not-null value's klass.
1196 // Load value class
1197 __ load_klass(r1, r0);
1198
1199 // Move element klass into r7
1200 __ ldr(r7, Address(r5, ArrayKlass::element_klass_offset()));
1201
1202 // flat value array needs exact type match
1203 // is "r1 == r7" (value subclass == array element superclass)
1204
1205 __ cmp(r7, r1);
1206 __ br(Assembler::EQ, is_type_ok);
1207
1208 __ b(ExternalAddress(Interpreter::_throw_ArrayStoreException_entry));
1209
1210 __ bind(is_type_ok);
1211 // r1: value's klass
1212 // r3: array
1213 // r5: array klass
1214 __ test_klass_is_empty_inline_type(r1, r7, done);
1215
1216 // calc dst for copy
1217 __ ldrw(r7, at_tos_p1()); // index
1218 __ data_for_value_array_index(r3, r5, r7, r7);
1219
1220 // ...and src for copy
1221 __ ldr(r6, at_tos()); // value
1222 __ data_for_oop(r6, r6, r1);
1223
1224 __ mov(r4, r1); // Shuffle arguments to avoid conflict with c_rarg1
1225 __ access_value_copy(IN_HEAP, r6, r7, r4);
1226 }
1227
1228 // Pop stack arguments
1229 __ bind(done);
1230 __ add(esp, esp, 3 * Interpreter::stackElementSize);
1231 }
1232
1233 void TemplateTable::bastore()
1234 {
1235 transition(itos, vtos);
1236 __ pop_i(r1);
1237 __ pop_ptr(r3);
1238 // r0: value
1239 // r1: index
1240 // r3: array
1241 index_check(r3, r1); // prefer index in r1
1242
1243 // Need to check whether array is boolean or byte
1244 // since both types share the bastore bytecode.
1245 __ load_klass(r2, r3);
1246 __ ldrw(r2, Address(r2, Klass::layout_helper_offset()));
1247 int diffbit_index = exact_log2(Klass::layout_helper_boolean_diffbit());
1248 Label L_skip;
1249 __ tbz(r2, diffbit_index, L_skip);
1250 __ andw(r0, r0, 1); // if it is a T_BOOLEAN array, mask the stored value to 0/1
1251 __ bind(L_skip);
1252
1253 __ add(r1, r1, arrayOopDesc::base_offset_in_bytes(T_BYTE) >> 0);
1254 __ access_store_at(T_BYTE, IN_HEAP | IS_ARRAY, Address(r3, r1, Address::uxtw(0)), r0, noreg, noreg, noreg);
1255 }
1256
1257 void TemplateTable::castore()
1258 {
1259 transition(itos, vtos);
1260 __ pop_i(r1);
1261 __ pop_ptr(r3);
1262 // r0: value
1263 // r1: index
1264 // r3: array
1265 index_check(r3, r1); // prefer index in r1
1266 __ add(r1, r1, arrayOopDesc::base_offset_in_bytes(T_CHAR) >> 1);
1267 __ access_store_at(T_CHAR, IN_HEAP | IS_ARRAY, Address(r3, r1, Address::uxtw(1)), r0, noreg, noreg, noreg);
1268 }
1269
1270 void TemplateTable::sastore()
1271 {
1272 castore();
1273 }
1274
1275 void TemplateTable::istore(int n)
1276 {
1277 transition(itos, vtos);
1278 __ str(r0, iaddress(n));
1279 }
1280
1281 void TemplateTable::lstore(int n)
1282 {
1283 transition(ltos, vtos);
1284 __ str(r0, laddress(n));
1285 }
1286
1287 void TemplateTable::fstore(int n)
1288 {
1289 transition(ftos, vtos);
1290 __ strs(v0, faddress(n));
1291 }
1292
1293 void TemplateTable::dstore(int n)
1294 {
1295 transition(dtos, vtos);
1296 __ strd(v0, daddress(n));
1297 }
1298
1299 void TemplateTable::astore(int n)
1300 {
1301 transition(vtos, vtos);
1302 __ pop_ptr(r0);
1303 __ str(r0, iaddress(n));
1304 }
1305
1306 void TemplateTable::pop()
1307 {
1308 transition(vtos, vtos);
1309 __ add(esp, esp, Interpreter::stackElementSize);
1310 }
1311
1312 void TemplateTable::pop2()
1313 {
1314 transition(vtos, vtos);
1315 __ add(esp, esp, 2 * Interpreter::stackElementSize);
1316 }
1317
1318 void TemplateTable::dup()
1319 {
1320 transition(vtos, vtos);
1321 __ ldr(r0, Address(esp, 0));
1322 __ push(r0);
1323 // stack: ..., a, a
1324 }
1325
1326 void TemplateTable::dup_x1()
1327 {
1328 transition(vtos, vtos);
1329 // stack: ..., a, b
1330 __ ldr(r0, at_tos()); // load b
1331 __ ldr(r2, at_tos_p1()); // load a
1332 __ str(r0, at_tos_p1()); // store b
1333 __ str(r2, at_tos()); // store a
1334 __ push(r0); // push b
1335 // stack: ..., b, a, b
1336 }
1337
1338 void TemplateTable::dup_x2()
1339 {
1340 transition(vtos, vtos);
1341 // stack: ..., a, b, c
1342 __ ldr(r0, at_tos()); // load c
1343 __ ldr(r2, at_tos_p2()); // load a
1344 __ str(r0, at_tos_p2()); // store c in a
1345 __ push(r0); // push c
1346 // stack: ..., c, b, c, c
1347 __ ldr(r0, at_tos_p2()); // load b
1348 __ str(r2, at_tos_p2()); // store a in b
1349 // stack: ..., c, a, c, c
1350 __ str(r0, at_tos_p1()); // store b in c
1351 // stack: ..., c, a, b, c
1352 }
1353
1354 void TemplateTable::dup2()
1355 {
1356 transition(vtos, vtos);
1357 // stack: ..., a, b
1358 __ ldr(r0, at_tos_p1()); // load a
1359 __ push(r0); // push a
1360 __ ldr(r0, at_tos_p1()); // load b
1361 __ push(r0); // push b
1362 // stack: ..., a, b, a, b
1363 }
1364
1365 void TemplateTable::dup2_x1()
1366 {
1367 transition(vtos, vtos);
1368 // stack: ..., a, b, c
1369 __ ldr(r2, at_tos()); // load c
1370 __ ldr(r0, at_tos_p1()); // load b
1371 __ push(r0); // push b
1372 __ push(r2); // push c
1373 // stack: ..., a, b, c, b, c
1374 __ str(r2, at_tos_p3()); // store c in b
1375 // stack: ..., a, c, c, b, c
1376 __ ldr(r2, at_tos_p4()); // load a
1377 __ str(r2, at_tos_p2()); // store a in 2nd c
1378 // stack: ..., a, c, a, b, c
1379 __ str(r0, at_tos_p4()); // store b in a
1380 // stack: ..., b, c, a, b, c
1381 }
1382
1383 void TemplateTable::dup2_x2()
1384 {
1385 transition(vtos, vtos);
1386 // stack: ..., a, b, c, d
1387 __ ldr(r2, at_tos()); // load d
1388 __ ldr(r0, at_tos_p1()); // load c
1389 __ push(r0) ; // push c
1390 __ push(r2); // push d
1391 // stack: ..., a, b, c, d, c, d
1392 __ ldr(r0, at_tos_p4()); // load b
1393 __ str(r0, at_tos_p2()); // store b in d
1394 __ str(r2, at_tos_p4()); // store d in b
1395 // stack: ..., a, d, c, b, c, d
1396 __ ldr(r2, at_tos_p5()); // load a
1397 __ ldr(r0, at_tos_p3()); // load c
1398 __ str(r2, at_tos_p3()); // store a in c
1399 __ str(r0, at_tos_p5()); // store c in a
1400 // stack: ..., c, d, a, b, c, d
1401 }
1402
1403 void TemplateTable::swap()
1404 {
1405 transition(vtos, vtos);
1406 // stack: ..., a, b
1407 __ ldr(r2, at_tos_p1()); // load a
1408 __ ldr(r0, at_tos()); // load b
1409 __ str(r2, at_tos()); // store a in b
1410 __ str(r0, at_tos_p1()); // store b in a
1411 // stack: ..., b, a
1412 }
1413
1414 void TemplateTable::iop2(Operation op)
1415 {
1416 transition(itos, itos);
1417 // r0 <== r1 op r0
1418 __ pop_i(r1);
1419 switch (op) {
1420 case add : __ addw(r0, r1, r0); break;
1421 case sub : __ subw(r0, r1, r0); break;
1422 case mul : __ mulw(r0, r1, r0); break;
1423 case _and : __ andw(r0, r1, r0); break;
1424 case _or : __ orrw(r0, r1, r0); break;
1425 case _xor : __ eorw(r0, r1, r0); break;
1426 case shl : __ lslvw(r0, r1, r0); break;
1427 case shr : __ asrvw(r0, r1, r0); break;
1428 case ushr : __ lsrvw(r0, r1, r0);break;
1429 default : ShouldNotReachHere();
1430 }
1431 }
1432
1433 void TemplateTable::lop2(Operation op)
1434 {
1435 transition(ltos, ltos);
1436 // r0 <== r1 op r0
1437 __ pop_l(r1);
1438 switch (op) {
1439 case add : __ add(r0, r1, r0); break;
1440 case sub : __ sub(r0, r1, r0); break;
1441 case mul : __ mul(r0, r1, r0); break;
1442 case _and : __ andr(r0, r1, r0); break;
1443 case _or : __ orr(r0, r1, r0); break;
1444 case _xor : __ eor(r0, r1, r0); break;
1445 default : ShouldNotReachHere();
1446 }
1447 }
1448
1449 void TemplateTable::idiv()
1450 {
1451 transition(itos, itos);
1452 // explicitly check for div0
1453 Label no_div0;
1454 __ cbnzw(r0, no_div0);
1455 __ mov(rscratch1, Interpreter::_throw_ArithmeticException_entry);
1456 __ br(rscratch1);
1457 __ bind(no_div0);
1458 __ pop_i(r1);
1459 // r0 <== r1 idiv r0
1460 __ corrected_idivl(r0, r1, r0, /* want_remainder */ false);
1461 }
1462
1463 void TemplateTable::irem()
1464 {
1465 transition(itos, itos);
1466 // explicitly check for div0
1467 Label no_div0;
1468 __ cbnzw(r0, no_div0);
1469 __ mov(rscratch1, Interpreter::_throw_ArithmeticException_entry);
1470 __ br(rscratch1);
1471 __ bind(no_div0);
1472 __ pop_i(r1);
1473 // r0 <== r1 irem r0
1474 __ corrected_idivl(r0, r1, r0, /* want_remainder */ true);
1475 }
1476
1477 void TemplateTable::lmul()
1478 {
1479 transition(ltos, ltos);
1480 __ pop_l(r1);
1481 __ mul(r0, r0, r1);
1482 }
1483
1484 void TemplateTable::ldiv()
1485 {
1486 transition(ltos, ltos);
1487 // explicitly check for div0
1488 Label no_div0;
1489 __ cbnz(r0, no_div0);
1490 __ mov(rscratch1, Interpreter::_throw_ArithmeticException_entry);
1491 __ br(rscratch1);
1492 __ bind(no_div0);
1493 __ pop_l(r1);
1494 // r0 <== r1 ldiv r0
1495 __ corrected_idivq(r0, r1, r0, /* want_remainder */ false);
1496 }
1497
1498 void TemplateTable::lrem()
1499 {
1500 transition(ltos, ltos);
1501 // explicitly check for div0
1502 Label no_div0;
1503 __ cbnz(r0, no_div0);
1504 __ mov(rscratch1, Interpreter::_throw_ArithmeticException_entry);
1505 __ br(rscratch1);
1506 __ bind(no_div0);
1507 __ pop_l(r1);
1508 // r0 <== r1 lrem r0
1509 __ corrected_idivq(r0, r1, r0, /* want_remainder */ true);
1510 }
1511
1512 void TemplateTable::lshl()
1513 {
1514 transition(itos, ltos);
1515 // shift count is in r0
1516 __ pop_l(r1);
1517 __ lslv(r0, r1, r0);
1518 }
1519
1520 void TemplateTable::lshr()
1521 {
1522 transition(itos, ltos);
1523 // shift count is in r0
1524 __ pop_l(r1);
1525 __ asrv(r0, r1, r0);
1526 }
1527
1528 void TemplateTable::lushr()
1529 {
1530 transition(itos, ltos);
1531 // shift count is in r0
1532 __ pop_l(r1);
1533 __ lsrv(r0, r1, r0);
1534 }
1535
1536 void TemplateTable::fop2(Operation op)
1537 {
1538 transition(ftos, ftos);
1539 switch (op) {
1540 case add:
1541 // n.b. use ldrd because this is a 64 bit slot
1542 __ pop_f(v1);
1543 __ fadds(v0, v1, v0);
1544 break;
1545 case sub:
1546 __ pop_f(v1);
1547 __ fsubs(v0, v1, v0);
1548 break;
1549 case mul:
1550 __ pop_f(v1);
1551 __ fmuls(v0, v1, v0);
1552 break;
1553 case div:
1554 __ pop_f(v1);
1555 __ fdivs(v0, v1, v0);
1556 break;
1557 case rem:
1558 __ fmovs(v1, v0);
1559 __ pop_f(v0);
1560 __ call_VM_leaf(CAST_FROM_FN_PTR(address, SharedRuntime::frem));
1561 break;
1562 default:
1563 ShouldNotReachHere();
1564 break;
1565 }
1566 }
1567
1568 void TemplateTable::dop2(Operation op)
1569 {
1570 transition(dtos, dtos);
1571 switch (op) {
1572 case add:
1573 // n.b. use ldrd because this is a 64 bit slot
1574 __ pop_d(v1);
1575 __ faddd(v0, v1, v0);
1576 break;
1577 case sub:
1578 __ pop_d(v1);
1579 __ fsubd(v0, v1, v0);
1580 break;
1581 case mul:
1582 __ pop_d(v1);
1583 __ fmuld(v0, v1, v0);
1584 break;
1585 case div:
1586 __ pop_d(v1);
1587 __ fdivd(v0, v1, v0);
1588 break;
1589 case rem:
1590 __ fmovd(v1, v0);
1591 __ pop_d(v0);
1592 __ call_VM_leaf(CAST_FROM_FN_PTR(address, SharedRuntime::drem));
1593 break;
1594 default:
1595 ShouldNotReachHere();
1596 break;
1597 }
1598 }
1599
1600 void TemplateTable::ineg()
1601 {
1602 transition(itos, itos);
1603 __ negw(r0, r0);
1604
1605 }
1606
1607 void TemplateTable::lneg()
1608 {
1609 transition(ltos, ltos);
1610 __ neg(r0, r0);
1611 }
1612
1613 void TemplateTable::fneg()
1614 {
1615 transition(ftos, ftos);
1616 __ fnegs(v0, v0);
1617 }
1618
1619 void TemplateTable::dneg()
1620 {
1621 transition(dtos, dtos);
1622 __ fnegd(v0, v0);
1623 }
1624
1625 void TemplateTable::iinc()
1626 {
1627 transition(vtos, vtos);
1628 __ load_signed_byte(r1, at_bcp(2)); // get constant
1629 locals_index(r2);
1630 __ ldr(r0, iaddress(r2));
1631 __ addw(r0, r0, r1);
1632 __ str(r0, iaddress(r2));
1633 }
1634
1635 void TemplateTable::wide_iinc()
1636 {
1637 transition(vtos, vtos);
1638 // __ mov(r1, zr);
1639 __ ldrw(r1, at_bcp(2)); // get constant and index
1640 __ rev16(r1, r1);
1641 __ ubfx(r2, r1, 0, 16);
1642 __ neg(r2, r2);
1643 __ sbfx(r1, r1, 16, 16);
1644 __ ldr(r0, iaddress(r2));
1645 __ addw(r0, r0, r1);
1646 __ str(r0, iaddress(r2));
1647 }
1648
1649 void TemplateTable::convert()
1650 {
1651 // Checking
1652 #ifdef ASSERT
1653 {
1654 TosState tos_in = ilgl;
1655 TosState tos_out = ilgl;
1656 switch (bytecode()) {
1657 case Bytecodes::_i2l: // fall through
1658 case Bytecodes::_i2f: // fall through
1659 case Bytecodes::_i2d: // fall through
1660 case Bytecodes::_i2b: // fall through
1661 case Bytecodes::_i2c: // fall through
1662 case Bytecodes::_i2s: tos_in = itos; break;
1663 case Bytecodes::_l2i: // fall through
1664 case Bytecodes::_l2f: // fall through
1665 case Bytecodes::_l2d: tos_in = ltos; break;
1666 case Bytecodes::_f2i: // fall through
1667 case Bytecodes::_f2l: // fall through
1668 case Bytecodes::_f2d: tos_in = ftos; break;
1669 case Bytecodes::_d2i: // fall through
1670 case Bytecodes::_d2l: // fall through
1671 case Bytecodes::_d2f: tos_in = dtos; break;
1672 default : ShouldNotReachHere();
1673 }
1674 switch (bytecode()) {
1675 case Bytecodes::_l2i: // fall through
1676 case Bytecodes::_f2i: // fall through
1677 case Bytecodes::_d2i: // fall through
1678 case Bytecodes::_i2b: // fall through
1679 case Bytecodes::_i2c: // fall through
1680 case Bytecodes::_i2s: tos_out = itos; break;
1681 case Bytecodes::_i2l: // fall through
1682 case Bytecodes::_f2l: // fall through
1683 case Bytecodes::_d2l: tos_out = ltos; break;
1684 case Bytecodes::_i2f: // fall through
1685 case Bytecodes::_l2f: // fall through
1686 case Bytecodes::_d2f: tos_out = ftos; break;
1687 case Bytecodes::_i2d: // fall through
1688 case Bytecodes::_l2d: // fall through
1689 case Bytecodes::_f2d: tos_out = dtos; break;
1690 default : ShouldNotReachHere();
1691 }
1692 transition(tos_in, tos_out);
1693 }
1694 #endif // ASSERT
1695 // static const int64_t is_nan = 0x8000000000000000L;
1696
1697 // Conversion
1698 switch (bytecode()) {
1699 case Bytecodes::_i2l:
1700 __ sxtw(r0, r0);
1701 break;
1702 case Bytecodes::_i2f:
1703 __ scvtfws(v0, r0);
1704 break;
1705 case Bytecodes::_i2d:
1706 __ scvtfwd(v0, r0);
1707 break;
1708 case Bytecodes::_i2b:
1709 __ sxtbw(r0, r0);
1710 break;
1711 case Bytecodes::_i2c:
1712 __ uxthw(r0, r0);
1713 break;
1714 case Bytecodes::_i2s:
1715 __ sxthw(r0, r0);
1716 break;
1717 case Bytecodes::_l2i:
1718 __ uxtw(r0, r0);
1719 break;
1720 case Bytecodes::_l2f:
1721 __ scvtfs(v0, r0);
1722 break;
1723 case Bytecodes::_l2d:
1724 __ scvtfd(v0, r0);
1725 break;
1726 case Bytecodes::_f2i:
1727 {
1728 Label L_Okay;
1729 __ clear_fpsr();
1730 __ fcvtzsw(r0, v0);
1731 __ get_fpsr(r1);
1732 __ cbzw(r1, L_Okay);
1733 __ call_VM_leaf(CAST_FROM_FN_PTR(address, SharedRuntime::f2i));
1734 __ bind(L_Okay);
1735 }
1736 break;
1737 case Bytecodes::_f2l:
1738 {
1739 Label L_Okay;
1740 __ clear_fpsr();
1741 __ fcvtzs(r0, v0);
1742 __ get_fpsr(r1);
1743 __ cbzw(r1, L_Okay);
1744 __ call_VM_leaf(CAST_FROM_FN_PTR(address, SharedRuntime::f2l));
1745 __ bind(L_Okay);
1746 }
1747 break;
1748 case Bytecodes::_f2d:
1749 __ fcvts(v0, v0);
1750 break;
1751 case Bytecodes::_d2i:
1752 {
1753 Label L_Okay;
1754 __ clear_fpsr();
1755 __ fcvtzdw(r0, v0);
1756 __ get_fpsr(r1);
1757 __ cbzw(r1, L_Okay);
1758 __ call_VM_leaf(CAST_FROM_FN_PTR(address, SharedRuntime::d2i));
1759 __ bind(L_Okay);
1760 }
1761 break;
1762 case Bytecodes::_d2l:
1763 {
1764 Label L_Okay;
1765 __ clear_fpsr();
1766 __ fcvtzd(r0, v0);
1767 __ get_fpsr(r1);
1768 __ cbzw(r1, L_Okay);
1769 __ call_VM_leaf(CAST_FROM_FN_PTR(address, SharedRuntime::d2l));
1770 __ bind(L_Okay);
1771 }
1772 break;
1773 case Bytecodes::_d2f:
1774 __ fcvtd(v0, v0);
1775 break;
1776 default:
1777 ShouldNotReachHere();
1778 }
1779 }
1780
1781 void TemplateTable::lcmp()
1782 {
1783 transition(ltos, itos);
1784 Label done;
1785 __ pop_l(r1);
1786 __ cmp(r1, r0);
1787 __ mov(r0, (uint64_t)-1L);
1788 __ br(Assembler::LT, done);
1789 // __ mov(r0, 1UL);
1790 // __ csel(r0, r0, zr, Assembler::NE);
1791 // and here is a faster way
1792 __ csinc(r0, zr, zr, Assembler::EQ);
1793 __ bind(done);
1794 }
1795
1796 void TemplateTable::float_cmp(bool is_float, int unordered_result)
1797 {
1798 Label done;
1799 if (is_float) {
1800 // XXX get rid of pop here, use ... reg, mem32
1801 __ pop_f(v1);
1802 __ fcmps(v1, v0);
1803 } else {
1804 // XXX get rid of pop here, use ... reg, mem64
1805 __ pop_d(v1);
1806 __ fcmpd(v1, v0);
1807 }
1808 if (unordered_result < 0) {
1809 // we want -1 for unordered or less than, 0 for equal and 1 for
1810 // greater than.
1811 __ mov(r0, (uint64_t)-1L);
1812 // for FP LT tests less than or unordered
1813 __ br(Assembler::LT, done);
1814 // install 0 for EQ otherwise 1
1815 __ csinc(r0, zr, zr, Assembler::EQ);
1816 } else {
1817 // we want -1 for less than, 0 for equal and 1 for unordered or
1818 // greater than.
1819 __ mov(r0, 1L);
1820 // for FP HI tests greater than or unordered
1821 __ br(Assembler::HI, done);
1822 // install 0 for EQ otherwise ~0
1823 __ csinv(r0, zr, zr, Assembler::EQ);
1824
1825 }
1826 __ bind(done);
1827 }
1828
1829 void TemplateTable::branch(bool is_jsr, bool is_wide)
1830 {
1831 // We might be moving to a safepoint. The thread which calls
1832 // Interpreter::notice_safepoints() will effectively flush its cache
1833 // when it makes a system call, but we need to do something to
1834 // ensure that we see the changed dispatch table.
1835 __ membar(MacroAssembler::LoadLoad);
1836
1837 __ profile_taken_branch(r0, r1);
1838 const ByteSize be_offset = MethodCounters::backedge_counter_offset() +
1839 InvocationCounter::counter_offset();
1840 const ByteSize inv_offset = MethodCounters::invocation_counter_offset() +
1841 InvocationCounter::counter_offset();
1842
1843 // load branch displacement
1844 if (!is_wide) {
1845 __ ldrh(r2, at_bcp(1));
1846 __ rev16(r2, r2);
1847 // sign extend the 16 bit value in r2
1848 __ sbfm(r2, r2, 0, 15);
1849 } else {
1850 __ ldrw(r2, at_bcp(1));
1851 __ revw(r2, r2);
1852 // sign extend the 32 bit value in r2
1853 __ sbfm(r2, r2, 0, 31);
1854 }
1855
1856 // Handle all the JSR stuff here, then exit.
1857 // It's much shorter and cleaner than intermingling with the non-JSR
1858 // normal-branch stuff occurring below.
1859
1860 if (is_jsr) {
1861 // Pre-load the next target bytecode into rscratch1
1862 __ load_unsigned_byte(rscratch1, Address(rbcp, r2));
1863 // compute return address as bci
1864 __ ldr(rscratch2, Address(rmethod, Method::const_offset()));
1865 __ add(rscratch2, rscratch2,
1866 in_bytes(ConstMethod::codes_offset()) - (is_wide ? 5 : 3));
1867 __ sub(r1, rbcp, rscratch2);
1868 __ push_i(r1);
1869 // Adjust the bcp by the 16-bit displacement in r2
1870 __ add(rbcp, rbcp, r2);
1871 __ dispatch_only(vtos, /*generate_poll*/true);
1872 return;
1873 }
1874
1875 // Normal (non-jsr) branch handling
1876
1877 // Adjust the bcp by the displacement in r2
1878 __ add(rbcp, rbcp, r2);
1879
1880 assert(UseLoopCounter || !UseOnStackReplacement,
1881 "on-stack-replacement requires loop counters");
1882 Label backedge_counter_overflow;
1883 Label dispatch;
1884 if (UseLoopCounter) {
1885 // increment backedge counter for backward branches
1886 // r0: MDO
1887 // w1: MDO bumped taken-count
1888 // r2: target offset
1889 __ cmp(r2, zr);
1890 __ br(Assembler::GT, dispatch); // count only if backward branch
1891
1892 // ECN: FIXME: This code smells
1893 // check if MethodCounters exists
1894 Label has_counters;
1895 __ ldr(rscratch1, Address(rmethod, Method::method_counters_offset()));
1896 __ cbnz(rscratch1, has_counters);
1897 __ push(r0);
1898 __ push(r1);
1899 __ push(r2);
1900 __ call_VM(noreg, CAST_FROM_FN_PTR(address,
1901 InterpreterRuntime::build_method_counters), rmethod);
1902 __ pop(r2);
1903 __ pop(r1);
1904 __ pop(r0);
1905 __ ldr(rscratch1, Address(rmethod, Method::method_counters_offset()));
1906 __ cbz(rscratch1, dispatch); // No MethodCounters allocated, OutOfMemory
1907 __ bind(has_counters);
1908
1909 Label no_mdo;
1910 int increment = InvocationCounter::count_increment;
1911 if (ProfileInterpreter) {
1912 // Are we profiling?
1913 __ ldr(r1, Address(rmethod, in_bytes(Method::method_data_offset())));
1914 __ cbz(r1, no_mdo);
1915 // Increment the MDO backedge counter
1916 const Address mdo_backedge_counter(r1, in_bytes(MethodData::backedge_counter_offset()) +
1917 in_bytes(InvocationCounter::counter_offset()));
1918 const Address mask(r1, in_bytes(MethodData::backedge_mask_offset()));
1919 __ increment_mask_and_jump(mdo_backedge_counter, increment, mask,
1920 r0, rscratch1, false, Assembler::EQ,
1921 UseOnStackReplacement ? &backedge_counter_overflow : &dispatch);
1922 __ b(dispatch);
1923 }
1924 __ bind(no_mdo);
1925 // Increment backedge counter in MethodCounters*
1926 __ ldr(rscratch1, Address(rmethod, Method::method_counters_offset()));
1927 const Address mask(rscratch1, in_bytes(MethodCounters::backedge_mask_offset()));
1928 __ increment_mask_and_jump(Address(rscratch1, be_offset), increment, mask,
1929 r0, rscratch2, false, Assembler::EQ,
1930 UseOnStackReplacement ? &backedge_counter_overflow : &dispatch);
1931 __ bind(dispatch);
1932 }
1933
1934 // Pre-load the next target bytecode into rscratch1
1935 __ load_unsigned_byte(rscratch1, Address(rbcp, 0));
1936
1937 // continue with the bytecode @ target
1938 // rscratch1: target bytecode
1939 // rbcp: target bcp
1940 __ dispatch_only(vtos, /*generate_poll*/true);
1941
1942 if (UseLoopCounter && UseOnStackReplacement) {
1943 // invocation counter overflow
1944 __ bind(backedge_counter_overflow);
1945 __ neg(r2, r2);
1946 __ add(r2, r2, rbcp); // branch bcp
1947 // IcoResult frequency_counter_overflow([JavaThread*], address branch_bcp)
1948 __ call_VM(noreg,
1949 CAST_FROM_FN_PTR(address,
1950 InterpreterRuntime::frequency_counter_overflow),
1951 r2);
1952 __ load_unsigned_byte(r1, Address(rbcp, 0)); // restore target bytecode
1953
1954 // r0: osr nmethod (osr ok) or NULL (osr not possible)
1955 // w1: target bytecode
1956 // r2: scratch
1957 __ cbz(r0, dispatch); // test result -- no osr if null
1958 // nmethod may have been invalidated (VM may block upon call_VM return)
1959 __ ldrb(r2, Address(r0, nmethod::state_offset()));
1960 if (nmethod::in_use != 0)
1961 __ sub(r2, r2, nmethod::in_use);
1962 __ cbnz(r2, dispatch);
1963
1964 // We have the address of an on stack replacement routine in r0
1965 // We need to prepare to execute the OSR method. First we must
1966 // migrate the locals and monitors off of the stack.
1967
1968 __ mov(r19, r0); // save the nmethod
1969
1970 call_VM(noreg, CAST_FROM_FN_PTR(address, SharedRuntime::OSR_migration_begin));
1971
1972 // r0 is OSR buffer, move it to expected parameter location
1973 __ mov(j_rarg0, r0);
1974
1975 // remove activation
1976 // get sender esp
1977 __ ldr(esp,
1978 Address(rfp, frame::interpreter_frame_sender_sp_offset * wordSize));
1979 // remove frame anchor
1980 __ leave();
1981 // Ensure compiled code always sees stack at proper alignment
1982 __ andr(sp, esp, -16);
1983
1984 // and begin the OSR nmethod
1985 __ ldr(rscratch1, Address(r19, nmethod::osr_entry_point_offset()));
1986 __ br(rscratch1);
1987 }
1988 }
1989
1990
1991 void TemplateTable::if_0cmp(Condition cc)
1992 {
1993 transition(itos, vtos);
1994 // assume branch is more often taken than not (loops use backward branches)
1995 Label not_taken;
1996 if (cc == equal)
1997 __ cbnzw(r0, not_taken);
1998 else if (cc == not_equal)
1999 __ cbzw(r0, not_taken);
2000 else {
2001 __ andsw(zr, r0, r0);
2002 __ br(j_not(cc), not_taken);
2003 }
2004
2005 branch(false, false);
2006 __ bind(not_taken);
2007 __ profile_not_taken_branch(r0);
2008 }
2009
2010 void TemplateTable::if_icmp(Condition cc)
2011 {
2012 transition(itos, vtos);
2013 // assume branch is more often taken than not (loops use backward branches)
2014 Label not_taken;
2015 __ pop_i(r1);
2016 __ cmpw(r1, r0, Assembler::LSL);
2017 __ br(j_not(cc), not_taken);
2018 branch(false, false);
2019 __ bind(not_taken);
2020 __ profile_not_taken_branch(r0);
2021 }
2022
2023 void TemplateTable::if_nullcmp(Condition cc)
2024 {
2025 transition(atos, vtos);
2026 // assume branch is more often taken than not (loops use backward branches)
2027 Label not_taken;
2028 if (cc == equal)
2029 __ cbnz(r0, not_taken);
2030 else
2031 __ cbz(r0, not_taken);
2032 branch(false, false);
2033 __ bind(not_taken);
2034 __ profile_not_taken_branch(r0);
2035 }
2036
2037 void TemplateTable::if_acmp(Condition cc) {
2038 transition(atos, vtos);
2039 // assume branch is more often taken than not (loops use backward branches)
2040 Label taken, not_taken;
2041 __ pop_ptr(r1);
2042
2043 __ profile_acmp(r2, r1, r0, r4);
2044
2045 Register is_inline_type_mask = rscratch1;
2046 __ mov(is_inline_type_mask, markWord::inline_type_pattern);
2047
2048 if (EnableValhalla) {
2049 __ cmp(r1, r0);
2050 __ br(Assembler::EQ, (cc == equal) ? taken : not_taken);
2051
2052 // might be substitutable, test if either r0 or r1 is null
2053 __ andr(r2, r0, r1);
2054 __ cbz(r2, (cc == equal) ? not_taken : taken);
2055
2056 // and both are values ?
2057 __ ldr(r2, Address(r1, oopDesc::mark_offset_in_bytes()));
2058 __ andr(r2, r2, is_inline_type_mask);
2059 __ ldr(r4, Address(r0, oopDesc::mark_offset_in_bytes()));
2060 __ andr(r4, r4, is_inline_type_mask);
2061 __ andr(r2, r2, r4);
2062 __ cmp(r2, is_inline_type_mask);
2063 __ br(Assembler::NE, (cc == equal) ? not_taken : taken);
2064
2065 // same value klass ?
2066 __ load_metadata(r2, r1);
2067 __ load_metadata(r4, r0);
2068 __ cmp(r2, r4);
2069 __ br(Assembler::NE, (cc == equal) ? not_taken : taken);
2070
2071 // Know both are the same type, let's test for substitutability...
2072 if (cc == equal) {
2073 invoke_is_substitutable(r0, r1, taken, not_taken);
2074 } else {
2075 invoke_is_substitutable(r0, r1, not_taken, taken);
2076 }
2077 __ stop("Not reachable");
2078 }
2079
2080 __ cmpoop(r1, r0);
2081 __ br(j_not(cc), not_taken);
2082 __ bind(taken);
2083 branch(false, false);
2084 __ bind(not_taken);
2085 __ profile_not_taken_branch(r0, true);
2086 }
2087
2088 void TemplateTable::invoke_is_substitutable(Register aobj, Register bobj,
2089 Label& is_subst, Label& not_subst) {
2090
2091 __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::is_substitutable), aobj, bobj);
2092 // Restored... r0 answer, jmp to outcome...
2093 __ cbz(r0, not_subst);
2094 __ b(is_subst);
2095 }
2096
2097
2098 void TemplateTable::ret() {
2099 transition(vtos, vtos);
2100 // We might be moving to a safepoint. The thread which calls
2101 // Interpreter::notice_safepoints() will effectively flush its cache
2102 // when it makes a system call, but we need to do something to
2103 // ensure that we see the changed dispatch table.
2104 __ membar(MacroAssembler::LoadLoad);
2105
2106 locals_index(r1);
2107 __ ldr(r1, aaddress(r1)); // get return bci, compute return bcp
2108 __ profile_ret(r1, r2);
2109 __ ldr(rbcp, Address(rmethod, Method::const_offset()));
2110 __ lea(rbcp, Address(rbcp, r1));
2111 __ add(rbcp, rbcp, in_bytes(ConstMethod::codes_offset()));
2112 __ dispatch_next(vtos, 0, /*generate_poll*/true);
2113 }
2114
2115 void TemplateTable::wide_ret() {
2116 transition(vtos, vtos);
2117 locals_index_wide(r1);
2118 __ ldr(r1, aaddress(r1)); // get return bci, compute return bcp
2119 __ profile_ret(r1, r2);
2120 __ ldr(rbcp, Address(rmethod, Method::const_offset()));
2121 __ lea(rbcp, Address(rbcp, r1));
2122 __ add(rbcp, rbcp, in_bytes(ConstMethod::codes_offset()));
2123 __ dispatch_next(vtos, 0, /*generate_poll*/true);
2124 }
2125
2126
2127 void TemplateTable::tableswitch() {
2128 Label default_case, continue_execution;
2129 transition(itos, vtos);
2130 // align rbcp
2131 __ lea(r1, at_bcp(BytesPerInt));
2132 __ andr(r1, r1, -BytesPerInt);
2133 // load lo & hi
2134 __ ldrw(r2, Address(r1, BytesPerInt));
2135 __ ldrw(r3, Address(r1, 2 * BytesPerInt));
2136 __ rev32(r2, r2);
2137 __ rev32(r3, r3);
2138 // check against lo & hi
2139 __ cmpw(r0, r2);
2140 __ br(Assembler::LT, default_case);
2141 __ cmpw(r0, r3);
2142 __ br(Assembler::GT, default_case);
2143 // lookup dispatch offset
2144 __ subw(r0, r0, r2);
2145 __ lea(r3, Address(r1, r0, Address::uxtw(2)));
2146 __ ldrw(r3, Address(r3, 3 * BytesPerInt));
2147 __ profile_switch_case(r0, r1, r2);
2148 // continue execution
2149 __ bind(continue_execution);
2150 __ rev32(r3, r3);
2151 __ load_unsigned_byte(rscratch1, Address(rbcp, r3, Address::sxtw(0)));
2152 __ add(rbcp, rbcp, r3, ext::sxtw);
2153 __ dispatch_only(vtos, /*generate_poll*/true);
2154 // handle default
2155 __ bind(default_case);
2156 __ profile_switch_default(r0);
2157 __ ldrw(r3, Address(r1, 0));
2158 __ b(continue_execution);
2159 }
2160
2161 void TemplateTable::lookupswitch() {
2162 transition(itos, itos);
2163 __ stop("lookupswitch bytecode should have been rewritten");
2164 }
2165
2166 void TemplateTable::fast_linearswitch() {
2167 transition(itos, vtos);
2168 Label loop_entry, loop, found, continue_execution;
2169 // bswap r0 so we can avoid bswapping the table entries
2170 __ rev32(r0, r0);
2171 // align rbcp
2172 __ lea(r19, at_bcp(BytesPerInt)); // btw: should be able to get rid of
2173 // this instruction (change offsets
2174 // below)
2175 __ andr(r19, r19, -BytesPerInt);
2176 // set counter
2177 __ ldrw(r1, Address(r19, BytesPerInt));
2178 __ rev32(r1, r1);
2179 __ b(loop_entry);
2180 // table search
2181 __ bind(loop);
2182 __ lea(rscratch1, Address(r19, r1, Address::lsl(3)));
2183 __ ldrw(rscratch1, Address(rscratch1, 2 * BytesPerInt));
2184 __ cmpw(r0, rscratch1);
2185 __ br(Assembler::EQ, found);
2186 __ bind(loop_entry);
2187 __ subs(r1, r1, 1);
2188 __ br(Assembler::PL, loop);
2189 // default case
2190 __ profile_switch_default(r0);
2191 __ ldrw(r3, Address(r19, 0));
2192 __ b(continue_execution);
2193 // entry found -> get offset
2194 __ bind(found);
2195 __ lea(rscratch1, Address(r19, r1, Address::lsl(3)));
2196 __ ldrw(r3, Address(rscratch1, 3 * BytesPerInt));
2197 __ profile_switch_case(r1, r0, r19);
2198 // continue execution
2199 __ bind(continue_execution);
2200 __ rev32(r3, r3);
2201 __ add(rbcp, rbcp, r3, ext::sxtw);
2202 __ ldrb(rscratch1, Address(rbcp, 0));
2203 __ dispatch_only(vtos, /*generate_poll*/true);
2204 }
2205
2206 void TemplateTable::fast_binaryswitch() {
2207 transition(itos, vtos);
2208 // Implementation using the following core algorithm:
2209 //
2210 // int binary_search(int key, LookupswitchPair* array, int n) {
2211 // // Binary search according to "Methodik des Programmierens" by
2212 // // Edsger W. Dijkstra and W.H.J. Feijen, Addison Wesley Germany 1985.
2213 // int i = 0;
2214 // int j = n;
2215 // while (i+1 < j) {
2216 // // invariant P: 0 <= i < j <= n and (a[i] <= key < a[j] or Q)
2217 // // with Q: for all i: 0 <= i < n: key < a[i]
2218 // // where a stands for the array and assuming that the (inexisting)
2219 // // element a[n] is infinitely big.
2220 // int h = (i + j) >> 1;
2221 // // i < h < j
2222 // if (key < array[h].fast_match()) {
2223 // j = h;
2224 // } else {
2225 // i = h;
2226 // }
2227 // }
2228 // // R: a[i] <= key < a[i+1] or Q
2229 // // (i.e., if key is within array, i is the correct index)
2230 // return i;
2231 // }
2232
2233 // Register allocation
2234 const Register key = r0; // already set (tosca)
2235 const Register array = r1;
2236 const Register i = r2;
2237 const Register j = r3;
2238 const Register h = rscratch1;
2239 const Register temp = rscratch2;
2240
2241 // Find array start
2242 __ lea(array, at_bcp(3 * BytesPerInt)); // btw: should be able to
2243 // get rid of this
2244 // instruction (change
2245 // offsets below)
2246 __ andr(array, array, -BytesPerInt);
2247
2248 // Initialize i & j
2249 __ mov(i, 0); // i = 0;
2250 __ ldrw(j, Address(array, -BytesPerInt)); // j = length(array);
2251
2252 // Convert j into native byteordering
2253 __ rev32(j, j);
2254
2255 // And start
2256 Label entry;
2257 __ b(entry);
2258
2259 // binary search loop
2260 {
2261 Label loop;
2262 __ bind(loop);
2263 // int h = (i + j) >> 1;
2264 __ addw(h, i, j); // h = i + j;
2265 __ lsrw(h, h, 1); // h = (i + j) >> 1;
2266 // if (key < array[h].fast_match()) {
2267 // j = h;
2268 // } else {
2269 // i = h;
2270 // }
2271 // Convert array[h].match to native byte-ordering before compare
2272 __ ldr(temp, Address(array, h, Address::lsl(3)));
2273 __ rev32(temp, temp);
2274 __ cmpw(key, temp);
2275 // j = h if (key < array[h].fast_match())
2276 __ csel(j, h, j, Assembler::LT);
2277 // i = h if (key >= array[h].fast_match())
2278 __ csel(i, h, i, Assembler::GE);
2279 // while (i+1 < j)
2280 __ bind(entry);
2281 __ addw(h, i, 1); // i+1
2282 __ cmpw(h, j); // i+1 < j
2283 __ br(Assembler::LT, loop);
2284 }
2285
2286 // end of binary search, result index is i (must check again!)
2287 Label default_case;
2288 // Convert array[i].match to native byte-ordering before compare
2289 __ ldr(temp, Address(array, i, Address::lsl(3)));
2290 __ rev32(temp, temp);
2291 __ cmpw(key, temp);
2292 __ br(Assembler::NE, default_case);
2293
2294 // entry found -> j = offset
2295 __ add(j, array, i, ext::uxtx, 3);
2296 __ ldrw(j, Address(j, BytesPerInt));
2297 __ profile_switch_case(i, key, array);
2298 __ rev32(j, j);
2299 __ load_unsigned_byte(rscratch1, Address(rbcp, j, Address::sxtw(0)));
2300 __ lea(rbcp, Address(rbcp, j, Address::sxtw(0)));
2301 __ dispatch_only(vtos, /*generate_poll*/true);
2302
2303 // default case -> j = default offset
2304 __ bind(default_case);
2305 __ profile_switch_default(i);
2306 __ ldrw(j, Address(array, -2 * BytesPerInt));
2307 __ rev32(j, j);
2308 __ load_unsigned_byte(rscratch1, Address(rbcp, j, Address::sxtw(0)));
2309 __ lea(rbcp, Address(rbcp, j, Address::sxtw(0)));
2310 __ dispatch_only(vtos, /*generate_poll*/true);
2311 }
2312
2313
2314 void TemplateTable::_return(TosState state)
2315 {
2316 transition(state, state);
2317 assert(_desc->calls_vm(),
2318 "inconsistent calls_vm information"); // call in remove_activation
2319
2320 if (_desc->bytecode() == Bytecodes::_return_register_finalizer) {
2321 assert(state == vtos, "only valid state");
2322
2323 __ ldr(c_rarg1, aaddress(0));
2324 __ load_klass(r3, c_rarg1);
2325 __ ldrw(r3, Address(r3, Klass::access_flags_offset()));
2326 Label skip_register_finalizer;
2327 __ tbz(r3, exact_log2(JVM_ACC_HAS_FINALIZER), skip_register_finalizer);
2328
2329 __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::register_finalizer), c_rarg1);
2330
2331 __ bind(skip_register_finalizer);
2332 }
2333
2334 // Issue a StoreStore barrier after all stores but before return
2335 // from any constructor for any class with a final field. We don't
2336 // know if this is a finalizer, so we always do so.
2337 if (_desc->bytecode() == Bytecodes::_return)
2338 __ membar(MacroAssembler::StoreStore);
2339
2340 // Narrow result if state is itos but result type is smaller.
2341 // Need to narrow in the return bytecode rather than in generate_return_entry
2342 // since compiled code callers expect the result to already be narrowed.
2343 if (state == itos) {
2344 __ narrow(r0);
2345 }
2346
2347 __ remove_activation(state);
2348 __ ret(lr);
2349 }
2350
2351 // ----------------------------------------------------------------------------
2352 // Volatile variables demand their effects be made known to all CPU's
2353 // in order. Store buffers on most chips allow reads & writes to
2354 // reorder; the JMM's ReadAfterWrite.java test fails in -Xint mode
2355 // without some kind of memory barrier (i.e., it's not sufficient that
2356 // the interpreter does not reorder volatile references, the hardware
2357 // also must not reorder them).
2358 //
2359 // According to the new Java Memory Model (JMM):
2360 // (1) All volatiles are serialized wrt to each other. ALSO reads &
2361 // writes act as acquire & release, so:
2362 // (2) A read cannot let unrelated NON-volatile memory refs that
2363 // happen after the read float up to before the read. It's OK for
2364 // non-volatile memory refs that happen before the volatile read to
2365 // float down below it.
2366 // (3) Similar a volatile write cannot let unrelated NON-volatile
2367 // memory refs that happen BEFORE the write float down to after the
2368 // write. It's OK for non-volatile memory refs that happen after the
2369 // volatile write to float up before it.
2370 //
2371 // We only put in barriers around volatile refs (they are expensive),
2372 // not _between_ memory refs (that would require us to track the
2373 // flavor of the previous memory refs). Requirements (2) and (3)
2374 // require some barriers before volatile stores and after volatile
2375 // loads. These nearly cover requirement (1) but miss the
2376 // volatile-store-volatile-load case. This final case is placed after
2377 // volatile-stores although it could just as well go before
2378 // volatile-loads.
2379
2380 void TemplateTable::resolve_cache_and_index(int byte_no,
2381 Register Rcache,
2382 Register index,
2383 size_t index_size) {
2384 const Register temp = r19;
2385 assert_different_registers(Rcache, index, temp);
2386
2387 Label resolved, clinit_barrier_slow;
2388
2389 Bytecodes::Code code = bytecode();
2390 switch (code) {
2391 case Bytecodes::_nofast_getfield: code = Bytecodes::_getfield; break;
2392 case Bytecodes::_nofast_putfield: code = Bytecodes::_putfield; break;
2393 default: break;
2394 }
2395
2396 assert(byte_no == f1_byte || byte_no == f2_byte, "byte_no out of range");
2397 __ get_cache_and_index_and_bytecode_at_bcp(Rcache, index, temp, byte_no, 1, index_size);
2398 __ subs(zr, temp, (int) code); // have we resolved this bytecode?
2399 __ br(Assembler::EQ, resolved);
2400
2401 // resolve first time through
2402 // Class initialization barrier slow path lands here as well.
2403 __ bind(clinit_barrier_slow);
2404 address entry = CAST_FROM_FN_PTR(address, InterpreterRuntime::resolve_from_cache);
2405 __ mov(temp, (int) code);
2406 __ call_VM(noreg, entry, temp);
2407
2408 // Update registers with resolved info
2409 __ get_cache_and_index_at_bcp(Rcache, index, 1, index_size);
2410 // n.b. unlike x86 Rcache is now rcpool plus the indexed offset
2411 // so all clients ofthis method must be modified accordingly
2412 __ bind(resolved);
2413
2414 // Class initialization barrier for static methods
2415 if (VM_Version::supports_fast_class_init_checks() && bytecode() == Bytecodes::_invokestatic) {
2416 __ load_resolved_method_at_index(byte_no, temp, Rcache);
2417 __ load_method_holder(temp, temp);
2418 __ clinit_barrier(temp, rscratch1, NULL, &clinit_barrier_slow);
2419 }
2420 }
2421
2422 // The Rcache and index registers must be set before call
2423 // n.b unlike x86 cache already includes the index offset
2424 void TemplateTable::load_field_cp_cache_entry(Register obj,
2425 Register cache,
2426 Register index,
2427 Register off,
2428 Register flags,
2429 bool is_static = false) {
2430 assert_different_registers(cache, index, flags, off);
2431
2432 ByteSize cp_base_offset = ConstantPoolCache::base_offset();
2433 // Field offset
2434 __ ldr(off, Address(cache, in_bytes(cp_base_offset +
2435 ConstantPoolCacheEntry::f2_offset())));
2436 // Flags
2437 __ ldrw(flags, Address(cache, in_bytes(cp_base_offset +
2438 ConstantPoolCacheEntry::flags_offset())));
2439
2440 // klass overwrite register
2441 if (is_static) {
2442 __ ldr(obj, Address(cache, in_bytes(cp_base_offset +
2443 ConstantPoolCacheEntry::f1_offset())));
2444 const int mirror_offset = in_bytes(Klass::java_mirror_offset());
2445 __ ldr(obj, Address(obj, mirror_offset));
2446 __ resolve_oop_handle(obj, r5, rscratch2);
2447 }
2448 }
2449
2450 void TemplateTable::load_invoke_cp_cache_entry(int byte_no,
2451 Register method,
2452 Register itable_index,
2453 Register flags,
2454 bool is_invokevirtual,
2455 bool is_invokevfinal, /*unused*/
2456 bool is_invokedynamic) {
2457 // setup registers
2458 const Register cache = rscratch2;
2459 const Register index = r4;
2460 assert_different_registers(method, flags);
2461 assert_different_registers(method, cache, index);
2462 assert_different_registers(itable_index, flags);
2463 assert_different_registers(itable_index, cache, index);
2464 // determine constant pool cache field offsets
2465 assert(is_invokevirtual == (byte_no == f2_byte), "is_invokevirtual flag redundant");
2466 const int method_offset = in_bytes(
2467 ConstantPoolCache::base_offset() +
2468 (is_invokevirtual
2469 ? ConstantPoolCacheEntry::f2_offset()
2470 : ConstantPoolCacheEntry::f1_offset()));
2471 const int flags_offset = in_bytes(ConstantPoolCache::base_offset() +
2472 ConstantPoolCacheEntry::flags_offset());
2473 // access constant pool cache fields
2474 const int index_offset = in_bytes(ConstantPoolCache::base_offset() +
2475 ConstantPoolCacheEntry::f2_offset());
2476
2477 size_t index_size = (is_invokedynamic ? sizeof(u4) : sizeof(u2));
2478 resolve_cache_and_index(byte_no, cache, index, index_size);
2479 __ ldr(method, Address(cache, method_offset));
2480
2481 if (itable_index != noreg) {
2482 __ ldr(itable_index, Address(cache, index_offset));
2483 }
2484 __ ldrw(flags, Address(cache, flags_offset));
2485 }
2486
2487
2488 // The registers cache and index expected to be set before call.
2489 // Correct values of the cache and index registers are preserved.
2490 void TemplateTable::jvmti_post_field_access(Register cache, Register index,
2491 bool is_static, bool has_tos) {
2492 // do the JVMTI work here to avoid disturbing the register state below
2493 // We use c_rarg registers here because we want to use the register used in
2494 // the call to the VM
2495 if (JvmtiExport::can_post_field_access()) {
2496 // Check to see if a field access watch has been set before we
2497 // take the time to call into the VM.
2498 Label L1;
2499 assert_different_registers(cache, index, r0);
2500 __ lea(rscratch1, ExternalAddress((address) JvmtiExport::get_field_access_count_addr()));
2501 __ ldrw(r0, Address(rscratch1));
2502 __ cbzw(r0, L1);
2503
2504 __ get_cache_and_index_at_bcp(c_rarg2, c_rarg3, 1);
2505 __ lea(c_rarg2, Address(c_rarg2, in_bytes(ConstantPoolCache::base_offset())));
2506
2507 if (is_static) {
2508 __ mov(c_rarg1, zr); // NULL object reference
2509 } else {
2510 __ ldr(c_rarg1, at_tos()); // get object pointer without popping it
2511 __ verify_oop(c_rarg1);
2512 }
2513 // c_rarg1: object pointer or NULL
2514 // c_rarg2: cache entry pointer
2515 // c_rarg3: jvalue object on the stack
2516 __ call_VM(noreg, CAST_FROM_FN_PTR(address,
2517 InterpreterRuntime::post_field_access),
2518 c_rarg1, c_rarg2, c_rarg3);
2519 __ get_cache_and_index_at_bcp(cache, index, 1);
2520 __ bind(L1);
2521 }
2522 }
2523
2524 void TemplateTable::pop_and_check_object(Register r)
2525 {
2526 __ pop_ptr(r);
2527 __ null_check(r); // for field access must check obj.
2528 __ verify_oop(r);
2529 }
2530
2531 void TemplateTable::getfield_or_static(int byte_no, bool is_static, RewriteControl rc)
2532 {
2533 const Register cache = r2;
2534 const Register index = r3;
2535 const Register obj = r4;
2536 const Register klass = r5;
2537 const Register inline_klass = r7;
2538 const Register off = r19;
2539 const Register flags = r0;
2540 const Register raw_flags = r6;
2541 const Register bc = r4; // uses same reg as obj, so don't mix them
2542
2543 resolve_cache_and_index(byte_no, cache, index, sizeof(u2));
2544 jvmti_post_field_access(cache, index, is_static, false);
2545 load_field_cp_cache_entry(obj, cache, index, off, raw_flags, is_static);
2546
2547 if (!is_static) {
2548 // obj is on the stack
2549 pop_and_check_object(obj);
2550 }
2551
2552 // 8179954: We need to make sure that the code generated for
2553 // volatile accesses forms a sequentially-consistent set of
2554 // operations when combined with STLR and LDAR. Without a leading
2555 // membar it's possible for a simple Dekker test to fail if loads
2556 // use LDR;DMB but stores use STLR. This can happen if C2 compiles
2557 // the stores in one method and we interpret the loads in another.
2558 if (!CompilerConfig::is_c1_or_interpreter_only_no_jvmci()){
2559 Label notVolatile;
2560 __ tbz(raw_flags, ConstantPoolCacheEntry::is_volatile_shift, notVolatile);
2561 __ membar(MacroAssembler::AnyAny);
2562 __ bind(notVolatile);
2563 }
2564
2565 const Address field(obj, off);
2566
2567 Label Done, notByte, notBool, notInt, notShort, notChar,
2568 notLong, notFloat, notObj, notDouble;
2569
2570 if (!is_static) {
2571 __ ldr(klass, Address(cache, in_bytes(ConstantPoolCache::base_offset() +
2572 ConstantPoolCacheEntry::f1_offset())));
2573 }
2574
2575 // x86 uses a shift and mask or wings it with a shift plus assert
2576 // the mask is not needed. aarch64 just uses bitfield extract
2577 __ ubfxw(flags, raw_flags, ConstantPoolCacheEntry::tos_state_shift, ConstantPoolCacheEntry::tos_state_bits);
2578
2579 assert(btos == 0, "change code, btos != 0");
2580 __ cbnz(flags, notByte);
2581
2582 // Don't rewrite getstatic, only getfield
2583 if (is_static) rc = may_not_rewrite;
2584
2585 // btos
2586 __ access_load_at(T_BYTE, IN_HEAP, r0, field, noreg, noreg);
2587 __ push(btos);
2588 // Rewrite bytecode to be faster
2589 if (rc == may_rewrite) {
2590 patch_bytecode(Bytecodes::_fast_bgetfield, bc, r1);
2591 }
2592 __ b(Done);
2593
2594 __ bind(notByte);
2595 __ cmp(flags, (u1)ztos);
2596 __ br(Assembler::NE, notBool);
2597
2598 // ztos (same code as btos)
2599 __ access_load_at(T_BOOLEAN, IN_HEAP, r0, field, noreg, noreg);
2600 __ push(ztos);
2601 // Rewrite bytecode to be faster
2602 if (rc == may_rewrite) {
2603 // use btos rewriting, no truncating to t/f bit is needed for getfield.
2604 patch_bytecode(Bytecodes::_fast_bgetfield, bc, r1);
2605 }
2606 __ b(Done);
2607
2608 __ bind(notBool);
2609 __ cmp(flags, (u1)atos);
2610 __ br(Assembler::NE, notObj);
2611 // atos
2612 if (!EnablePrimitiveClasses) {
2613 do_oop_load(_masm, field, r0, IN_HEAP);
2614 __ push(atos);
2615 if (rc == may_rewrite) {
2616 patch_bytecode(Bytecodes::_fast_agetfield, bc, r1);
2617 }
2618 __ b(Done);
2619 } else { // Valhalla
2620 if (is_static) {
2621 __ load_heap_oop(r0, field, rscratch1, rscratch2);
2622 Label is_null_free_inline_type, uninitialized;
2623 // Issue below if the static field has not been initialized yet
2624 __ test_field_is_null_free_inline_type(raw_flags, noreg /*temp*/, is_null_free_inline_type);
2625 // field is not a null free inline type
2626 __ push(atos);
2627 __ b(Done);
2628 // field is a null free inline type, must not return null even if uninitialized
2629 __ bind(is_null_free_inline_type);
2630 __ cbz(r0, uninitialized);
2631 __ push(atos);
2632 __ b(Done);
2633 __ bind(uninitialized);
2634 __ andw(raw_flags, raw_flags, ConstantPoolCacheEntry::field_index_mask);
2635 Label slow_case, finish;
2636 __ ldrb(rscratch1, Address(cache, InstanceKlass::init_state_offset()));
2637 __ cmp(rscratch1, (u1)InstanceKlass::fully_initialized);
2638 __ br(Assembler::NE, slow_case);
2639 __ get_default_value_oop(klass, off /* temp */, r0);
2640 __ b(finish);
2641 __ bind(slow_case);
2642 __ call_VM(r0, CAST_FROM_FN_PTR(address, InterpreterRuntime::uninitialized_static_inline_type_field), obj, raw_flags);
2643 __ bind(finish);
2644 __ verify_oop(r0);
2645 __ push(atos);
2646 __ b(Done);
2647 } else {
2648 Label is_inlined, nonnull, is_inline_type, rewrite_inline;
2649 __ test_field_is_null_free_inline_type(raw_flags, noreg /*temp*/, is_inline_type);
2650 // Non-inline field case
2651 __ load_heap_oop(r0, field, rscratch1, rscratch2);
2652 __ push(atos);
2653 if (rc == may_rewrite) {
2654 patch_bytecode(Bytecodes::_fast_agetfield, bc, r1);
2655 }
2656 __ b(Done);
2657 __ bind(is_inline_type);
2658 __ test_field_is_inlined(raw_flags, noreg /* temp */, is_inlined);
2659 // field is not inlined
2660 __ load_heap_oop(r0, field, rscratch1, rscratch2);
2661 __ cbnz(r0, nonnull);
2662 __ andw(raw_flags, raw_flags, ConstantPoolCacheEntry::field_index_mask);
2663 __ get_inline_type_field_klass(klass, raw_flags, inline_klass);
2664 __ get_default_value_oop(inline_klass, klass /* temp */, r0);
2665 __ bind(nonnull);
2666 __ verify_oop(r0);
2667 __ push(atos);
2668 __ b(rewrite_inline);
2669 __ bind(is_inlined);
2670 // field is inlined
2671 __ andw(raw_flags, raw_flags, ConstantPoolCacheEntry::field_index_mask);
2672 __ mov(r0, obj);
2673 __ read_inlined_field(klass, raw_flags, off, inline_klass /* temp */, r0);
2674 __ verify_oop(r0);
2675 __ push(atos);
2676 __ bind(rewrite_inline);
2677 if (rc == may_rewrite) {
2678 patch_bytecode(Bytecodes::_fast_qgetfield, bc, r1);
2679 }
2680 __ b(Done);
2681 }
2682 }
2683
2684 __ bind(notObj);
2685 __ cmp(flags, (u1)itos);
2686 __ br(Assembler::NE, notInt);
2687 // itos
2688 __ access_load_at(T_INT, IN_HEAP, r0, field, noreg, noreg);
2689 __ push(itos);
2690 // Rewrite bytecode to be faster
2691 if (rc == may_rewrite) {
2692 patch_bytecode(Bytecodes::_fast_igetfield, bc, r1);
2693 }
2694 __ b(Done);
2695
2696 __ bind(notInt);
2697 __ cmp(flags, (u1)ctos);
2698 __ br(Assembler::NE, notChar);
2699 // ctos
2700 __ access_load_at(T_CHAR, IN_HEAP, r0, field, noreg, noreg);
2701 __ push(ctos);
2702 // Rewrite bytecode to be faster
2703 if (rc == may_rewrite) {
2704 patch_bytecode(Bytecodes::_fast_cgetfield, bc, r1);
2705 }
2706 __ b(Done);
2707
2708 __ bind(notChar);
2709 __ cmp(flags, (u1)stos);
2710 __ br(Assembler::NE, notShort);
2711 // stos
2712 __ access_load_at(T_SHORT, IN_HEAP, r0, field, noreg, noreg);
2713 __ push(stos);
2714 // Rewrite bytecode to be faster
2715 if (rc == may_rewrite) {
2716 patch_bytecode(Bytecodes::_fast_sgetfield, bc, r1);
2717 }
2718 __ b(Done);
2719
2720 __ bind(notShort);
2721 __ cmp(flags, (u1)ltos);
2722 __ br(Assembler::NE, notLong);
2723 // ltos
2724 __ access_load_at(T_LONG, IN_HEAP, r0, field, noreg, noreg);
2725 __ push(ltos);
2726 // Rewrite bytecode to be faster
2727 if (rc == may_rewrite) {
2728 patch_bytecode(Bytecodes::_fast_lgetfield, bc, r1);
2729 }
2730 __ b(Done);
2731
2732 __ bind(notLong);
2733 __ cmp(flags, (u1)ftos);
2734 __ br(Assembler::NE, notFloat);
2735 // ftos
2736 __ access_load_at(T_FLOAT, IN_HEAP, noreg /* ftos */, field, noreg, noreg);
2737 __ push(ftos);
2738 // Rewrite bytecode to be faster
2739 if (rc == may_rewrite) {
2740 patch_bytecode(Bytecodes::_fast_fgetfield, bc, r1);
2741 }
2742 __ b(Done);
2743
2744 __ bind(notFloat);
2745 #ifdef ASSERT
2746 __ cmp(flags, (u1)dtos);
2747 __ br(Assembler::NE, notDouble);
2748 #endif
2749 // dtos
2750 __ access_load_at(T_DOUBLE, IN_HEAP, noreg /* ftos */, field, noreg, noreg);
2751 __ push(dtos);
2752 // Rewrite bytecode to be faster
2753 if (rc == may_rewrite) {
2754 patch_bytecode(Bytecodes::_fast_dgetfield, bc, r1);
2755 }
2756 #ifdef ASSERT
2757 __ b(Done);
2758
2759 __ bind(notDouble);
2760 __ stop("Bad state");
2761 #endif
2762
2763 __ bind(Done);
2764
2765 Label notVolatile;
2766 __ tbz(raw_flags, ConstantPoolCacheEntry::is_volatile_shift, notVolatile);
2767 __ membar(MacroAssembler::LoadLoad | MacroAssembler::LoadStore);
2768 __ bind(notVolatile);
2769 }
2770
2771
2772 void TemplateTable::getfield(int byte_no)
2773 {
2774 getfield_or_static(byte_no, false);
2775 }
2776
2777 void TemplateTable::nofast_getfield(int byte_no) {
2778 getfield_or_static(byte_no, false, may_not_rewrite);
2779 }
2780
2781 void TemplateTable::getstatic(int byte_no)
2782 {
2783 getfield_or_static(byte_no, true);
2784 }
2785
2786 // The registers cache and index expected to be set before call.
2787 // The function may destroy various registers, just not the cache and index registers.
2788 void TemplateTable::jvmti_post_field_mod(Register cache, Register index, bool is_static) {
2789 transition(vtos, vtos);
2790
2791 ByteSize cp_base_offset = ConstantPoolCache::base_offset();
2792
2793 if (JvmtiExport::can_post_field_modification()) {
2794 // Check to see if a field modification watch has been set before
2795 // we take the time to call into the VM.
2796 Label L1;
2797 assert_different_registers(cache, index, r0);
2798 __ lea(rscratch1, ExternalAddress((address)JvmtiExport::get_field_modification_count_addr()));
2799 __ ldrw(r0, Address(rscratch1));
2800 __ cbz(r0, L1);
2801
2802 __ get_cache_and_index_at_bcp(c_rarg2, rscratch1, 1);
2803
2804 if (is_static) {
2805 // Life is simple. Null out the object pointer.
2806 __ mov(c_rarg1, zr);
2807 } else {
2808 // Life is harder. The stack holds the value on top, followed by
2809 // the object. We don't know the size of the value, though; it
2810 // could be one or two words depending on its type. As a result,
2811 // we must find the type to determine where the object is.
2812 __ ldrw(c_rarg3, Address(c_rarg2,
2813 in_bytes(cp_base_offset +
2814 ConstantPoolCacheEntry::flags_offset())));
2815 __ lsr(c_rarg3, c_rarg3,
2816 ConstantPoolCacheEntry::tos_state_shift);
2817 ConstantPoolCacheEntry::verify_tos_state_shift();
2818 Label nope2, done, ok;
2819 __ ldr(c_rarg1, at_tos_p1()); // initially assume a one word jvalue
2820 __ cmpw(c_rarg3, ltos);
2821 __ br(Assembler::EQ, ok);
2822 __ cmpw(c_rarg3, dtos);
2823 __ br(Assembler::NE, nope2);
2824 __ bind(ok);
2825 __ ldr(c_rarg1, at_tos_p2()); // ltos (two word jvalue)
2826 __ bind(nope2);
2827 }
2828 // cache entry pointer
2829 __ add(c_rarg2, c_rarg2, in_bytes(cp_base_offset));
2830 // object (tos)
2831 __ mov(c_rarg3, esp);
2832 // c_rarg1: object pointer set up above (NULL if static)
2833 // c_rarg2: cache entry pointer
2834 // c_rarg3: jvalue object on the stack
2835 __ call_VM(noreg,
2836 CAST_FROM_FN_PTR(address,
2837 InterpreterRuntime::post_field_modification),
2838 c_rarg1, c_rarg2, c_rarg3);
2839 __ get_cache_and_index_at_bcp(cache, index, 1);
2840 __ bind(L1);
2841 }
2842 }
2843
2844 void TemplateTable::putfield_or_static(int byte_no, bool is_static, RewriteControl rc) {
2845 transition(vtos, vtos);
2846
2847 const Register cache = r2;
2848 const Register index = r3;
2849 const Register obj = r2;
2850 const Register off = r19;
2851 const Register flags = r0;
2852 const Register flags2 = r6;
2853 const Register bc = r4;
2854 const Register inline_klass = r5;
2855
2856 resolve_cache_and_index(byte_no, cache, index, sizeof(u2));
2857 jvmti_post_field_mod(cache, index, is_static);
2858 load_field_cp_cache_entry(obj, cache, index, off, flags, is_static);
2859
2860 Label Done;
2861 __ mov(r5, flags);
2862
2863 {
2864 Label notVolatile;
2865 __ tbz(r5, ConstantPoolCacheEntry::is_volatile_shift, notVolatile);
2866 __ membar(MacroAssembler::StoreStore | MacroAssembler::LoadStore);
2867 __ bind(notVolatile);
2868 }
2869
2870 // field address
2871 const Address field(obj, off);
2872
2873 Label notByte, notBool, notInt, notShort, notChar,
2874 notLong, notFloat, notObj, notDouble;
2875
2876 __ mov(flags2, flags);
2877
2878 // x86 uses a shift and mask or wings it with a shift plus assert
2879 // the mask is not needed. aarch64 just uses bitfield extract
2880 __ ubfxw(flags, flags, ConstantPoolCacheEntry::tos_state_shift, ConstantPoolCacheEntry::tos_state_bits);
2881
2882 assert(btos == 0, "change code, btos != 0");
2883 __ cbnz(flags, notByte);
2884
2885 // Don't rewrite putstatic, only putfield
2886 if (is_static) rc = may_not_rewrite;
2887
2888 // btos
2889 {
2890 __ pop(btos);
2891 if (!is_static) pop_and_check_object(obj);
2892 __ access_store_at(T_BYTE, IN_HEAP, field, r0, noreg, noreg, noreg);
2893 if (rc == may_rewrite) {
2894 patch_bytecode(Bytecodes::_fast_bputfield, bc, r1, true, byte_no);
2895 }
2896 __ b(Done);
2897 }
2898
2899 __ bind(notByte);
2900 __ cmp(flags, (u1)ztos);
2901 __ br(Assembler::NE, notBool);
2902
2903 // ztos
2904 {
2905 __ pop(ztos);
2906 if (!is_static) pop_and_check_object(obj);
2907 __ access_store_at(T_BOOLEAN, IN_HEAP, field, r0, noreg, noreg, noreg);
2908 if (rc == may_rewrite) {
2909 patch_bytecode(Bytecodes::_fast_zputfield, bc, r1, true, byte_no);
2910 }
2911 __ b(Done);
2912 }
2913
2914 __ bind(notBool);
2915 __ cmp(flags, (u1)atos);
2916 __ br(Assembler::NE, notObj);
2917
2918 // atos
2919 {
2920 if (!EnablePrimitiveClasses) {
2921 __ pop(atos);
2922 if (!is_static) pop_and_check_object(obj);
2923 // Store into the field
2924 do_oop_store(_masm, field, r0, IN_HEAP);
2925 if (rc == may_rewrite) {
2926 patch_bytecode(Bytecodes::_fast_aputfield, bc, r1, true, byte_no);
2927 }
2928 __ b(Done);
2929 } else { // Valhalla
2930 __ pop(atos);
2931 if (is_static) {
2932 Label is_inline_type;
2933 __ test_field_is_not_null_free_inline_type(flags2, noreg /* temp */, is_inline_type);
2934 __ null_check(r0);
2935 __ bind(is_inline_type);
2936 do_oop_store(_masm, field, r0, IN_HEAP);
2937 __ b(Done);
2938 } else {
2939 Label is_inline_type, is_inlined, rewrite_not_inline, rewrite_inline;
2940 __ test_field_is_null_free_inline_type(flags2, noreg /*temp*/, is_inline_type);
2941 // Not an inline type
2942 pop_and_check_object(obj);
2943 // Store into the field
2944 do_oop_store(_masm, field, r0, IN_HEAP);
2945 __ bind(rewrite_not_inline);
2946 if (rc == may_rewrite) {
2947 patch_bytecode(Bytecodes::_fast_aputfield, bc, r19, true, byte_no);
2948 }
2949 __ b(Done);
2950 // Implementation of the inline type semantic
2951 __ bind(is_inline_type);
2952 __ null_check(r0);
2953 __ test_field_is_inlined(flags2, noreg /*temp*/, is_inlined);
2954 // field is not inlined
2955 pop_and_check_object(obj);
2956 // Store into the field
2957 do_oop_store(_masm, field, r0, IN_HEAP);
2958 __ b(rewrite_inline);
2959 __ bind(is_inlined);
2960 // field is inlined
2961 pop_and_check_object(obj);
2962 assert_different_registers(r0, inline_klass, obj, off);
2963 __ load_klass(inline_klass, r0);
2964 __ data_for_oop(r0, r0, inline_klass);
2965 __ add(obj, obj, off);
2966 __ access_value_copy(IN_HEAP, r0, obj, inline_klass);
2967 __ bind(rewrite_inline);
2968 if (rc == may_rewrite) {
2969 patch_bytecode(Bytecodes::_fast_qputfield, bc, r19, true, byte_no);
2970 }
2971 __ b(Done);
2972 }
2973 } // Valhalla
2974 }
2975
2976 __ bind(notObj);
2977 __ cmp(flags, (u1)itos);
2978 __ br(Assembler::NE, notInt);
2979
2980 // itos
2981 {
2982 __ pop(itos);
2983 if (!is_static) pop_and_check_object(obj);
2984 __ access_store_at(T_INT, IN_HEAP, field, r0, noreg, noreg, noreg);
2985 if (rc == may_rewrite) {
2986 patch_bytecode(Bytecodes::_fast_iputfield, bc, r1, true, byte_no);
2987 }
2988 __ b(Done);
2989 }
2990
2991 __ bind(notInt);
2992 __ cmp(flags, (u1)ctos);
2993 __ br(Assembler::NE, notChar);
2994
2995 // ctos
2996 {
2997 __ pop(ctos);
2998 if (!is_static) pop_and_check_object(obj);
2999 __ access_store_at(T_CHAR, IN_HEAP, field, r0, noreg, noreg, noreg);
3000 if (rc == may_rewrite) {
3001 patch_bytecode(Bytecodes::_fast_cputfield, bc, r1, true, byte_no);
3002 }
3003 __ b(Done);
3004 }
3005
3006 __ bind(notChar);
3007 __ cmp(flags, (u1)stos);
3008 __ br(Assembler::NE, notShort);
3009
3010 // stos
3011 {
3012 __ pop(stos);
3013 if (!is_static) pop_and_check_object(obj);
3014 __ access_store_at(T_SHORT, IN_HEAP, field, r0, noreg, noreg, noreg);
3015 if (rc == may_rewrite) {
3016 patch_bytecode(Bytecodes::_fast_sputfield, bc, r1, true, byte_no);
3017 }
3018 __ b(Done);
3019 }
3020
3021 __ bind(notShort);
3022 __ cmp(flags, (u1)ltos);
3023 __ br(Assembler::NE, notLong);
3024
3025 // ltos
3026 {
3027 __ pop(ltos);
3028 if (!is_static) pop_and_check_object(obj);
3029 __ access_store_at(T_LONG, IN_HEAP, field, r0, noreg, noreg, noreg);
3030 if (rc == may_rewrite) {
3031 patch_bytecode(Bytecodes::_fast_lputfield, bc, r1, true, byte_no);
3032 }
3033 __ b(Done);
3034 }
3035
3036 __ bind(notLong);
3037 __ cmp(flags, (u1)ftos);
3038 __ br(Assembler::NE, notFloat);
3039
3040 // ftos
3041 {
3042 __ pop(ftos);
3043 if (!is_static) pop_and_check_object(obj);
3044 __ access_store_at(T_FLOAT, IN_HEAP, field, noreg /* ftos */, noreg, noreg, noreg);
3045 if (rc == may_rewrite) {
3046 patch_bytecode(Bytecodes::_fast_fputfield, bc, r1, true, byte_no);
3047 }
3048 __ b(Done);
3049 }
3050
3051 __ bind(notFloat);
3052 #ifdef ASSERT
3053 __ cmp(flags, (u1)dtos);
3054 __ br(Assembler::NE, notDouble);
3055 #endif
3056
3057 // dtos
3058 {
3059 __ pop(dtos);
3060 if (!is_static) pop_and_check_object(obj);
3061 __ access_store_at(T_DOUBLE, IN_HEAP, field, noreg /* dtos */, noreg, noreg, noreg);
3062 if (rc == may_rewrite) {
3063 patch_bytecode(Bytecodes::_fast_dputfield, bc, r1, true, byte_no);
3064 }
3065 }
3066
3067 #ifdef ASSERT
3068 __ b(Done);
3069
3070 __ bind(notDouble);
3071 __ stop("Bad state");
3072 #endif
3073
3074 __ bind(Done);
3075
3076 {
3077 Label notVolatile;
3078 __ tbz(r5, ConstantPoolCacheEntry::is_volatile_shift, notVolatile);
3079 __ membar(MacroAssembler::StoreLoad | MacroAssembler::StoreStore);
3080 __ bind(notVolatile);
3081 }
3082 }
3083
3084 void TemplateTable::putfield(int byte_no)
3085 {
3086 putfield_or_static(byte_no, false);
3087 }
3088
3089 void TemplateTable::nofast_putfield(int byte_no) {
3090 putfield_or_static(byte_no, false, may_not_rewrite);
3091 }
3092
3093 void TemplateTable::putstatic(int byte_no) {
3094 putfield_or_static(byte_no, true);
3095 }
3096
3097 void TemplateTable::jvmti_post_fast_field_mod()
3098 {
3099 if (JvmtiExport::can_post_field_modification()) {
3100 // Check to see if a field modification watch has been set before
3101 // we take the time to call into the VM.
3102 Label L2;
3103 __ lea(rscratch1, ExternalAddress((address)JvmtiExport::get_field_modification_count_addr()));
3104 __ ldrw(c_rarg3, Address(rscratch1));
3105 __ cbzw(c_rarg3, L2);
3106 __ pop_ptr(r19); // copy the object pointer from tos
3107 __ verify_oop(r19);
3108 __ push_ptr(r19); // put the object pointer back on tos
3109 // Save tos values before call_VM() clobbers them. Since we have
3110 // to do it for every data type, we use the saved values as the
3111 // jvalue object.
3112 switch (bytecode()) { // load values into the jvalue object
3113 case Bytecodes::_fast_qputfield: //fall through
3114 case Bytecodes::_fast_aputfield: __ push_ptr(r0); break;
3115 case Bytecodes::_fast_bputfield: // fall through
3116 case Bytecodes::_fast_zputfield: // fall through
3117 case Bytecodes::_fast_sputfield: // fall through
3118 case Bytecodes::_fast_cputfield: // fall through
3119 case Bytecodes::_fast_iputfield: __ push_i(r0); break;
3120 case Bytecodes::_fast_dputfield: __ push_d(); break;
3121 case Bytecodes::_fast_fputfield: __ push_f(); break;
3122 case Bytecodes::_fast_lputfield: __ push_l(r0); break;
3123
3124 default:
3125 ShouldNotReachHere();
3126 }
3127 __ mov(c_rarg3, esp); // points to jvalue on the stack
3128 // access constant pool cache entry
3129 __ get_cache_entry_pointer_at_bcp(c_rarg2, r0, 1);
3130 __ verify_oop(r19);
3131 // r19: object pointer copied above
3132 // c_rarg2: cache entry pointer
3133 // c_rarg3: jvalue object on the stack
3134 __ call_VM(noreg,
3135 CAST_FROM_FN_PTR(address,
3136 InterpreterRuntime::post_field_modification),
3137 r19, c_rarg2, c_rarg3);
3138
3139 switch (bytecode()) { // restore tos values
3140 case Bytecodes::_fast_qputfield: //fall through
3141 case Bytecodes::_fast_aputfield: __ pop_ptr(r0); break;
3142 case Bytecodes::_fast_bputfield: // fall through
3143 case Bytecodes::_fast_zputfield: // fall through
3144 case Bytecodes::_fast_sputfield: // fall through
3145 case Bytecodes::_fast_cputfield: // fall through
3146 case Bytecodes::_fast_iputfield: __ pop_i(r0); break;
3147 case Bytecodes::_fast_dputfield: __ pop_d(); break;
3148 case Bytecodes::_fast_fputfield: __ pop_f(); break;
3149 case Bytecodes::_fast_lputfield: __ pop_l(r0); break;
3150 default: break;
3151 }
3152 __ bind(L2);
3153 }
3154 }
3155
3156 void TemplateTable::fast_storefield(TosState state)
3157 {
3158 transition(state, vtos);
3159
3160 ByteSize base = ConstantPoolCache::base_offset();
3161
3162 jvmti_post_fast_field_mod();
3163
3164 // access constant pool cache
3165 __ get_cache_and_index_at_bcp(r2, r1, 1);
3166
3167 // Must prevent reordering of the following cp cache loads with bytecode load
3168 __ membar(MacroAssembler::LoadLoad);
3169
3170 // test for volatile with r3
3171 __ ldrw(r3, Address(r2, in_bytes(base +
3172 ConstantPoolCacheEntry::flags_offset())));
3173
3174 // replace index with field offset from cache entry
3175 __ ldr(r1, Address(r2, in_bytes(base + ConstantPoolCacheEntry::f2_offset())));
3176
3177 {
3178 Label notVolatile;
3179 __ tbz(r3, ConstantPoolCacheEntry::is_volatile_shift, notVolatile);
3180 __ membar(MacroAssembler::StoreStore | MacroAssembler::LoadStore);
3181 __ bind(notVolatile);
3182 }
3183
3184 Label notVolatile;
3185
3186 // Get object from stack
3187 pop_and_check_object(r2);
3188
3189 // field address
3190 const Address field(r2, r1);
3191
3192 // access field
3193 switch (bytecode()) {
3194 case Bytecodes::_fast_qputfield: //fall through
3195 {
3196 Label is_inlined, done;
3197 __ null_check(r0);
3198 __ test_field_is_inlined(r3, noreg /* temp */, is_inlined);
3199 // field is not inlined
3200 do_oop_store(_masm, field, r0, IN_HEAP);
3201 __ b(done);
3202 __ bind(is_inlined);
3203 // field is inlined
3204 __ load_klass(r4, r0);
3205 __ data_for_oop(r0, r0, r4);
3206 __ lea(rscratch1, field);
3207 __ access_value_copy(IN_HEAP, r0, rscratch1, r4);
3208 __ bind(done);
3209 }
3210 break;
3211 case Bytecodes::_fast_aputfield:
3212 do_oop_store(_masm, field, r0, IN_HEAP);
3213 break;
3214 case Bytecodes::_fast_lputfield:
3215 __ access_store_at(T_LONG, IN_HEAP, field, r0, noreg, noreg, noreg);
3216 break;
3217 case Bytecodes::_fast_iputfield:
3218 __ access_store_at(T_INT, IN_HEAP, field, r0, noreg, noreg, noreg);
3219 break;
3220 case Bytecodes::_fast_zputfield:
3221 __ access_store_at(T_BOOLEAN, IN_HEAP, field, r0, noreg, noreg, noreg);
3222 break;
3223 case Bytecodes::_fast_bputfield:
3224 __ access_store_at(T_BYTE, IN_HEAP, field, r0, noreg, noreg, noreg);
3225 break;
3226 case Bytecodes::_fast_sputfield:
3227 __ access_store_at(T_SHORT, IN_HEAP, field, r0, noreg, noreg, noreg);
3228 break;
3229 case Bytecodes::_fast_cputfield:
3230 __ access_store_at(T_CHAR, IN_HEAP, field, r0, noreg, noreg, noreg);
3231 break;
3232 case Bytecodes::_fast_fputfield:
3233 __ access_store_at(T_FLOAT, IN_HEAP, field, noreg /* ftos */, noreg, noreg, noreg);
3234 break;
3235 case Bytecodes::_fast_dputfield:
3236 __ access_store_at(T_DOUBLE, IN_HEAP, field, noreg /* dtos */, noreg, noreg, noreg);
3237 break;
3238 default:
3239 ShouldNotReachHere();
3240 }
3241
3242 {
3243 Label notVolatile;
3244 __ tbz(r3, ConstantPoolCacheEntry::is_volatile_shift, notVolatile);
3245 __ membar(MacroAssembler::StoreLoad | MacroAssembler::StoreStore);
3246 __ bind(notVolatile);
3247 }
3248 }
3249
3250
3251 void TemplateTable::fast_accessfield(TosState state)
3252 {
3253 transition(atos, state);
3254 // Do the JVMTI work here to avoid disturbing the register state below
3255 if (JvmtiExport::can_post_field_access()) {
3256 // Check to see if a field access watch has been set before we
3257 // take the time to call into the VM.
3258 Label L1;
3259 __ lea(rscratch1, ExternalAddress((address) JvmtiExport::get_field_access_count_addr()));
3260 __ ldrw(r2, Address(rscratch1));
3261 __ cbzw(r2, L1);
3262 // access constant pool cache entry
3263 __ get_cache_entry_pointer_at_bcp(c_rarg2, rscratch2, 1);
3264 __ verify_oop(r0);
3265 __ push_ptr(r0); // save object pointer before call_VM() clobbers it
3266 __ mov(c_rarg1, r0);
3267 // c_rarg1: object pointer copied above
3268 // c_rarg2: cache entry pointer
3269 __ call_VM(noreg,
3270 CAST_FROM_FN_PTR(address,
3271 InterpreterRuntime::post_field_access),
3272 c_rarg1, c_rarg2);
3273 __ pop_ptr(r0); // restore object pointer
3274 __ bind(L1);
3275 }
3276
3277 // access constant pool cache
3278 __ get_cache_and_index_at_bcp(r2, r1, 1);
3279
3280 // Must prevent reordering of the following cp cache loads with bytecode load
3281 __ membar(MacroAssembler::LoadLoad);
3282
3283 __ ldr(r1, Address(r2, in_bytes(ConstantPoolCache::base_offset() +
3284 ConstantPoolCacheEntry::f2_offset())));
3285 __ ldrw(r3, Address(r2, in_bytes(ConstantPoolCache::base_offset() +
3286 ConstantPoolCacheEntry::flags_offset())));
3287
3288 // r0: object
3289 __ verify_oop(r0);
3290 __ null_check(r0);
3291 const Address field(r0, r1);
3292
3293 // 8179954: We need to make sure that the code generated for
3294 // volatile accesses forms a sequentially-consistent set of
3295 // operations when combined with STLR and LDAR. Without a leading
3296 // membar it's possible for a simple Dekker test to fail if loads
3297 // use LDR;DMB but stores use STLR. This can happen if C2 compiles
3298 // the stores in one method and we interpret the loads in another.
3299 if (!CompilerConfig::is_c1_or_interpreter_only_no_jvmci()) {
3300 Label notVolatile;
3301 __ tbz(r3, ConstantPoolCacheEntry::is_volatile_shift, notVolatile);
3302 __ membar(MacroAssembler::AnyAny);
3303 __ bind(notVolatile);
3304 }
3305
3306 // access field
3307 switch (bytecode()) {
3308 case Bytecodes::_fast_qgetfield:
3309 {
3310 Register index = r4, klass = r5, inline_klass = r6, tmp = r7;
3311 Label is_inlined, nonnull, Done;
3312 __ test_field_is_inlined(r3, noreg /* temp */, is_inlined);
3313 // field is not inlined
3314 __ load_heap_oop(r0, field, rscratch1, rscratch2);
3315 __ cbnz(r0, nonnull);
3316 __ andw(index, r3, ConstantPoolCacheEntry::field_index_mask);
3317 __ ldr(klass, Address(r2, in_bytes(ConstantPoolCache::base_offset() +
3318 ConstantPoolCacheEntry::f1_offset())));
3319 __ get_inline_type_field_klass(klass, index, inline_klass);
3320 __ get_default_value_oop(inline_klass, tmp /* temp */, r0);
3321 __ bind(nonnull);
3322 __ verify_oop(r0);
3323 __ b(Done);
3324 __ bind(is_inlined);
3325 // field is inlined
3326 __ andw(index, r3, ConstantPoolCacheEntry::field_index_mask);
3327 __ ldr(klass, Address(r2, in_bytes(ConstantPoolCache::base_offset() +
3328 ConstantPoolCacheEntry::f1_offset())));
3329 __ read_inlined_field(klass, index, r1, tmp /* temp */, r0);
3330 __ verify_oop(r0);
3331 __ bind(Done);
3332 }
3333 break;
3334 case Bytecodes::_fast_agetfield:
3335 do_oop_load(_masm, field, r0, IN_HEAP);
3336 __ verify_oop(r0);
3337 break;
3338 case Bytecodes::_fast_lgetfield:
3339 __ access_load_at(T_LONG, IN_HEAP, r0, field, noreg, noreg);
3340 break;
3341 case Bytecodes::_fast_igetfield:
3342 __ access_load_at(T_INT, IN_HEAP, r0, field, noreg, noreg);
3343 break;
3344 case Bytecodes::_fast_bgetfield:
3345 __ access_load_at(T_BYTE, IN_HEAP, r0, field, noreg, noreg);
3346 break;
3347 case Bytecodes::_fast_sgetfield:
3348 __ access_load_at(T_SHORT, IN_HEAP, r0, field, noreg, noreg);
3349 break;
3350 case Bytecodes::_fast_cgetfield:
3351 __ access_load_at(T_CHAR, IN_HEAP, r0, field, noreg, noreg);
3352 break;
3353 case Bytecodes::_fast_fgetfield:
3354 __ access_load_at(T_FLOAT, IN_HEAP, noreg /* ftos */, field, noreg, noreg);
3355 break;
3356 case Bytecodes::_fast_dgetfield:
3357 __ access_load_at(T_DOUBLE, IN_HEAP, noreg /* dtos */, field, noreg, noreg);
3358 break;
3359 default:
3360 ShouldNotReachHere();
3361 }
3362 {
3363 Label notVolatile;
3364 __ tbz(r3, ConstantPoolCacheEntry::is_volatile_shift, notVolatile);
3365 __ membar(MacroAssembler::LoadLoad | MacroAssembler::LoadStore);
3366 __ bind(notVolatile);
3367 }
3368 }
3369
3370 void TemplateTable::fast_xaccess(TosState state)
3371 {
3372 transition(vtos, state);
3373
3374 // get receiver
3375 __ ldr(r0, aaddress(0));
3376 // access constant pool cache
3377 __ get_cache_and_index_at_bcp(r2, r3, 2);
3378 __ ldr(r1, Address(r2, in_bytes(ConstantPoolCache::base_offset() +
3379 ConstantPoolCacheEntry::f2_offset())));
3380
3381 // 8179954: We need to make sure that the code generated for
3382 // volatile accesses forms a sequentially-consistent set of
3383 // operations when combined with STLR and LDAR. Without a leading
3384 // membar it's possible for a simple Dekker test to fail if loads
3385 // use LDR;DMB but stores use STLR. This can happen if C2 compiles
3386 // the stores in one method and we interpret the loads in another.
3387 if (!CompilerConfig::is_c1_or_interpreter_only_no_jvmci()) {
3388 Label notVolatile;
3389 __ ldrw(r3, Address(r2, in_bytes(ConstantPoolCache::base_offset() +
3390 ConstantPoolCacheEntry::flags_offset())));
3391 __ tbz(r3, ConstantPoolCacheEntry::is_volatile_shift, notVolatile);
3392 __ membar(MacroAssembler::AnyAny);
3393 __ bind(notVolatile);
3394 }
3395
3396 // make sure exception is reported in correct bcp range (getfield is
3397 // next instruction)
3398 __ increment(rbcp);
3399 __ null_check(r0);
3400 switch (state) {
3401 case itos:
3402 __ access_load_at(T_INT, IN_HEAP, r0, Address(r0, r1, Address::lsl(0)), noreg, noreg);
3403 break;
3404 case atos:
3405 do_oop_load(_masm, Address(r0, r1, Address::lsl(0)), r0, IN_HEAP);
3406 __ verify_oop(r0);
3407 break;
3408 case ftos:
3409 __ access_load_at(T_FLOAT, IN_HEAP, noreg /* ftos */, Address(r0, r1, Address::lsl(0)), noreg, noreg);
3410 break;
3411 default:
3412 ShouldNotReachHere();
3413 }
3414
3415 {
3416 Label notVolatile;
3417 __ ldrw(r3, Address(r2, in_bytes(ConstantPoolCache::base_offset() +
3418 ConstantPoolCacheEntry::flags_offset())));
3419 __ tbz(r3, ConstantPoolCacheEntry::is_volatile_shift, notVolatile);
3420 __ membar(MacroAssembler::LoadLoad | MacroAssembler::LoadStore);
3421 __ bind(notVolatile);
3422 }
3423
3424 __ decrement(rbcp);
3425 }
3426
3427
3428
3429 //-----------------------------------------------------------------------------
3430 // Calls
3431
3432 void TemplateTable::prepare_invoke(int byte_no,
3433 Register method, // linked method (or i-klass)
3434 Register index, // itable index, MethodType, etc.
3435 Register recv, // if caller wants to see it
3436 Register flags // if caller wants to test it
3437 ) {
3438 // determine flags
3439 Bytecodes::Code code = bytecode();
3440 const bool is_invokeinterface = code == Bytecodes::_invokeinterface;
3441 const bool is_invokedynamic = code == Bytecodes::_invokedynamic;
3442 const bool is_invokehandle = code == Bytecodes::_invokehandle;
3443 const bool is_invokevirtual = code == Bytecodes::_invokevirtual;
3444 const bool is_invokespecial = code == Bytecodes::_invokespecial;
3445 const bool load_receiver = (recv != noreg);
3446 const bool save_flags = (flags != noreg);
3447 assert(load_receiver == (code != Bytecodes::_invokestatic && code != Bytecodes::_invokedynamic), "");
3448 assert(save_flags == (is_invokeinterface || is_invokevirtual), "need flags for vfinal");
3449 assert(flags == noreg || flags == r3, "");
3450 assert(recv == noreg || recv == r2, "");
3451
3452 // setup registers & access constant pool cache
3453 if (recv == noreg) recv = r2;
3454 if (flags == noreg) flags = r3;
3455 assert_different_registers(method, index, recv, flags);
3456
3457 // save 'interpreter return address'
3458 __ save_bcp();
3459
3460 load_invoke_cp_cache_entry(byte_no, method, index, flags, is_invokevirtual, false, is_invokedynamic);
3461
3462 // maybe push appendix to arguments (just before return address)
3463 if (is_invokedynamic || is_invokehandle) {
3464 Label L_no_push;
3465 __ tbz(flags, ConstantPoolCacheEntry::has_appendix_shift, L_no_push);
3466 // Push the appendix as a trailing parameter.
3467 // This must be done before we get the receiver,
3468 // since the parameter_size includes it.
3469 __ push(r19);
3470 __ mov(r19, index);
3471 __ load_resolved_reference_at_index(index, r19);
3472 __ pop(r19);
3473 __ push(index); // push appendix (MethodType, CallSite, etc.)
3474 __ bind(L_no_push);
3475 }
3476
3477 // load receiver if needed (note: no return address pushed yet)
3478 if (load_receiver) {
3479 __ andw(recv, flags, ConstantPoolCacheEntry::parameter_size_mask);
3480 // FIXME -- is this actually correct? looks like it should be 2
3481 // const int no_return_pc_pushed_yet = -1; // argument slot correction before we push return address
3482 // const int receiver_is_at_end = -1; // back off one slot to get receiver
3483 // Address recv_addr = __ argument_address(recv, no_return_pc_pushed_yet + receiver_is_at_end);
3484 // __ movptr(recv, recv_addr);
3485 __ add(rscratch1, esp, recv, ext::uxtx, 3); // FIXME: uxtb here?
3486 __ ldr(recv, Address(rscratch1, -Interpreter::expr_offset_in_bytes(1)));
3487 __ verify_oop(recv);
3488 }
3489
3490 // compute return type
3491 // x86 uses a shift and mask or wings it with a shift plus assert
3492 // the mask is not needed. aarch64 just uses bitfield extract
3493 __ ubfxw(rscratch2, flags, ConstantPoolCacheEntry::tos_state_shift, ConstantPoolCacheEntry::tos_state_bits);
3494 // load return address
3495 {
3496 const address table_addr = (address) Interpreter::invoke_return_entry_table_for(code);
3497 __ mov(rscratch1, table_addr);
3498 __ ldr(lr, Address(rscratch1, rscratch2, Address::lsl(3)));
3499 }
3500 }
3501
3502
3503 void TemplateTable::invokevirtual_helper(Register index,
3504 Register recv,
3505 Register flags)
3506 {
3507 // Uses temporary registers r0, r3
3508 assert_different_registers(index, recv, r0, r3);
3509 // Test for an invoke of a final method
3510 Label notFinal;
3511 __ tbz(flags, ConstantPoolCacheEntry::is_vfinal_shift, notFinal);
3512
3513 const Register method = index; // method must be rmethod
3514 assert(method == rmethod,
3515 "Method must be rmethod for interpreter calling convention");
3516
3517 // do the call - the index is actually the method to call
3518 // that is, f2 is a vtable index if !is_vfinal, else f2 is a Method*
3519
3520 // It's final, need a null check here!
3521 __ null_check(recv);
3522
3523 // profile this call
3524 __ profile_final_call(r0);
3525 __ profile_arguments_type(r0, method, r4, true);
3526
3527 __ jump_from_interpreted(method, r0);
3528
3529 __ bind(notFinal);
3530
3531 // get receiver klass
3532 __ null_check(recv, oopDesc::klass_offset_in_bytes());
3533 __ load_klass(r0, recv);
3534
3535 // profile this call
3536 __ profile_virtual_call(r0, rlocals, r3);
3537
3538 // get target Method & entry point
3539 __ lookup_virtual_method(r0, index, method);
3540 __ profile_arguments_type(r3, method, r4, true);
3541 // FIXME -- this looks completely redundant. is it?
3542 // __ ldr(r3, Address(method, Method::interpreter_entry_offset()));
3543 __ jump_from_interpreted(method, r3);
3544 }
3545
3546 void TemplateTable::invokevirtual(int byte_no)
3547 {
3548 transition(vtos, vtos);
3549 assert(byte_no == f2_byte, "use this argument");
3550
3551 prepare_invoke(byte_no, rmethod, noreg, r2, r3);
3552
3553 // rmethod: index (actually a Method*)
3554 // r2: receiver
3555 // r3: flags
3556
3557 invokevirtual_helper(rmethod, r2, r3);
3558 }
3559
3560 void TemplateTable::invokespecial(int byte_no)
3561 {
3562 transition(vtos, vtos);
3563 assert(byte_no == f1_byte, "use this argument");
3564
3565 prepare_invoke(byte_no, rmethod, noreg, // get f1 Method*
3566 r2); // get receiver also for null check
3567 __ verify_oop(r2);
3568 __ null_check(r2);
3569 // do the call
3570 __ profile_call(r0);
3571 __ profile_arguments_type(r0, rmethod, rbcp, false);
3572 __ jump_from_interpreted(rmethod, r0);
3573 }
3574
3575 void TemplateTable::invokestatic(int byte_no)
3576 {
3577 transition(vtos, vtos);
3578 assert(byte_no == f1_byte, "use this argument");
3579
3580 prepare_invoke(byte_no, rmethod); // get f1 Method*
3581 // do the call
3582 __ profile_call(r0);
3583 __ profile_arguments_type(r0, rmethod, r4, false);
3584 __ jump_from_interpreted(rmethod, r0);
3585 }
3586
3587 void TemplateTable::fast_invokevfinal(int byte_no)
3588 {
3589 __ call_Unimplemented();
3590 }
3591
3592 void TemplateTable::invokeinterface(int byte_no) {
3593 transition(vtos, vtos);
3594 assert(byte_no == f1_byte, "use this argument");
3595
3596 prepare_invoke(byte_no, r0, rmethod, // get f1 Klass*, f2 Method*
3597 r2, r3); // recv, flags
3598
3599 // r0: interface klass (from f1)
3600 // rmethod: method (from f2)
3601 // r2: receiver
3602 // r3: flags
3603
3604 // First check for Object case, then private interface method,
3605 // then regular interface method.
3606
3607 // Special case of invokeinterface called for virtual method of
3608 // java.lang.Object. See cpCache.cpp for details.
3609 Label notObjectMethod;
3610 __ tbz(r3, ConstantPoolCacheEntry::is_forced_virtual_shift, notObjectMethod);
3611
3612 invokevirtual_helper(rmethod, r2, r3);
3613 __ bind(notObjectMethod);
3614
3615 Label no_such_interface;
3616
3617 // Check for private method invocation - indicated by vfinal
3618 Label notVFinal;
3619 __ tbz(r3, ConstantPoolCacheEntry::is_vfinal_shift, notVFinal);
3620
3621 // Get receiver klass into r3 - also a null check
3622 __ null_check(r2, oopDesc::klass_offset_in_bytes());
3623 __ load_klass(r3, r2);
3624
3625 Label subtype;
3626 __ check_klass_subtype(r3, r0, r4, subtype);
3627 // If we get here the typecheck failed
3628 __ b(no_such_interface);
3629 __ bind(subtype);
3630
3631 __ profile_final_call(r0);
3632 __ profile_arguments_type(r0, rmethod, r4, true);
3633 __ jump_from_interpreted(rmethod, r0);
3634
3635 __ bind(notVFinal);
3636
3637 // Get receiver klass into r3 - also a null check
3638 __ restore_locals();
3639 __ null_check(r2, oopDesc::klass_offset_in_bytes());
3640 __ load_klass(r3, r2);
3641
3642 Label no_such_method;
3643
3644 // Preserve method for throw_AbstractMethodErrorVerbose.
3645 __ mov(r16, rmethod);
3646 // Receiver subtype check against REFC.
3647 // Superklass in r0. Subklass in r3. Blows rscratch2, r13
3648 __ lookup_interface_method(// inputs: rec. class, interface, itable index
3649 r3, r0, noreg,
3650 // outputs: scan temp. reg, scan temp. reg
3651 rscratch2, r13,
3652 no_such_interface,
3653 /*return_method=*/false);
3654
3655 // profile this call
3656 __ profile_virtual_call(r3, r13, r19);
3657
3658 // Get declaring interface class from method, and itable index
3659
3660 __ load_method_holder(r0, rmethod);
3661 __ ldrw(rmethod, Address(rmethod, Method::itable_index_offset()));
3662 __ subw(rmethod, rmethod, Method::itable_index_max);
3663 __ negw(rmethod, rmethod);
3664
3665 // Preserve recvKlass for throw_AbstractMethodErrorVerbose.
3666 __ mov(rlocals, r3);
3667 __ lookup_interface_method(// inputs: rec. class, interface, itable index
3668 rlocals, r0, rmethod,
3669 // outputs: method, scan temp. reg
3670 rmethod, r13,
3671 no_such_interface);
3672
3673 // rmethod,: Method to call
3674 // r2: receiver
3675 // Check for abstract method error
3676 // Note: This should be done more efficiently via a throw_abstract_method_error
3677 // interpreter entry point and a conditional jump to it in case of a null
3678 // method.
3679 __ cbz(rmethod, no_such_method);
3680
3681 __ profile_arguments_type(r3, rmethod, r13, true);
3682
3683 // do the call
3684 // r2: receiver
3685 // rmethod,: Method
3686 __ jump_from_interpreted(rmethod, r3);
3687 __ should_not_reach_here();
3688
3689 // exception handling code follows...
3690 // note: must restore interpreter registers to canonical
3691 // state for exception handling to work correctly!
3692
3693 __ bind(no_such_method);
3694 // throw exception
3695 __ restore_bcp(); // bcp must be correct for exception handler (was destroyed)
3696 __ restore_locals(); // make sure locals pointer is correct as well (was destroyed)
3697 // Pass arguments for generating a verbose error message.
3698 __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::throw_AbstractMethodErrorVerbose), r3, r16);
3699 // the call_VM checks for exception, so we should never return here.
3700 __ should_not_reach_here();
3701
3702 __ bind(no_such_interface);
3703 // throw exception
3704 __ restore_bcp(); // bcp must be correct for exception handler (was destroyed)
3705 __ restore_locals(); // make sure locals pointer is correct as well (was destroyed)
3706 // Pass arguments for generating a verbose error message.
3707 __ call_VM(noreg, CAST_FROM_FN_PTR(address,
3708 InterpreterRuntime::throw_IncompatibleClassChangeErrorVerbose), r3, r0);
3709 // the call_VM checks for exception, so we should never return here.
3710 __ should_not_reach_here();
3711 return;
3712 }
3713
3714 void TemplateTable::invokehandle(int byte_no) {
3715 transition(vtos, vtos);
3716 assert(byte_no == f1_byte, "use this argument");
3717
3718 prepare_invoke(byte_no, rmethod, r0, r2);
3719 __ verify_method_ptr(r2);
3720 __ verify_oop(r2);
3721 __ null_check(r2);
3722
3723 // FIXME: profile the LambdaForm also
3724
3725 // r13 is safe to use here as a scratch reg because it is about to
3726 // be clobbered by jump_from_interpreted().
3727 __ profile_final_call(r13);
3728 __ profile_arguments_type(r13, rmethod, r4, true);
3729
3730 __ jump_from_interpreted(rmethod, r0);
3731 }
3732
3733 void TemplateTable::invokedynamic(int byte_no) {
3734 transition(vtos, vtos);
3735 assert(byte_no == f1_byte, "use this argument");
3736
3737 prepare_invoke(byte_no, rmethod, r0);
3738
3739 // r0: CallSite object (from cpool->resolved_references[])
3740 // rmethod: MH.linkToCallSite method (from f2)
3741
3742 // Note: r0_callsite is already pushed by prepare_invoke
3743
3744 // %%% should make a type profile for any invokedynamic that takes a ref argument
3745 // profile this call
3746 __ profile_call(rbcp);
3747 __ profile_arguments_type(r3, rmethod, r13, false);
3748
3749 __ verify_oop(r0);
3750
3751 __ jump_from_interpreted(rmethod, r0);
3752 }
3753
3754
3755 //-----------------------------------------------------------------------------
3756 // Allocation
3757
3758 void TemplateTable::_new() {
3759 transition(vtos, atos);
3760
3761 __ get_unsigned_2_byte_index_at_bcp(r3, 1);
3762 Label slow_case;
3763 Label done;
3764 Label is_not_value;
3765 Label initialize_header;
3766
3767 __ get_cpool_and_tags(r4, r0);
3768 // Make sure the class we're about to instantiate has been resolved.
3769 // This is done before loading InstanceKlass to be consistent with the order
3770 // how Constant Pool is updated (see ConstantPool::klass_at_put)
3771 const int tags_offset = Array<u1>::base_offset_in_bytes();
3772 __ lea(rscratch1, Address(r0, r3, Address::lsl(0)));
3773 __ lea(rscratch1, Address(rscratch1, tags_offset));
3774 __ ldarb(rscratch1, rscratch1);
3775 __ cmp(rscratch1, (u1)JVM_CONSTANT_Class);
3776 __ br(Assembler::NE, slow_case);
3777
3778 // get InstanceKlass
3779 __ load_resolved_klass_at_offset(r4, r3, r4, rscratch1);
3780
3781 __ ldrb(rscratch1, Address(r4, InstanceKlass::kind_offset()));
3782 __ cmp(rscratch1, (u1)InlineKlassKind);
3783 __ br(Assembler::NE, is_not_value);
3784
3785 __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::throw_InstantiationError));
3786
3787 __ bind(is_not_value);
3788
3789 // make sure klass is initialized & doesn't have finalizer
3790 // make sure klass is fully initialized
3791 __ ldrb(rscratch1, Address(r4, InstanceKlass::init_state_offset()));
3792 __ cmp(rscratch1, (u1)InstanceKlass::fully_initialized);
3793 __ br(Assembler::NE, slow_case);
3794
3795 __ allocate_instance(r4, r0, r3, r1, true, slow_case);
3796 __ b(done);
3797
3798 // slow case
3799 __ bind(slow_case);
3800 __ get_constant_pool(c_rarg1);
3801 __ get_unsigned_2_byte_index_at_bcp(c_rarg2, 1);
3802 call_VM(r0, CAST_FROM_FN_PTR(address, InterpreterRuntime::_new), c_rarg1, c_rarg2);
3803 __ verify_oop(r0);
3804
3805 // continue
3806 __ bind(done);
3807 // Must prevent reordering of stores for object initialization with stores that publish the new object.
3808 __ membar(Assembler::StoreStore);
3809 }
3810
3811 void TemplateTable::aconst_init() {
3812 transition(vtos, atos);
3813 __ get_unsigned_2_byte_index_at_bcp(c_rarg2, 1);
3814 __ get_constant_pool(c_rarg1);
3815 call_VM(r0, CAST_FROM_FN_PTR(address, InterpreterRuntime::aconst_init),
3816 c_rarg1, c_rarg2);
3817 __ verify_oop(r0);
3818 // Must prevent reordering of stores for object initialization with stores that publish the new object.
3819 __ membar(Assembler::StoreStore);
3820 }
3821
3822 void TemplateTable::withfield() {
3823 transition(vtos, atos);
3824 resolve_cache_and_index(f2_byte, c_rarg1 /*cache*/, c_rarg2 /*index*/, sizeof(u2));
3825
3826 ByteSize cp_base_offset = ConstantPoolCache::base_offset();
3827
3828 // n.b. unlike x86 cache is now rcpool plus the indexed offset
3829 __ lea(c_rarg1, Address(c_rarg1, in_bytes(cp_base_offset)));
3830
3831 __ lea(c_rarg2, at_tos());
3832 call_VM(r1, CAST_FROM_FN_PTR(address, InterpreterRuntime::withfield), c_rarg1, c_rarg2);
3833 // new value type is returned in r1
3834 // stack adjustment is returned in r0
3835 __ verify_oop(r1);
3836 __ add(esp, esp, r0);
3837 __ mov(r0, r1);
3838 }
3839
3840 void TemplateTable::newarray() {
3841 transition(itos, atos);
3842 __ load_unsigned_byte(c_rarg1, at_bcp(1));
3843 __ mov(c_rarg2, r0);
3844 call_VM(r0, CAST_FROM_FN_PTR(address, InterpreterRuntime::newarray),
3845 c_rarg1, c_rarg2);
3846 // Must prevent reordering of stores for object initialization with stores that publish the new object.
3847 __ membar(Assembler::StoreStore);
3848 }
3849
3850 void TemplateTable::anewarray() {
3851 transition(itos, atos);
3852 __ get_unsigned_2_byte_index_at_bcp(c_rarg2, 1);
3853 __ get_constant_pool(c_rarg1);
3854 __ mov(c_rarg3, r0);
3855 call_VM(r0, CAST_FROM_FN_PTR(address, InterpreterRuntime::anewarray),
3856 c_rarg1, c_rarg2, c_rarg3);
3857 // Must prevent reordering of stores for object initialization with stores that publish the new object.
3858 __ membar(Assembler::StoreStore);
3859 }
3860
3861 void TemplateTable::arraylength() {
3862 transition(atos, itos);
3863 __ null_check(r0, arrayOopDesc::length_offset_in_bytes());
3864 __ ldrw(r0, Address(r0, arrayOopDesc::length_offset_in_bytes()));
3865 }
3866
3867 void TemplateTable::checkcast()
3868 {
3869 transition(atos, atos);
3870 Label done, is_null, ok_is_subtype, quicked, resolved;
3871 __ cbz(r0, is_null);
3872
3873 // Get cpool & tags index
3874 __ get_cpool_and_tags(r2, r3); // r2=cpool, r3=tags array
3875 __ get_unsigned_2_byte_index_at_bcp(r19, 1); // r19=index
3876 // See if bytecode has already been quicked
3877 __ add(rscratch1, r3, Array<u1>::base_offset_in_bytes());
3878 __ lea(r1, Address(rscratch1, r19));
3879 __ ldarb(r1, r1);
3880 __ andr(r1, r1, ~JVM_CONSTANT_QDescBit);
3881 __ cmp(r1, (u1)JVM_CONSTANT_Class);
3882 __ br(Assembler::EQ, quicked);
3883
3884 __ push(atos); // save receiver for result, and for GC
3885 call_VM(r0, CAST_FROM_FN_PTR(address, InterpreterRuntime::quicken_io_cc));
3886 // vm_result_2 has metadata result
3887 __ get_vm_result_2(r0, rthread);
3888 __ pop(r3); // restore receiver
3889 __ b(resolved);
3890
3891 // Get superklass in r0 and subklass in r3
3892 __ bind(quicked);
3893 __ mov(r3, r0); // Save object in r3; r0 needed for subtype check
3894 __ load_resolved_klass_at_offset(r2, r19, r0, rscratch1); // r0 = klass
3895
3896 __ bind(resolved);
3897 __ load_klass(r19, r3);
3898
3899 // Generate subtype check. Blows r2, r5. Object in r3.
3900 // Superklass in r0. Subklass in r19.
3901 __ gen_subtype_check(r19, ok_is_subtype);
3902
3903 // Come here on failure
3904 __ push(r3);
3905 // object is at TOS
3906 __ b(Interpreter::_throw_ClassCastException_entry);
3907
3908 // Come here on success
3909 __ bind(ok_is_subtype);
3910 __ mov(r0, r3); // Restore object in r3
3911
3912 __ b(done);
3913 __ bind(is_null);
3914
3915 // Collect counts on whether this test sees NULLs a lot or not.
3916 if (ProfileInterpreter) {
3917 __ profile_null_seen(r2);
3918 }
3919
3920 if (EnablePrimitiveClasses) {
3921 // Get cpool & tags index
3922 __ get_cpool_and_tags(r2, r3); // r2=cpool, r3=tags array
3923 __ get_unsigned_2_byte_index_at_bcp(r19, 1); // r19=index
3924 // See if bytecode has already been quicked
3925 __ add(rscratch1, r3, Array<u1>::base_offset_in_bytes());
3926 __ lea(r1, Address(rscratch1, r19));
3927 __ ldarb(r1, r1);
3928 // See if CP entry is a Q-descriptor
3929 __ andr (r1, r1, JVM_CONSTANT_QDescBit);
3930 __ cmp(r1, (u1) JVM_CONSTANT_QDescBit);
3931 __ br(Assembler::NE, done);
3932 __ b(ExternalAddress(Interpreter::_throw_NullPointerException_entry));
3933 }
3934
3935 __ bind(done);
3936 }
3937
3938 void TemplateTable::instanceof() {
3939 transition(atos, itos);
3940 Label done, is_null, ok_is_subtype, quicked, resolved;
3941 __ cbz(r0, is_null);
3942
3943 // Get cpool & tags index
3944 __ get_cpool_and_tags(r2, r3); // r2=cpool, r3=tags array
3945 __ get_unsigned_2_byte_index_at_bcp(r19, 1); // r19=index
3946 // See if bytecode has already been quicked
3947 __ add(rscratch1, r3, Array<u1>::base_offset_in_bytes());
3948 __ lea(r1, Address(rscratch1, r19));
3949 __ ldarb(r1, r1);
3950 __ andr(r1, r1, ~JVM_CONSTANT_QDescBit);
3951 __ cmp(r1, (u1)JVM_CONSTANT_Class);
3952 __ br(Assembler::EQ, quicked);
3953
3954 __ push(atos); // save receiver for result, and for GC
3955 call_VM(r0, CAST_FROM_FN_PTR(address, InterpreterRuntime::quicken_io_cc));
3956 // vm_result_2 has metadata result
3957 __ get_vm_result_2(r0, rthread);
3958 __ pop(r3); // restore receiver
3959 __ verify_oop(r3);
3960 __ load_klass(r3, r3);
3961 __ b(resolved);
3962
3963 // Get superklass in r0 and subklass in r3
3964 __ bind(quicked);
3965 __ load_klass(r3, r0);
3966 __ load_resolved_klass_at_offset(r2, r19, r0, rscratch1);
3967
3968 __ bind(resolved);
3969
3970 // Generate subtype check. Blows r2, r5
3971 // Superklass in r0. Subklass in r3.
3972 __ gen_subtype_check(r3, ok_is_subtype);
3973
3974 // Come here on failure
3975 __ mov(r0, 0);
3976 __ b(done);
3977 // Come here on success
3978 __ bind(ok_is_subtype);
3979 __ mov(r0, 1);
3980
3981 // Collect counts on whether this test sees NULLs a lot or not.
3982 if (ProfileInterpreter) {
3983 __ b(done);
3984 __ bind(is_null);
3985 __ profile_null_seen(r2);
3986 } else {
3987 __ bind(is_null); // same as 'done'
3988 }
3989 __ bind(done);
3990 // r0 = 0: obj == NULL or obj is not an instanceof the specified klass
3991 // r0 = 1: obj != NULL and obj is an instanceof the specified klass
3992 }
3993
3994 //-----------------------------------------------------------------------------
3995 // Breakpoints
3996 void TemplateTable::_breakpoint() {
3997 // Note: We get here even if we are single stepping..
3998 // jbug inists on setting breakpoints at every bytecode
3999 // even if we are in single step mode.
4000
4001 transition(vtos, vtos);
4002
4003 // get the unpatched byte code
4004 __ get_method(c_rarg1);
4005 __ call_VM(noreg,
4006 CAST_FROM_FN_PTR(address,
4007 InterpreterRuntime::get_original_bytecode_at),
4008 c_rarg1, rbcp);
4009 __ mov(r19, r0);
4010
4011 // post the breakpoint event
4012 __ call_VM(noreg,
4013 CAST_FROM_FN_PTR(address, InterpreterRuntime::_breakpoint),
4014 rmethod, rbcp);
4015
4016 // complete the execution of original bytecode
4017 __ mov(rscratch1, r19);
4018 __ dispatch_only_normal(vtos);
4019 }
4020
4021 //-----------------------------------------------------------------------------
4022 // Exceptions
4023
4024 void TemplateTable::athrow() {
4025 transition(atos, vtos);
4026 __ null_check(r0);
4027 __ b(Interpreter::throw_exception_entry());
4028 }
4029
4030 //-----------------------------------------------------------------------------
4031 // Synchronization
4032 //
4033 // Note: monitorenter & exit are symmetric routines; which is reflected
4034 // in the assembly code structure as well
4035 //
4036 // Stack layout:
4037 //
4038 // [expressions ] <--- esp = expression stack top
4039 // ..
4040 // [expressions ]
4041 // [monitor entry] <--- monitor block top = expression stack bot
4042 // ..
4043 // [monitor entry]
4044 // [frame data ] <--- monitor block bot
4045 // ...
4046 // [saved rfp ] <--- rfp
4047 void TemplateTable::monitorenter()
4048 {
4049 transition(atos, vtos);
4050
4051 // check for NULL object
4052 __ null_check(r0);
4053
4054 Label is_inline_type;
4055 __ ldr(rscratch1, Address(r0, oopDesc::mark_offset_in_bytes()));
4056 __ test_markword_is_inline_type(rscratch1, is_inline_type);
4057
4058 const Address monitor_block_top(
4059 rfp, frame::interpreter_frame_monitor_block_top_offset * wordSize);
4060 const Address monitor_block_bot(
4061 rfp, frame::interpreter_frame_initial_sp_offset * wordSize);
4062 const int entry_size = frame::interpreter_frame_monitor_size() * wordSize;
4063
4064 Label allocated;
4065
4066 // initialize entry pointer
4067 __ mov(c_rarg1, zr); // points to free slot or NULL
4068
4069 // find a free slot in the monitor block (result in c_rarg1)
4070 {
4071 Label entry, loop, exit;
4072 __ ldr(c_rarg3, monitor_block_top); // points to current entry,
4073 // starting with top-most entry
4074 __ lea(c_rarg2, monitor_block_bot); // points to word before bottom
4075
4076 __ b(entry);
4077
4078 __ bind(loop);
4079 // check if current entry is used
4080 // if not used then remember entry in c_rarg1
4081 __ ldr(rscratch1, Address(c_rarg3, BasicObjectLock::obj_offset_in_bytes()));
4082 __ cmp(zr, rscratch1);
4083 __ csel(c_rarg1, c_rarg3, c_rarg1, Assembler::EQ);
4084 // check if current entry is for same object
4085 __ cmp(r0, rscratch1);
4086 // if same object then stop searching
4087 __ br(Assembler::EQ, exit);
4088 // otherwise advance to next entry
4089 __ add(c_rarg3, c_rarg3, entry_size);
4090 __ bind(entry);
4091 // check if bottom reached
4092 __ cmp(c_rarg3, c_rarg2);
4093 // if not at bottom then check this entry
4094 __ br(Assembler::NE, loop);
4095 __ bind(exit);
4096 }
4097
4098 __ cbnz(c_rarg1, allocated); // check if a slot has been found and
4099 // if found, continue with that on
4100
4101 // allocate one if there's no free slot
4102 {
4103 Label entry, loop;
4104 // 1. compute new pointers // rsp: old expression stack top
4105
4106 __ check_extended_sp();
4107 __ sub(sp, sp, entry_size); // make room for the monitor
4108 __ mov(rscratch1, sp);
4109 __ str(rscratch1, Address(rfp, frame::interpreter_frame_extended_sp_offset * wordSize));
4110
4111 __ ldr(c_rarg1, monitor_block_bot); // c_rarg1: old expression stack bottom
4112 __ sub(esp, esp, entry_size); // move expression stack top
4113 __ sub(c_rarg1, c_rarg1, entry_size); // move expression stack bottom
4114 __ mov(c_rarg3, esp); // set start value for copy loop
4115 __ str(c_rarg1, monitor_block_bot); // set new monitor block bottom
4116
4117 __ b(entry);
4118 // 2. move expression stack contents
4119 __ bind(loop);
4120 __ ldr(c_rarg2, Address(c_rarg3, entry_size)); // load expression stack
4121 // word from old location
4122 __ str(c_rarg2, Address(c_rarg3, 0)); // and store it at new location
4123 __ add(c_rarg3, c_rarg3, wordSize); // advance to next word
4124 __ bind(entry);
4125 __ cmp(c_rarg3, c_rarg1); // check if bottom reached
4126 __ br(Assembler::NE, loop); // if not at bottom then
4127 // copy next word
4128 }
4129
4130 // call run-time routine
4131 // c_rarg1: points to monitor entry
4132 __ bind(allocated);
4133
4134 // Increment bcp to point to the next bytecode, so exception
4135 // handling for async. exceptions work correctly.
4136 // The object has already been popped from the stack, so the
4137 // expression stack looks correct.
4138 __ increment(rbcp);
4139
4140 // store object
4141 __ str(r0, Address(c_rarg1, BasicObjectLock::obj_offset_in_bytes()));
4142 __ lock_object(c_rarg1);
4143
4144 // check to make sure this monitor doesn't cause stack overflow after locking
4145 __ save_bcp(); // in case of exception
4146 __ generate_stack_overflow_check(0);
4147
4148 // The bcp has already been incremented. Just need to dispatch to
4149 // next instruction.
4150 __ dispatch_next(vtos);
4151
4152 __ bind(is_inline_type);
4153 __ call_VM(noreg, CAST_FROM_FN_PTR(address,
4154 InterpreterRuntime::throw_illegal_monitor_state_exception));
4155 __ should_not_reach_here();
4156 }
4157
4158
4159 void TemplateTable::monitorexit()
4160 {
4161 transition(atos, vtos);
4162
4163 // check for NULL object
4164 __ null_check(r0);
4165
4166 const int is_inline_type_mask = markWord::inline_type_pattern;
4167 Label has_identity;
4168 __ ldr(rscratch1, Address(r0, oopDesc::mark_offset_in_bytes()));
4169 __ mov(rscratch2, is_inline_type_mask);
4170 __ andr(rscratch1, rscratch1, rscratch2);
4171 __ cmp(rscratch1, rscratch2);
4172 __ br(Assembler::NE, has_identity);
4173 __ call_VM(noreg, CAST_FROM_FN_PTR(address,
4174 InterpreterRuntime::throw_illegal_monitor_state_exception));
4175 __ should_not_reach_here();
4176 __ bind(has_identity);
4177
4178 const Address monitor_block_top(
4179 rfp, frame::interpreter_frame_monitor_block_top_offset * wordSize);
4180 const Address monitor_block_bot(
4181 rfp, frame::interpreter_frame_initial_sp_offset * wordSize);
4182 const int entry_size = frame::interpreter_frame_monitor_size() * wordSize;
4183
4184 Label found;
4185
4186 // find matching slot
4187 {
4188 Label entry, loop;
4189 __ ldr(c_rarg1, monitor_block_top); // points to current entry,
4190 // starting with top-most entry
4191 __ lea(c_rarg2, monitor_block_bot); // points to word before bottom
4192 // of monitor block
4193 __ b(entry);
4194
4195 __ bind(loop);
4196 // check if current entry is for same object
4197 __ ldr(rscratch1, Address(c_rarg1, BasicObjectLock::obj_offset_in_bytes()));
4198 __ cmp(r0, rscratch1);
4199 // if same object then stop searching
4200 __ br(Assembler::EQ, found);
4201 // otherwise advance to next entry
4202 __ add(c_rarg1, c_rarg1, entry_size);
4203 __ bind(entry);
4204 // check if bottom reached
4205 __ cmp(c_rarg1, c_rarg2);
4206 // if not at bottom then check this entry
4207 __ br(Assembler::NE, loop);
4208 }
4209
4210 // error handling. Unlocking was not block-structured
4211 __ call_VM(noreg, CAST_FROM_FN_PTR(address,
4212 InterpreterRuntime::throw_illegal_monitor_state_exception));
4213 __ should_not_reach_here();
4214
4215 // call run-time routine
4216 __ bind(found);
4217 __ push_ptr(r0); // make sure object is on stack (contract with oopMaps)
4218 __ unlock_object(c_rarg1);
4219 __ pop_ptr(r0); // discard object
4220 }
4221
4222
4223 // Wide instructions
4224 void TemplateTable::wide()
4225 {
4226 __ load_unsigned_byte(r19, at_bcp(1));
4227 __ mov(rscratch1, (address)Interpreter::_wentry_point);
4228 __ ldr(rscratch1, Address(rscratch1, r19, Address::uxtw(3)));
4229 __ br(rscratch1);
4230 }
4231
4232
4233 // Multi arrays
4234 void TemplateTable::multianewarray() {
4235 transition(vtos, atos);
4236 __ load_unsigned_byte(r0, at_bcp(3)); // get number of dimensions
4237 // last dim is on top of stack; we want address of first one:
4238 // first_addr = last_addr + (ndims - 1) * wordSize
4239 __ lea(c_rarg1, Address(esp, r0, Address::uxtw(3)));
4240 __ sub(c_rarg1, c_rarg1, wordSize);
4241 call_VM(r0,
4242 CAST_FROM_FN_PTR(address, InterpreterRuntime::multianewarray),
4243 c_rarg1);
4244 __ load_unsigned_byte(r1, at_bcp(3));
4245 __ lea(esp, Address(esp, r1, Address::uxtw(3)));
4246 }