155 static void do_oop_load(InterpreterMacroAssembler* _masm,
156 Address src,
157 Register dst,
158 DecoratorSet decorators) {
159 __ load_heap_oop(dst, src, r10, r11, decorators);
160 }
161
162 Address TemplateTable::at_bcp(int offset) {
163 assert(_desc->uses_bcp(), "inconsistent uses_bcp information");
164 return Address(rbcp, offset);
165 }
166
167 void TemplateTable::patch_bytecode(Bytecodes::Code bc, Register bc_reg,
168 Register temp_reg, bool load_bc_into_bc_reg/*=true*/,
169 int byte_no)
170 {
171 if (!RewriteBytecodes) return;
172 Label L_patch_done;
173
174 switch (bc) {
175 case Bytecodes::_fast_aputfield:
176 case Bytecodes::_fast_bputfield:
177 case Bytecodes::_fast_zputfield:
178 case Bytecodes::_fast_cputfield:
179 case Bytecodes::_fast_dputfield:
180 case Bytecodes::_fast_fputfield:
181 case Bytecodes::_fast_iputfield:
182 case Bytecodes::_fast_lputfield:
183 case Bytecodes::_fast_sputfield:
184 {
185 // We skip bytecode quickening for putfield instructions when
186 // the put_code written to the constant pool cache is zero.
187 // This is required so that every execution of this instruction
188 // calls out to InterpreterRuntime::resolve_get_put to do
189 // additional, required work.
190 assert(byte_no == f1_byte || byte_no == f2_byte, "byte_no out of range");
191 assert(load_bc_into_bc_reg, "we use bc_reg as temp");
192 __ load_field_entry(temp_reg, bc_reg);
193 if (byte_no == f1_byte) {
194 __ lea(temp_reg, Address(temp_reg, in_bytes(ResolvedFieldEntry::get_code_offset())));
736 locals_index_wide(r1);
737 __ ldr(r0, aaddress(r1));
738 }
739
740 void TemplateTable::index_check(Register array, Register index)
741 {
742 // destroys r1, rscratch1
743 // sign extend index for use by indexed load
744 // __ movl2ptr(index, index);
745 // check index
746 Register length = rscratch1;
747 __ ldrw(length, Address(array, arrayOopDesc::length_offset_in_bytes()));
748 __ cmpw(index, length);
749 if (index != r1) {
750 // ??? convention: move aberrant index into r1 for exception message
751 assert(r1 != array, "different registers");
752 __ mov(r1, index);
753 }
754 Label ok;
755 __ br(Assembler::LO, ok);
756 // ??? convention: move array into r3 for exception message
757 __ mov(r3, array);
758 __ mov(rscratch1, Interpreter::_throw_ArrayIndexOutOfBoundsException_entry);
759 __ br(rscratch1);
760 __ bind(ok);
761 }
762
763 void TemplateTable::iaload()
764 {
765 transition(itos, itos);
766 __ mov(r1, r0);
767 __ pop_ptr(r0);
768 // r0: array
769 // r1: index
770 index_check(r0, r1); // leaves index in r1, kills rscratch1
771 __ add(r1, r1, arrayOopDesc::base_offset_in_bytes(T_INT) >> 2);
772 __ access_load_at(T_INT, IN_HEAP | IS_ARRAY, r0, Address(r0, r1, Address::uxtw(2)), noreg, noreg);
773 }
774
775 void TemplateTable::laload()
776 {
777 transition(itos, ltos);
778 __ mov(r1, r0);
779 __ pop_ptr(r0);
799 void TemplateTable::daload()
800 {
801 transition(itos, dtos);
802 __ mov(r1, r0);
803 __ pop_ptr(r0);
804 // r0: array
805 // r1: index
806 index_check(r0, r1); // leaves index in r1, kills rscratch1
807 __ add(r1, r1, arrayOopDesc::base_offset_in_bytes(T_DOUBLE) >> 3);
808 __ access_load_at(T_DOUBLE, IN_HEAP | IS_ARRAY, r0, Address(r0, r1, Address::uxtw(3)), noreg, noreg);
809 }
810
811 void TemplateTable::aaload()
812 {
813 transition(itos, atos);
814 __ mov(r1, r0);
815 __ pop_ptr(r0);
816 // r0: array
817 // r1: index
818 index_check(r0, r1); // leaves index in r1, kills rscratch1
819 __ add(r1, r1, arrayOopDesc::base_offset_in_bytes(T_OBJECT) >> LogBytesPerHeapOop);
820 do_oop_load(_masm,
821 Address(r0, r1, Address::uxtw(LogBytesPerHeapOop)),
822 r0,
823 IS_ARRAY);
824 }
825
826 void TemplateTable::baload()
827 {
828 transition(itos, itos);
829 __ mov(r1, r0);
830 __ pop_ptr(r0);
831 // r0: array
832 // r1: index
833 index_check(r0, r1); // leaves index in r1, kills rscratch1
834 __ add(r1, r1, arrayOopDesc::base_offset_in_bytes(T_BYTE) >> 0);
835 __ access_load_at(T_BYTE, IN_HEAP | IS_ARRAY, r0, Address(r0, r1, Address::uxtw(0)), noreg, noreg);
836 }
837
838 void TemplateTable::caload()
839 {
840 transition(itos, itos);
841 __ mov(r1, r0);
842 __ pop_ptr(r0);
843 // r0: array
1090 // r1: index
1091 // r3: array
1092 index_check(r3, r1); // prefer index in r1
1093 __ add(r1, r1, arrayOopDesc::base_offset_in_bytes(T_FLOAT) >> 2);
1094 __ access_store_at(T_FLOAT, IN_HEAP | IS_ARRAY, Address(r3, r1, Address::uxtw(2)), noreg /* ftos */, noreg, noreg, noreg);
1095 }
1096
1097 void TemplateTable::dastore() {
1098 transition(dtos, vtos);
1099 __ pop_i(r1);
1100 __ pop_ptr(r3);
1101 // v0: value
1102 // r1: index
1103 // r3: array
1104 index_check(r3, r1); // prefer index in r1
1105 __ add(r1, r1, arrayOopDesc::base_offset_in_bytes(T_DOUBLE) >> 3);
1106 __ access_store_at(T_DOUBLE, IN_HEAP | IS_ARRAY, Address(r3, r1, Address::uxtw(3)), noreg /* dtos */, noreg, noreg, noreg);
1107 }
1108
1109 void TemplateTable::aastore() {
1110 Label is_null, ok_is_subtype, done;
1111 transition(vtos, vtos);
1112 // stack: ..., array, index, value
1113 __ ldr(r0, at_tos()); // value
1114 __ ldr(r2, at_tos_p1()); // index
1115 __ ldr(r3, at_tos_p2()); // array
1116
1117 Address element_address(r3, r4, Address::uxtw(LogBytesPerHeapOop));
1118
1119 index_check(r3, r2); // kills r1
1120 __ add(r4, r2, arrayOopDesc::base_offset_in_bytes(T_OBJECT) >> LogBytesPerHeapOop);
1121
1122 // do array store check - check for null value first
1123 __ cbz(r0, is_null);
1124
1125 // Move subklass into r1
1126 __ load_klass(r1, r0);
1127 // Move superklass into r0
1128 __ load_klass(r0, r3);
1129 __ ldr(r0, Address(r0,
1130 ObjArrayKlass::element_klass_offset()));
1131 // Compress array + index*oopSize + 12 into a single register. Frees r2.
1132
1133 // Generate subtype check. Blows r2, r5
1134 // Superklass in r0. Subklass in r1.
1135 __ gen_subtype_check(r1, ok_is_subtype);
1136
1137 // Come here on failure
1138 // object is at TOS
1139 __ b(Interpreter::_throw_ArrayStoreException_entry);
1140
1141 // Come here on success
1142 __ bind(ok_is_subtype);
1143
1144 // Get the value we will store
1145 __ ldr(r0, at_tos());
1146 // Now store using the appropriate barrier
1147 do_oop_store(_masm, element_address, r0, IS_ARRAY);
1148 __ b(done);
1149
1150 // Have a null in r0, r3=array, r2=index. Store null at ary[idx]
1151 __ bind(is_null);
1152 __ profile_null_seen(r2);
1153
1154 // Store a null
1155 do_oop_store(_masm, element_address, noreg, IS_ARRAY);
1156
1157 // Pop stack arguments
1158 __ bind(done);
1159 __ add(esp, esp, 3 * Interpreter::stackElementSize);
1160 }
1161
1162 void TemplateTable::bastore()
1163 {
1164 transition(itos, vtos);
1165 __ pop_i(r1);
1166 __ pop_ptr(r3);
1167 // r0: value
1168 // r1: index
1169 // r3: array
1170 index_check(r3, r1); // prefer index in r1
1171
1172 // Need to check whether array is boolean or byte
1173 // since both types share the bastore bytecode.
1174 __ load_klass(r2, r3);
1175 __ ldrw(r2, Address(r2, Klass::layout_helper_offset()));
1940 __ br(j_not(cc), not_taken);
1941 branch(false, false);
1942 __ bind(not_taken);
1943 __ profile_not_taken_branch(r0);
1944 }
1945
1946 void TemplateTable::if_nullcmp(Condition cc)
1947 {
1948 transition(atos, vtos);
1949 // assume branch is more often taken than not (loops use backward branches)
1950 Label not_taken;
1951 if (cc == equal)
1952 __ cbnz(r0, not_taken);
1953 else
1954 __ cbz(r0, not_taken);
1955 branch(false, false);
1956 __ bind(not_taken);
1957 __ profile_not_taken_branch(r0);
1958 }
1959
1960 void TemplateTable::if_acmp(Condition cc)
1961 {
1962 transition(atos, vtos);
1963 // assume branch is more often taken than not (loops use backward branches)
1964 Label not_taken;
1965 __ pop_ptr(r1);
1966 __ cmpoop(r1, r0);
1967 __ br(j_not(cc), not_taken);
1968 branch(false, false);
1969 __ bind(not_taken);
1970 __ profile_not_taken_branch(r0);
1971 }
1972
1973 void TemplateTable::ret() {
1974 transition(vtos, vtos);
1975 locals_index(r1);
1976 __ ldr(r1, aaddress(r1)); // get return bci, compute return bcp
1977 __ profile_ret(r1, r2);
1978 __ ldr(rbcp, Address(rmethod, Method::const_offset()));
1979 __ lea(rbcp, Address(rbcp, r1));
1980 __ add(rbcp, rbcp, in_bytes(ConstMethod::codes_offset()));
1981 __ dispatch_next(vtos, 0, /*generate_poll*/true);
1982 }
1983
1984 void TemplateTable::wide_ret() {
1985 transition(vtos, vtos);
1986 locals_index_wide(r1);
1987 __ ldr(r1, aaddress(r1)); // get return bci, compute return bcp
1988 __ profile_ret(r1, r2);
1989 __ ldr(rbcp, Address(rmethod, Method::const_offset()));
1990 __ lea(rbcp, Address(rbcp, r1));
1991 __ add(rbcp, rbcp, in_bytes(ConstMethod::codes_offset()));
1992 __ dispatch_next(vtos, 0, /*generate_poll*/true);
2562 }
2563 // c_rarg1: object pointer or null
2564 // c_rarg2: cache entry pointer
2565 __ call_VM(noreg, CAST_FROM_FN_PTR(address,
2566 InterpreterRuntime::post_field_access),
2567 c_rarg1, c_rarg2);
2568 __ load_field_entry(cache, index);
2569 __ bind(L1);
2570 }
2571 }
2572
2573 void TemplateTable::pop_and_check_object(Register r)
2574 {
2575 __ pop_ptr(r);
2576 __ null_check(r); // for field access must check obj.
2577 __ verify_oop(r);
2578 }
2579
2580 void TemplateTable::getfield_or_static(int byte_no, bool is_static, RewriteControl rc)
2581 {
2582 const Register cache = r4;
2583 const Register obj = r4;
2584 const Register index = r3;
2585 const Register tos_state = r3;
2586 const Register off = r19;
2587 const Register flags = r6;
2588 const Register bc = r4; // uses same reg as obj, so don't mix them
2589
2590 resolve_cache_and_index_for_field(byte_no, cache, index);
2591 jvmti_post_field_access(cache, index, is_static, false);
2592 load_resolved_field_entry(obj, cache, tos_state, off, flags, is_static);
2593
2594 if (!is_static) {
2595 // obj is on the stack
2596 pop_and_check_object(obj);
2597 }
2598
2599 // 8179954: We need to make sure that the code generated for
2600 // volatile accesses forms a sequentially-consistent set of
2601 // operations when combined with STLR and LDAR. Without a leading
2602 // membar it's possible for a simple Dekker test to fail if loads
2603 // use LDR;DMB but stores use STLR. This can happen if C2 compiles
2604 // the stores in one method and we interpret the loads in another.
2605 if (!CompilerConfig::is_c1_or_interpreter_only_no_jvmci()){
2606 Label notVolatile;
2607 __ tbz(flags, ResolvedFieldEntry::is_volatile_shift, notVolatile);
2608 __ membar(MacroAssembler::AnyAny);
2609 __ bind(notVolatile);
2610 }
2611
2630 __ b(Done);
2631
2632 __ bind(notByte);
2633 __ cmp(tos_state, (u1)ztos);
2634 __ br(Assembler::NE, notBool);
2635
2636 // ztos (same code as btos)
2637 __ access_load_at(T_BOOLEAN, IN_HEAP, r0, field, noreg, noreg);
2638 __ push(ztos);
2639 // Rewrite bytecode to be faster
2640 if (rc == may_rewrite) {
2641 // use btos rewriting, no truncating to t/f bit is needed for getfield.
2642 patch_bytecode(Bytecodes::_fast_bgetfield, bc, r1);
2643 }
2644 __ b(Done);
2645
2646 __ bind(notBool);
2647 __ cmp(tos_state, (u1)atos);
2648 __ br(Assembler::NE, notObj);
2649 // atos
2650 do_oop_load(_masm, field, r0, IN_HEAP);
2651 __ push(atos);
2652 if (rc == may_rewrite) {
2653 patch_bytecode(Bytecodes::_fast_agetfield, bc, r1);
2654 }
2655 __ b(Done);
2656
2657 __ bind(notObj);
2658 __ cmp(tos_state, (u1)itos);
2659 __ br(Assembler::NE, notInt);
2660 // itos
2661 __ access_load_at(T_INT, IN_HEAP, r0, field, noreg, noreg);
2662 __ push(itos);
2663 // Rewrite bytecode to be faster
2664 if (rc == may_rewrite) {
2665 patch_bytecode(Bytecodes::_fast_igetfield, bc, r1);
2666 }
2667 __ b(Done);
2668
2669 __ bind(notInt);
2670 __ cmp(tos_state, (u1)ctos);
2671 __ br(Assembler::NE, notChar);
2672 // ctos
2673 __ access_load_at(T_CHAR, IN_HEAP, r0, field, noreg, noreg);
2674 __ push(ctos);
2675 // Rewrite bytecode to be faster
2796 // c_rarg1: object pointer set up above (null if static)
2797 // c_rarg2: cache entry pointer
2798 // c_rarg3: jvalue object on the stack
2799 __ call_VM(noreg,
2800 CAST_FROM_FN_PTR(address,
2801 InterpreterRuntime::post_field_modification),
2802 c_rarg1, c_rarg2, c_rarg3);
2803 __ load_field_entry(cache, index);
2804 __ bind(L1);
2805 }
2806 }
2807
2808 void TemplateTable::putfield_or_static(int byte_no, bool is_static, RewriteControl rc) {
2809 transition(vtos, vtos);
2810
2811 const Register cache = r2;
2812 const Register index = r3;
2813 const Register tos_state = r3;
2814 const Register obj = r2;
2815 const Register off = r19;
2816 const Register flags = r0;
2817 const Register bc = r4;
2818
2819 resolve_cache_and_index_for_field(byte_no, cache, index);
2820 jvmti_post_field_mod(cache, index, is_static);
2821 load_resolved_field_entry(obj, cache, tos_state, off, flags, is_static);
2822
2823 Label Done;
2824 __ mov(r5, flags);
2825
2826 {
2827 Label notVolatile;
2828 __ tbz(r5, ResolvedFieldEntry::is_volatile_shift, notVolatile);
2829 __ membar(MacroAssembler::StoreStore | MacroAssembler::LoadStore);
2830 __ bind(notVolatile);
2831 }
2832
2833 // field address
2834 const Address field(obj, off);
2835
2836 Label notByte, notBool, notInt, notShort, notChar,
2837 notLong, notFloat, notObj, notDouble;
2838
2839 assert(btos == 0, "change code, btos != 0");
2840 __ cbnz(tos_state, notByte);
2841
2842 // Don't rewrite putstatic, only putfield
2843 if (is_static) rc = may_not_rewrite;
2844
2845 // btos
2846 {
2847 __ pop(btos);
2848 if (!is_static) pop_and_check_object(obj);
2857 __ cmp(tos_state, (u1)ztos);
2858 __ br(Assembler::NE, notBool);
2859
2860 // ztos
2861 {
2862 __ pop(ztos);
2863 if (!is_static) pop_and_check_object(obj);
2864 __ access_store_at(T_BOOLEAN, IN_HEAP, field, r0, noreg, noreg, noreg);
2865 if (rc == may_rewrite) {
2866 patch_bytecode(Bytecodes::_fast_zputfield, bc, r1, true, byte_no);
2867 }
2868 __ b(Done);
2869 }
2870
2871 __ bind(notBool);
2872 __ cmp(tos_state, (u1)atos);
2873 __ br(Assembler::NE, notObj);
2874
2875 // atos
2876 {
2877 __ pop(atos);
2878 if (!is_static) pop_and_check_object(obj);
2879 // Store into the field
2880 do_oop_store(_masm, field, r0, IN_HEAP);
2881 if (rc == may_rewrite) {
2882 patch_bytecode(Bytecodes::_fast_aputfield, bc, r1, true, byte_no);
2883 }
2884 __ b(Done);
2885 }
2886
2887 __ bind(notObj);
2888 __ cmp(tos_state, (u1)itos);
2889 __ br(Assembler::NE, notInt);
2890
2891 // itos
2892 {
2893 __ pop(itos);
2894 if (!is_static) pop_and_check_object(obj);
2895 __ access_store_at(T_INT, IN_HEAP, field, r0, noreg, noreg, noreg);
2896 if (rc == may_rewrite) {
2897 patch_bytecode(Bytecodes::_fast_iputfield, bc, r1, true, byte_no);
2898 }
2899 __ b(Done);
2900 }
2901
2902 __ bind(notInt);
2903 __ cmp(tos_state, (u1)ctos);
2904 __ br(Assembler::NE, notChar);
2969 {
2970 __ pop(dtos);
2971 if (!is_static) pop_and_check_object(obj);
2972 __ access_store_at(T_DOUBLE, IN_HEAP, field, noreg /* dtos */, noreg, noreg, noreg);
2973 if (rc == may_rewrite) {
2974 patch_bytecode(Bytecodes::_fast_dputfield, bc, r1, true, byte_no);
2975 }
2976 }
2977
2978 #ifdef ASSERT
2979 __ b(Done);
2980
2981 __ bind(notDouble);
2982 __ stop("Bad state");
2983 #endif
2984
2985 __ bind(Done);
2986
2987 {
2988 Label notVolatile;
2989 __ tbz(r5, ResolvedFieldEntry::is_volatile_shift, notVolatile);
2990 __ membar(MacroAssembler::StoreLoad | MacroAssembler::StoreStore);
2991 __ bind(notVolatile);
2992 }
2993 }
2994
2995 void TemplateTable::putfield(int byte_no)
2996 {
2997 putfield_or_static(byte_no, false);
2998 }
2999
3000 void TemplateTable::nofast_putfield(int byte_no) {
3001 putfield_or_static(byte_no, false, may_not_rewrite);
3002 }
3003
3004 void TemplateTable::putstatic(int byte_no) {
3005 putfield_or_static(byte_no, true);
3006 }
3007
3008 void TemplateTable::jvmti_post_fast_field_mod() {
3009 if (JvmtiExport::can_post_field_modification()) {
3010 // Check to see if a field modification watch has been set before
3011 // we take the time to call into the VM.
3012 Label L2;
3013 __ lea(rscratch1, ExternalAddress((address)JvmtiExport::get_field_modification_count_addr()));
3014 __ ldrw(c_rarg3, Address(rscratch1));
3015 __ cbzw(c_rarg3, L2);
3016 __ pop_ptr(r19); // copy the object pointer from tos
3017 __ verify_oop(r19);
3018 __ push_ptr(r19); // put the object pointer back on tos
3019 // Save tos values before call_VM() clobbers them. Since we have
3020 // to do it for every data type, we use the saved values as the
3021 // jvalue object.
3022 switch (bytecode()) { // load values into the jvalue object
3023 case Bytecodes::_fast_aputfield: __ push_ptr(r0); break;
3024 case Bytecodes::_fast_bputfield: // fall through
3025 case Bytecodes::_fast_zputfield: // fall through
3026 case Bytecodes::_fast_sputfield: // fall through
3027 case Bytecodes::_fast_cputfield: // fall through
3028 case Bytecodes::_fast_iputfield: __ push_i(r0); break;
3029 case Bytecodes::_fast_dputfield: __ push_d(); break;
3030 case Bytecodes::_fast_fputfield: __ push_f(); break;
3031 case Bytecodes::_fast_lputfield: __ push_l(r0); break;
3032
3033 default:
3034 ShouldNotReachHere();
3035 }
3036 __ mov(c_rarg3, esp); // points to jvalue on the stack
3037 // access constant pool cache entry
3038 __ load_field_entry(c_rarg2, r0);
3039 __ verify_oop(r19);
3040 // r19: object pointer copied above
3041 // c_rarg2: cache entry pointer
3042 // c_rarg3: jvalue object on the stack
3043 __ call_VM(noreg,
3044 CAST_FROM_FN_PTR(address,
3045 InterpreterRuntime::post_field_modification),
3046 r19, c_rarg2, c_rarg3);
3047
3048 switch (bytecode()) { // restore tos values
3049 case Bytecodes::_fast_aputfield: __ pop_ptr(r0); break;
3050 case Bytecodes::_fast_bputfield: // fall through
3051 case Bytecodes::_fast_zputfield: // fall through
3052 case Bytecodes::_fast_sputfield: // fall through
3053 case Bytecodes::_fast_cputfield: // fall through
3054 case Bytecodes::_fast_iputfield: __ pop_i(r0); break;
3055 case Bytecodes::_fast_dputfield: __ pop_d(); break;
3056 case Bytecodes::_fast_fputfield: __ pop_f(); break;
3057 case Bytecodes::_fast_lputfield: __ pop_l(r0); break;
3058 default: break;
3059 }
3060 __ bind(L2);
3061 }
3062 }
3063
3064 void TemplateTable::fast_storefield(TosState state)
3065 {
3066 transition(state, vtos);
3067
3068 ByteSize base = ConstantPoolCache::base_offset();
3075 // R1: field offset, R2: field holder, R3: flags
3076 load_resolved_field_entry(r2, r2, noreg, r1, r3);
3077
3078 {
3079 Label notVolatile;
3080 __ tbz(r3, ResolvedFieldEntry::is_volatile_shift, notVolatile);
3081 __ membar(MacroAssembler::StoreStore | MacroAssembler::LoadStore);
3082 __ bind(notVolatile);
3083 }
3084
3085 Label notVolatile;
3086
3087 // Get object from stack
3088 pop_and_check_object(r2);
3089
3090 // field address
3091 const Address field(r2, r1);
3092
3093 // access field
3094 switch (bytecode()) {
3095 case Bytecodes::_fast_aputfield:
3096 do_oop_store(_masm, field, r0, IN_HEAP);
3097 break;
3098 case Bytecodes::_fast_lputfield:
3099 __ access_store_at(T_LONG, IN_HEAP, field, r0, noreg, noreg, noreg);
3100 break;
3101 case Bytecodes::_fast_iputfield:
3102 __ access_store_at(T_INT, IN_HEAP, field, r0, noreg, noreg, noreg);
3103 break;
3104 case Bytecodes::_fast_zputfield:
3105 __ access_store_at(T_BOOLEAN, IN_HEAP, field, r0, noreg, noreg, noreg);
3106 break;
3107 case Bytecodes::_fast_bputfield:
3108 __ access_store_at(T_BYTE, IN_HEAP, field, r0, noreg, noreg, noreg);
3109 break;
3110 case Bytecodes::_fast_sputfield:
3111 __ access_store_at(T_SHORT, IN_HEAP, field, r0, noreg, noreg, noreg);
3112 break;
3113 case Bytecodes::_fast_cputfield:
3114 __ access_store_at(T_CHAR, IN_HEAP, field, r0, noreg, noreg, noreg);
3167 // r0: object
3168 __ verify_oop(r0);
3169 __ null_check(r0);
3170 const Address field(r0, r1);
3171
3172 // 8179954: We need to make sure that the code generated for
3173 // volatile accesses forms a sequentially-consistent set of
3174 // operations when combined with STLR and LDAR. Without a leading
3175 // membar it's possible for a simple Dekker test to fail if loads
3176 // use LDR;DMB but stores use STLR. This can happen if C2 compiles
3177 // the stores in one method and we interpret the loads in another.
3178 if (!CompilerConfig::is_c1_or_interpreter_only_no_jvmci()) {
3179 Label notVolatile;
3180 __ tbz(r3, ResolvedFieldEntry::is_volatile_shift, notVolatile);
3181 __ membar(MacroAssembler::AnyAny);
3182 __ bind(notVolatile);
3183 }
3184
3185 // access field
3186 switch (bytecode()) {
3187 case Bytecodes::_fast_agetfield:
3188 do_oop_load(_masm, field, r0, IN_HEAP);
3189 __ verify_oop(r0);
3190 break;
3191 case Bytecodes::_fast_lgetfield:
3192 __ access_load_at(T_LONG, IN_HEAP, r0, field, noreg, noreg);
3193 break;
3194 case Bytecodes::_fast_igetfield:
3195 __ access_load_at(T_INT, IN_HEAP, r0, field, noreg, noreg);
3196 break;
3197 case Bytecodes::_fast_bgetfield:
3198 __ access_load_at(T_BYTE, IN_HEAP, r0, field, noreg, noreg);
3199 break;
3200 case Bytecodes::_fast_sgetfield:
3201 __ access_load_at(T_SHORT, IN_HEAP, r0, field, noreg, noreg);
3202 break;
3203 case Bytecodes::_fast_cgetfield:
3204 __ access_load_at(T_CHAR, IN_HEAP, r0, field, noreg, noreg);
3205 break;
3206 case Bytecodes::_fast_fgetfield:
3585 Label initialize_header;
3586
3587 __ get_cpool_and_tags(r4, r0);
3588 // Make sure the class we're about to instantiate has been resolved.
3589 // This is done before loading InstanceKlass to be consistent with the order
3590 // how Constant Pool is updated (see ConstantPool::klass_at_put)
3591 const int tags_offset = Array<u1>::base_offset_in_bytes();
3592 __ lea(rscratch1, Address(r0, r3, Address::lsl(0)));
3593 __ lea(rscratch1, Address(rscratch1, tags_offset));
3594 __ ldarb(rscratch1, rscratch1);
3595 __ cmp(rscratch1, (u1)JVM_CONSTANT_Class);
3596 __ br(Assembler::NE, slow_case);
3597
3598 // get InstanceKlass
3599 __ load_resolved_klass_at_offset(r4, r3, r4, rscratch1);
3600
3601 // make sure klass is initialized
3602 assert(VM_Version::supports_fast_class_init_checks(), "Optimization requires support for fast class initialization checks");
3603 __ clinit_barrier(r4, rscratch1, nullptr /*L_fast_path*/, &slow_case);
3604
3605 // get instance_size in InstanceKlass (scaled to a count of bytes)
3606 __ ldrw(r3,
3607 Address(r4,
3608 Klass::layout_helper_offset()));
3609 // test to see if it is malformed in some way
3610 __ tbnz(r3, exact_log2(Klass::_lh_instance_slow_path_bit), slow_case);
3611
3612 // Allocate the instance:
3613 // If TLAB is enabled:
3614 // Try to allocate in the TLAB.
3615 // If fails, go to the slow path.
3616 // Initialize the allocation.
3617 // Exit.
3618 //
3619 // Go to slow path.
3620
3621 if (UseTLAB) {
3622 __ tlab_allocate(r0, r3, 0, noreg, r1, slow_case);
3623
3624 if (ZeroTLAB) {
3625 // the fields have been already cleared
3626 __ b(initialize_header);
3627 }
3628
3629 // The object is initialized before the header. If the object size is
3630 // zero, go directly to the header initialization.
3631 int header_size = oopDesc::header_size() * HeapWordSize;
3632 assert(is_aligned(header_size, BytesPerLong), "oop header size must be 8-byte-aligned");
3633 __ sub(r3, r3, header_size);
3634 __ cbz(r3, initialize_header);
3635
3636 // Initialize object fields
3637 {
3638 __ add(r2, r0, header_size);
3639 Label loop;
3640 __ bind(loop);
3641 __ str(zr, Address(__ post(r2, BytesPerLong)));
3642 __ sub(r3, r3, BytesPerLong);
3643 __ cbnz(r3, loop);
3644 }
3645
3646 // initialize object header only.
3647 __ bind(initialize_header);
3648 if (UseCompactObjectHeaders) {
3649 __ ldr(rscratch1, Address(r4, Klass::prototype_header_offset()));
3650 __ str(rscratch1, Address(r0, oopDesc::mark_offset_in_bytes()));
3651 } else {
3652 __ mov(rscratch1, (intptr_t)markWord::prototype().value());
3653 __ str(rscratch1, Address(r0, oopDesc::mark_offset_in_bytes()));
3654 __ store_klass_gap(r0, zr); // zero klass gap for compressed oops
3655 __ store_klass(r0, r4); // store klass last
3656 }
3657
3658 if (DTraceAllocProbes) {
3659 // Trigger dtrace event for fastpath
3660 __ push(atos); // save the return value
3661 __ call_VM_leaf(
3662 CAST_FROM_FN_PTR(address, static_cast<int (*)(oopDesc*)>(SharedRuntime::dtrace_object_alloc)), r0);
3663 __ pop(atos); // restore the return value
3664
3665 }
3666 __ b(done);
3667 }
3668
3669 // slow case
3670 __ bind(slow_case);
3671 __ get_constant_pool(c_rarg1);
3672 __ get_unsigned_2_byte_index_at_bcp(c_rarg2, 1);
3673 call_VM(r0, CAST_FROM_FN_PTR(address, InterpreterRuntime::_new), c_rarg1, c_rarg2);
3674 __ verify_oop(r0);
3675
3676 // continue
3677 __ bind(done);
3678 // Must prevent reordering of stores for object initialization with stores that publish the new object.
3679 __ membar(Assembler::StoreStore);
3680 }
3681
3682 void TemplateTable::newarray() {
3683 transition(itos, atos);
3684 __ load_unsigned_byte(c_rarg1, at_bcp(1));
3685 __ mov(c_rarg2, r0);
3686 call_VM(r0, CAST_FROM_FN_PTR(address, InterpreterRuntime::newarray),
3687 c_rarg1, c_rarg2);
3732 __ bind(quicked);
3733 __ mov(r3, r0); // Save object in r3; r0 needed for subtype check
3734 __ load_resolved_klass_at_offset(r2, r19, r0, rscratch1); // r0 = klass
3735
3736 __ bind(resolved);
3737 __ load_klass(r19, r3);
3738
3739 // Generate subtype check. Blows r2, r5. Object in r3.
3740 // Superklass in r0. Subklass in r19.
3741 __ gen_subtype_check(r19, ok_is_subtype);
3742
3743 // Come here on failure
3744 __ push(r3);
3745 // object is at TOS
3746 __ b(Interpreter::_throw_ClassCastException_entry);
3747
3748 // Come here on success
3749 __ bind(ok_is_subtype);
3750 __ mov(r0, r3); // Restore object in r3
3751
3752 // Collect counts on whether this test sees nulls a lot or not.
3753 if (ProfileInterpreter) {
3754 __ b(done);
3755 __ bind(is_null);
3756 __ profile_null_seen(r2);
3757 } else {
3758 __ bind(is_null); // same as 'done'
3759 }
3760 __ bind(done);
3761 }
3762
3763 void TemplateTable::instanceof() {
3764 transition(atos, itos);
3765 Label done, is_null, ok_is_subtype, quicked, resolved;
3766 __ cbz(r0, is_null);
3767
3768 // Get cpool & tags index
3769 __ get_cpool_and_tags(r2, r3); // r2=cpool, r3=tags array
3770 __ get_unsigned_2_byte_index_at_bcp(r19, 1); // r19=index
3771 // See if bytecode has already been quicked
3772 __ add(rscratch1, r3, Array<u1>::base_offset_in_bytes());
3773 __ lea(r1, Address(rscratch1, r19));
3774 __ ldarb(r1, r1);
3775 __ cmp(r1, (u1)JVM_CONSTANT_Class);
3776 __ br(Assembler::EQ, quicked);
3777
3778 __ push(atos); // save receiver for result, and for GC
3779 call_VM(r0, CAST_FROM_FN_PTR(address, InterpreterRuntime::quicken_io_cc));
3858 // in the assembly code structure as well
3859 //
3860 // Stack layout:
3861 //
3862 // [expressions ] <--- esp = expression stack top
3863 // ..
3864 // [expressions ]
3865 // [monitor entry] <--- monitor block top = expression stack bot
3866 // ..
3867 // [monitor entry]
3868 // [frame data ] <--- monitor block bot
3869 // ...
3870 // [saved rfp ] <--- rfp
3871 void TemplateTable::monitorenter()
3872 {
3873 transition(atos, vtos);
3874
3875 // check for null object
3876 __ null_check(r0);
3877
3878 const Address monitor_block_top(
3879 rfp, frame::interpreter_frame_monitor_block_top_offset * wordSize);
3880 const Address monitor_block_bot(
3881 rfp, frame::interpreter_frame_initial_sp_offset * wordSize);
3882 const int entry_size = frame::interpreter_frame_monitor_size_in_bytes();
3883
3884 Label allocated;
3885
3886 // initialize entry pointer
3887 __ mov(c_rarg1, zr); // points to free slot or null
3888
3889 // find a free slot in the monitor block (result in c_rarg1)
3890 {
3891 Label entry, loop, exit;
3892 __ ldr(c_rarg3, monitor_block_top); // derelativize pointer
3893 __ lea(c_rarg3, Address(rfp, c_rarg3, Address::lsl(Interpreter::logStackElementSize)));
3894 // c_rarg3 points to current entry, starting with top-most entry
3895
3896 __ lea(c_rarg2, monitor_block_bot); // points to word before bottom
3897
3959 // c_rarg1: points to monitor entry
3960 __ bind(allocated);
3961
3962 // Increment bcp to point to the next bytecode, so exception
3963 // handling for async. exceptions work correctly.
3964 // The object has already been popped from the stack, so the
3965 // expression stack looks correct.
3966 __ increment(rbcp);
3967
3968 // store object
3969 __ str(r0, Address(c_rarg1, BasicObjectLock::obj_offset()));
3970 __ lock_object(c_rarg1);
3971
3972 // check to make sure this monitor doesn't cause stack overflow after locking
3973 __ save_bcp(); // in case of exception
3974 __ generate_stack_overflow_check(0);
3975
3976 // The bcp has already been incremented. Just need to dispatch to
3977 // next instruction.
3978 __ dispatch_next(vtos);
3979 }
3980
3981
3982 void TemplateTable::monitorexit()
3983 {
3984 transition(atos, vtos);
3985
3986 // check for null object
3987 __ null_check(r0);
3988
3989 const Address monitor_block_top(
3990 rfp, frame::interpreter_frame_monitor_block_top_offset * wordSize);
3991 const Address monitor_block_bot(
3992 rfp, frame::interpreter_frame_initial_sp_offset * wordSize);
3993 const int entry_size = frame::interpreter_frame_monitor_size_in_bytes();
3994
3995 Label found;
3996
3997 // find matching slot
3998 {
3999 Label entry, loop;
4000 __ ldr(c_rarg1, monitor_block_top); // derelativize pointer
4001 __ lea(c_rarg1, Address(rfp, c_rarg1, Address::lsl(Interpreter::logStackElementSize)));
4002 // c_rarg1 points to current entry, starting with top-most entry
4003
4004 __ lea(c_rarg2, monitor_block_bot); // points to word before bottom
4005 // of monitor block
4006 __ b(entry);
4007
4008 __ bind(loop);
|
155 static void do_oop_load(InterpreterMacroAssembler* _masm,
156 Address src,
157 Register dst,
158 DecoratorSet decorators) {
159 __ load_heap_oop(dst, src, r10, r11, decorators);
160 }
161
162 Address TemplateTable::at_bcp(int offset) {
163 assert(_desc->uses_bcp(), "inconsistent uses_bcp information");
164 return Address(rbcp, offset);
165 }
166
167 void TemplateTable::patch_bytecode(Bytecodes::Code bc, Register bc_reg,
168 Register temp_reg, bool load_bc_into_bc_reg/*=true*/,
169 int byte_no)
170 {
171 if (!RewriteBytecodes) return;
172 Label L_patch_done;
173
174 switch (bc) {
175 case Bytecodes::_fast_vputfield:
176 case Bytecodes::_fast_aputfield:
177 case Bytecodes::_fast_bputfield:
178 case Bytecodes::_fast_zputfield:
179 case Bytecodes::_fast_cputfield:
180 case Bytecodes::_fast_dputfield:
181 case Bytecodes::_fast_fputfield:
182 case Bytecodes::_fast_iputfield:
183 case Bytecodes::_fast_lputfield:
184 case Bytecodes::_fast_sputfield:
185 {
186 // We skip bytecode quickening for putfield instructions when
187 // the put_code written to the constant pool cache is zero.
188 // This is required so that every execution of this instruction
189 // calls out to InterpreterRuntime::resolve_get_put to do
190 // additional, required work.
191 assert(byte_no == f1_byte || byte_no == f2_byte, "byte_no out of range");
192 assert(load_bc_into_bc_reg, "we use bc_reg as temp");
193 __ load_field_entry(temp_reg, bc_reg);
194 if (byte_no == f1_byte) {
195 __ lea(temp_reg, Address(temp_reg, in_bytes(ResolvedFieldEntry::get_code_offset())));
737 locals_index_wide(r1);
738 __ ldr(r0, aaddress(r1));
739 }
740
741 void TemplateTable::index_check(Register array, Register index)
742 {
743 // destroys r1, rscratch1
744 // sign extend index for use by indexed load
745 // __ movl2ptr(index, index);
746 // check index
747 Register length = rscratch1;
748 __ ldrw(length, Address(array, arrayOopDesc::length_offset_in_bytes()));
749 __ cmpw(index, length);
750 if (index != r1) {
751 // ??? convention: move aberrant index into r1 for exception message
752 assert(r1 != array, "different registers");
753 __ mov(r1, index);
754 }
755 Label ok;
756 __ br(Assembler::LO, ok);
757 // ??? convention: move array into r3 for exception message
758 __ mov(r3, array);
759 __ mov(rscratch1, Interpreter::_throw_ArrayIndexOutOfBoundsException_entry);
760 __ br(rscratch1);
761 __ bind(ok);
762 }
763
764 void TemplateTable::iaload()
765 {
766 transition(itos, itos);
767 __ mov(r1, r0);
768 __ pop_ptr(r0);
769 // r0: array
770 // r1: index
771 index_check(r0, r1); // leaves index in r1, kills rscratch1
772 __ add(r1, r1, arrayOopDesc::base_offset_in_bytes(T_INT) >> 2);
773 __ access_load_at(T_INT, IN_HEAP | IS_ARRAY, r0, Address(r0, r1, Address::uxtw(2)), noreg, noreg);
774 }
775
776 void TemplateTable::laload()
777 {
778 transition(itos, ltos);
779 __ mov(r1, r0);
780 __ pop_ptr(r0);
800 void TemplateTable::daload()
801 {
802 transition(itos, dtos);
803 __ mov(r1, r0);
804 __ pop_ptr(r0);
805 // r0: array
806 // r1: index
807 index_check(r0, r1); // leaves index in r1, kills rscratch1
808 __ add(r1, r1, arrayOopDesc::base_offset_in_bytes(T_DOUBLE) >> 3);
809 __ access_load_at(T_DOUBLE, IN_HEAP | IS_ARRAY, r0, Address(r0, r1, Address::uxtw(3)), noreg, noreg);
810 }
811
812 void TemplateTable::aaload()
813 {
814 transition(itos, atos);
815 __ mov(r1, r0);
816 __ pop_ptr(r0);
817 // r0: array
818 // r1: index
819 index_check(r0, r1); // leaves index in r1, kills rscratch1
820 __ profile_array_type<ArrayLoadData>(r2, r0, r4);
821 if (UseArrayFlattening) {
822 Label is_flat_array, done;
823
824 __ test_flat_array_oop(r0, r8 /*temp*/, is_flat_array);
825 __ add(r1, r1, arrayOopDesc::base_offset_in_bytes(T_OBJECT) >> LogBytesPerHeapOop);
826 do_oop_load(_masm, Address(r0, r1, Address::uxtw(LogBytesPerHeapOop)), r0, IS_ARRAY);
827
828 __ b(done);
829 __ bind(is_flat_array);
830 __ call_VM(r0, CAST_FROM_FN_PTR(address, InterpreterRuntime::flat_array_load), r0, r1);
831 // Ensure the stores to copy the inline field contents are visible
832 // before any subsequent store that publishes this reference.
833 __ membar(Assembler::StoreStore);
834 __ bind(done);
835 } else {
836 __ add(r1, r1, arrayOopDesc::base_offset_in_bytes(T_OBJECT) >> LogBytesPerHeapOop);
837 do_oop_load(_masm, Address(r0, r1, Address::uxtw(LogBytesPerHeapOop)), r0, IS_ARRAY);
838 }
839 __ profile_element_type(r2, r0, r4);
840 }
841
842 void TemplateTable::baload()
843 {
844 transition(itos, itos);
845 __ mov(r1, r0);
846 __ pop_ptr(r0);
847 // r0: array
848 // r1: index
849 index_check(r0, r1); // leaves index in r1, kills rscratch1
850 __ add(r1, r1, arrayOopDesc::base_offset_in_bytes(T_BYTE) >> 0);
851 __ access_load_at(T_BYTE, IN_HEAP | IS_ARRAY, r0, Address(r0, r1, Address::uxtw(0)), noreg, noreg);
852 }
853
854 void TemplateTable::caload()
855 {
856 transition(itos, itos);
857 __ mov(r1, r0);
858 __ pop_ptr(r0);
859 // r0: array
1106 // r1: index
1107 // r3: array
1108 index_check(r3, r1); // prefer index in r1
1109 __ add(r1, r1, arrayOopDesc::base_offset_in_bytes(T_FLOAT) >> 2);
1110 __ access_store_at(T_FLOAT, IN_HEAP | IS_ARRAY, Address(r3, r1, Address::uxtw(2)), noreg /* ftos */, noreg, noreg, noreg);
1111 }
1112
1113 void TemplateTable::dastore() {
1114 transition(dtos, vtos);
1115 __ pop_i(r1);
1116 __ pop_ptr(r3);
1117 // v0: value
1118 // r1: index
1119 // r3: array
1120 index_check(r3, r1); // prefer index in r1
1121 __ add(r1, r1, arrayOopDesc::base_offset_in_bytes(T_DOUBLE) >> 3);
1122 __ access_store_at(T_DOUBLE, IN_HEAP | IS_ARRAY, Address(r3, r1, Address::uxtw(3)), noreg /* dtos */, noreg, noreg, noreg);
1123 }
1124
1125 void TemplateTable::aastore() {
1126 Label is_null, is_flat_array, ok_is_subtype, done;
1127 transition(vtos, vtos);
1128 // stack: ..., array, index, value
1129 __ ldr(r0, at_tos()); // value
1130 __ ldr(r2, at_tos_p1()); // index
1131 __ ldr(r3, at_tos_p2()); // array
1132
1133 index_check(r3, r2); // kills r1
1134
1135 __ profile_array_type<ArrayStoreData>(r4, r3, r5);
1136 __ profile_multiple_element_types(r4, r0, r5, r6);
1137
1138 __ add(r4, r2, arrayOopDesc::base_offset_in_bytes(T_OBJECT) >> LogBytesPerHeapOop);
1139 Address element_address(r3, r4, Address::uxtw(LogBytesPerHeapOop));
1140 // Be careful not to clobber r4 below
1141
1142 // do array store check - check for null value first
1143 __ cbz(r0, is_null);
1144
1145 // Move array class to r5
1146 __ load_klass(r5, r3);
1147
1148 if (UseArrayFlattening) {
1149 __ ldrw(r6, Address(r5, Klass::layout_helper_offset()));
1150 __ test_flat_array_layout(r6, is_flat_array);
1151 }
1152
1153 // Move subklass into r1
1154 __ load_klass(r1, r0);
1155
1156 // Move array element superklass into r0
1157 __ ldr(r0, Address(r5, ObjArrayKlass::element_klass_offset()));
1158 // Compress array + index*oopSize + 12 into a single register. Frees r2.
1159
1160 // Generate subtype check. Blows r2, r5
1161 // Superklass in r0. Subklass in r1.
1162
1163 // is "r1 <: r0" ? (value subclass <: array element superclass)
1164 __ gen_subtype_check(r1, ok_is_subtype, false);
1165
1166 // Come here on failure
1167 // object is at TOS
1168 __ b(Interpreter::_throw_ArrayStoreException_entry);
1169
1170 // Come here on success
1171 __ bind(ok_is_subtype);
1172
1173 // Get the value we will store
1174 __ ldr(r0, at_tos());
1175 // Now store using the appropriate barrier
1176 do_oop_store(_masm, element_address, r0, IS_ARRAY);
1177 __ b(done);
1178
1179 // Have a null in r0, r3=array, r2=index. Store null at ary[idx]
1180 __ bind(is_null);
1181 if (EnableValhalla) {
1182 Label is_null_into_value_array_npe, store_null;
1183
1184 if (UseArrayFlattening) {
1185 __ test_flat_array_oop(r3, r8, is_flat_array);
1186 }
1187
1188 // No way to store null in a null-free array
1189 __ test_null_free_array_oop(r3, r8, is_null_into_value_array_npe);
1190 __ b(store_null);
1191
1192 __ bind(is_null_into_value_array_npe);
1193 __ b(ExternalAddress(Interpreter::_throw_NullPointerException_entry));
1194
1195 __ bind(store_null);
1196 }
1197
1198 // Store a null
1199 do_oop_store(_masm, element_address, noreg, IS_ARRAY);
1200 __ b(done);
1201
1202 if (UseArrayFlattening) {
1203 Label is_type_ok;
1204 __ bind(is_flat_array); // Store non-null value to flat
1205
1206 __ ldr(r0, at_tos()); // value
1207 __ ldr(r3, at_tos_p1()); // index
1208 __ ldr(r2, at_tos_p2()); // array
1209 __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::flat_array_store), r0, r2, r3);
1210 }
1211
1212 // Pop stack arguments
1213 __ bind(done);
1214 __ add(esp, esp, 3 * Interpreter::stackElementSize);
1215 }
1216
1217 void TemplateTable::bastore()
1218 {
1219 transition(itos, vtos);
1220 __ pop_i(r1);
1221 __ pop_ptr(r3);
1222 // r0: value
1223 // r1: index
1224 // r3: array
1225 index_check(r3, r1); // prefer index in r1
1226
1227 // Need to check whether array is boolean or byte
1228 // since both types share the bastore bytecode.
1229 __ load_klass(r2, r3);
1230 __ ldrw(r2, Address(r2, Klass::layout_helper_offset()));
1995 __ br(j_not(cc), not_taken);
1996 branch(false, false);
1997 __ bind(not_taken);
1998 __ profile_not_taken_branch(r0);
1999 }
2000
2001 void TemplateTable::if_nullcmp(Condition cc)
2002 {
2003 transition(atos, vtos);
2004 // assume branch is more often taken than not (loops use backward branches)
2005 Label not_taken;
2006 if (cc == equal)
2007 __ cbnz(r0, not_taken);
2008 else
2009 __ cbz(r0, not_taken);
2010 branch(false, false);
2011 __ bind(not_taken);
2012 __ profile_not_taken_branch(r0);
2013 }
2014
2015 void TemplateTable::if_acmp(Condition cc) {
2016 transition(atos, vtos);
2017 // assume branch is more often taken than not (loops use backward branches)
2018 Label taken, not_taken;
2019 __ pop_ptr(r1);
2020
2021 __ profile_acmp(r2, r1, r0, r4);
2022
2023 Register is_inline_type_mask = rscratch1;
2024 __ mov(is_inline_type_mask, markWord::inline_type_pattern);
2025
2026 if (EnableValhalla) {
2027 __ cmp(r1, r0);
2028 __ br(Assembler::EQ, (cc == equal) ? taken : not_taken);
2029
2030 // might be substitutable, test if either r0 or r1 is null
2031 __ andr(r2, r0, r1);
2032 __ cbz(r2, (cc == equal) ? not_taken : taken);
2033
2034 // and both are values ?
2035 __ ldr(r2, Address(r1, oopDesc::mark_offset_in_bytes()));
2036 __ andr(r2, r2, is_inline_type_mask);
2037 __ ldr(r4, Address(r0, oopDesc::mark_offset_in_bytes()));
2038 __ andr(r4, r4, is_inline_type_mask);
2039 __ andr(r2, r2, r4);
2040 __ cmp(r2, is_inline_type_mask);
2041 __ br(Assembler::NE, (cc == equal) ? not_taken : taken);
2042
2043 // same value klass ?
2044 __ load_metadata(r2, r1);
2045 __ load_metadata(r4, r0);
2046 __ cmp(r2, r4);
2047 __ br(Assembler::NE, (cc == equal) ? not_taken : taken);
2048
2049 // Know both are the same type, let's test for substitutability...
2050 if (cc == equal) {
2051 invoke_is_substitutable(r0, r1, taken, not_taken);
2052 } else {
2053 invoke_is_substitutable(r0, r1, not_taken, taken);
2054 }
2055 __ stop("Not reachable");
2056 }
2057
2058 __ cmpoop(r1, r0);
2059 __ br(j_not(cc), not_taken);
2060 __ bind(taken);
2061 branch(false, false);
2062 __ bind(not_taken);
2063 __ profile_not_taken_branch(r0, true);
2064 }
2065
2066 void TemplateTable::invoke_is_substitutable(Register aobj, Register bobj,
2067 Label& is_subst, Label& not_subst) {
2068
2069 __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::is_substitutable), aobj, bobj);
2070 // Restored... r0 answer, jmp to outcome...
2071 __ cbz(r0, not_subst);
2072 __ b(is_subst);
2073 }
2074
2075
2076 void TemplateTable::ret() {
2077 transition(vtos, vtos);
2078 locals_index(r1);
2079 __ ldr(r1, aaddress(r1)); // get return bci, compute return bcp
2080 __ profile_ret(r1, r2);
2081 __ ldr(rbcp, Address(rmethod, Method::const_offset()));
2082 __ lea(rbcp, Address(rbcp, r1));
2083 __ add(rbcp, rbcp, in_bytes(ConstMethod::codes_offset()));
2084 __ dispatch_next(vtos, 0, /*generate_poll*/true);
2085 }
2086
2087 void TemplateTable::wide_ret() {
2088 transition(vtos, vtos);
2089 locals_index_wide(r1);
2090 __ ldr(r1, aaddress(r1)); // get return bci, compute return bcp
2091 __ profile_ret(r1, r2);
2092 __ ldr(rbcp, Address(rmethod, Method::const_offset()));
2093 __ lea(rbcp, Address(rbcp, r1));
2094 __ add(rbcp, rbcp, in_bytes(ConstMethod::codes_offset()));
2095 __ dispatch_next(vtos, 0, /*generate_poll*/true);
2665 }
2666 // c_rarg1: object pointer or null
2667 // c_rarg2: cache entry pointer
2668 __ call_VM(noreg, CAST_FROM_FN_PTR(address,
2669 InterpreterRuntime::post_field_access),
2670 c_rarg1, c_rarg2);
2671 __ load_field_entry(cache, index);
2672 __ bind(L1);
2673 }
2674 }
2675
2676 void TemplateTable::pop_and_check_object(Register r)
2677 {
2678 __ pop_ptr(r);
2679 __ null_check(r); // for field access must check obj.
2680 __ verify_oop(r);
2681 }
2682
2683 void TemplateTable::getfield_or_static(int byte_no, bool is_static, RewriteControl rc)
2684 {
2685 const Register cache = r2;
2686 const Register obj = r4;
2687 const Register klass = r5;
2688 const Register inline_klass = r7;
2689 const Register field_index = r23;
2690 const Register index = r3;
2691 const Register tos_state = r3;
2692 const Register off = r19;
2693 const Register flags = r6;
2694 const Register bc = r4; // uses same reg as obj, so don't mix them
2695
2696 resolve_cache_and_index_for_field(byte_no, cache, index);
2697 jvmti_post_field_access(cache, index, is_static, false);
2698
2699 // Valhalla extras
2700 __ load_unsigned_short(field_index, Address(cache, in_bytes(ResolvedFieldEntry::field_index_offset())));
2701 __ ldr(klass, Address(cache, ResolvedFieldEntry::field_holder_offset()));
2702
2703 load_resolved_field_entry(obj, cache, tos_state, off, flags, is_static);
2704
2705 if (!is_static) {
2706 // obj is on the stack
2707 pop_and_check_object(obj);
2708 }
2709
2710 // 8179954: We need to make sure that the code generated for
2711 // volatile accesses forms a sequentially-consistent set of
2712 // operations when combined with STLR and LDAR. Without a leading
2713 // membar it's possible for a simple Dekker test to fail if loads
2714 // use LDR;DMB but stores use STLR. This can happen if C2 compiles
2715 // the stores in one method and we interpret the loads in another.
2716 if (!CompilerConfig::is_c1_or_interpreter_only_no_jvmci()){
2717 Label notVolatile;
2718 __ tbz(flags, ResolvedFieldEntry::is_volatile_shift, notVolatile);
2719 __ membar(MacroAssembler::AnyAny);
2720 __ bind(notVolatile);
2721 }
2722
2741 __ b(Done);
2742
2743 __ bind(notByte);
2744 __ cmp(tos_state, (u1)ztos);
2745 __ br(Assembler::NE, notBool);
2746
2747 // ztos (same code as btos)
2748 __ access_load_at(T_BOOLEAN, IN_HEAP, r0, field, noreg, noreg);
2749 __ push(ztos);
2750 // Rewrite bytecode to be faster
2751 if (rc == may_rewrite) {
2752 // use btos rewriting, no truncating to t/f bit is needed for getfield.
2753 patch_bytecode(Bytecodes::_fast_bgetfield, bc, r1);
2754 }
2755 __ b(Done);
2756
2757 __ bind(notBool);
2758 __ cmp(tos_state, (u1)atos);
2759 __ br(Assembler::NE, notObj);
2760 // atos
2761 if (!EnableValhalla) {
2762 do_oop_load(_masm, field, r0, IN_HEAP);
2763 __ push(atos);
2764 if (rc == may_rewrite) {
2765 patch_bytecode(Bytecodes::_fast_agetfield, bc, r1);
2766 }
2767 __ b(Done);
2768 } else { // Valhalla
2769 if (is_static) {
2770 __ load_heap_oop(r0, field, rscratch1, rscratch2);
2771 Label is_null_free_inline_type, uninitialized;
2772 // Issue below if the static field has not been initialized yet
2773 __ test_field_is_null_free_inline_type(flags, noreg /*temp*/, is_null_free_inline_type);
2774 // field is not a null free inline type
2775 __ push(atos);
2776 __ b(Done);
2777 // field is a null free inline type, must not return null even if uninitialized
2778 __ bind(is_null_free_inline_type);
2779 __ cbz(r0, uninitialized);
2780 __ push(atos);
2781 __ b(Done);
2782 __ bind(uninitialized);
2783 Label slow_case, finish;
2784 __ ldrb(rscratch1, Address(klass, InstanceKlass::init_state_offset()));
2785 __ cmp(rscratch1, (u1)InstanceKlass::fully_initialized);
2786 __ br(Assembler::NE, slow_case);
2787 __ get_default_value_oop(klass, off /* temp */, r0);
2788 __ b(finish);
2789 __ bind(slow_case);
2790 __ call_VM(r0, CAST_FROM_FN_PTR(address, InterpreterRuntime::uninitialized_static_inline_type_field), obj, cache);
2791 __ bind(finish);
2792 __ verify_oop(r0);
2793 __ push(atos);
2794 __ b(Done);
2795 } else {
2796 Label is_flat, nonnull, is_inline_type, has_null_marker, rewrite_inline;
2797 __ test_field_is_null_free_inline_type(flags, noreg /*temp*/, is_inline_type);
2798 __ test_field_has_null_marker(flags, noreg /*temp*/, has_null_marker);
2799 // Non-inline field case
2800 __ load_heap_oop(r0, field, rscratch1, rscratch2);
2801 __ push(atos);
2802 if (rc == may_rewrite) {
2803 patch_bytecode(Bytecodes::_fast_agetfield, bc, r1);
2804 }
2805 __ b(Done);
2806 __ bind(is_inline_type);
2807 __ test_field_is_flat(flags, noreg /* temp */, is_flat);
2808 // field is not flat
2809 __ load_heap_oop(r0, field, rscratch1, rscratch2);
2810 __ cbnz(r0, nonnull);
2811 __ get_inline_type_field_klass(klass, field_index, inline_klass);
2812 __ get_default_value_oop(inline_klass, klass /* temp */, r0);
2813 __ bind(nonnull);
2814 __ verify_oop(r0);
2815 __ push(atos);
2816 __ b(rewrite_inline);
2817 __ bind(is_flat);
2818 // field is flat
2819 __ mov(r0, obj);
2820 __ read_flat_field(cache, field_index, off, inline_klass /* temp */, r0);
2821 __ verify_oop(r0);
2822 __ push(atos);
2823 __ b(rewrite_inline);
2824 __ bind(has_null_marker);
2825 call_VM(r0, CAST_FROM_FN_PTR(address, InterpreterRuntime::read_nullable_flat_field), obj, cache);
2826 __ verify_oop(r0);
2827 __ push(atos);
2828 __ bind(rewrite_inline);
2829 if (rc == may_rewrite) {
2830 patch_bytecode(Bytecodes::_fast_vgetfield, bc, r1);
2831 }
2832 __ b(Done);
2833 }
2834 }
2835
2836 __ bind(notObj);
2837 __ cmp(tos_state, (u1)itos);
2838 __ br(Assembler::NE, notInt);
2839 // itos
2840 __ access_load_at(T_INT, IN_HEAP, r0, field, noreg, noreg);
2841 __ push(itos);
2842 // Rewrite bytecode to be faster
2843 if (rc == may_rewrite) {
2844 patch_bytecode(Bytecodes::_fast_igetfield, bc, r1);
2845 }
2846 __ b(Done);
2847
2848 __ bind(notInt);
2849 __ cmp(tos_state, (u1)ctos);
2850 __ br(Assembler::NE, notChar);
2851 // ctos
2852 __ access_load_at(T_CHAR, IN_HEAP, r0, field, noreg, noreg);
2853 __ push(ctos);
2854 // Rewrite bytecode to be faster
2975 // c_rarg1: object pointer set up above (null if static)
2976 // c_rarg2: cache entry pointer
2977 // c_rarg3: jvalue object on the stack
2978 __ call_VM(noreg,
2979 CAST_FROM_FN_PTR(address,
2980 InterpreterRuntime::post_field_modification),
2981 c_rarg1, c_rarg2, c_rarg3);
2982 __ load_field_entry(cache, index);
2983 __ bind(L1);
2984 }
2985 }
2986
2987 void TemplateTable::putfield_or_static(int byte_no, bool is_static, RewriteControl rc) {
2988 transition(vtos, vtos);
2989
2990 const Register cache = r2;
2991 const Register index = r3;
2992 const Register tos_state = r3;
2993 const Register obj = r2;
2994 const Register off = r19;
2995 const Register flags = r6;
2996 const Register bc = r4;
2997 const Register inline_klass = r5;
2998
2999 resolve_cache_and_index_for_field(byte_no, cache, index);
3000 jvmti_post_field_mod(cache, index, is_static);
3001 load_resolved_field_entry(obj, cache, tos_state, off, flags, is_static);
3002
3003 Label Done;
3004 {
3005 Label notVolatile;
3006 __ tbz(flags, ResolvedFieldEntry::is_volatile_shift, notVolatile);
3007 __ membar(MacroAssembler::StoreStore | MacroAssembler::LoadStore);
3008 __ bind(notVolatile);
3009 }
3010
3011 // field address
3012 const Address field(obj, off);
3013
3014 Label notByte, notBool, notInt, notShort, notChar,
3015 notLong, notFloat, notObj, notDouble;
3016
3017 assert(btos == 0, "change code, btos != 0");
3018 __ cbnz(tos_state, notByte);
3019
3020 // Don't rewrite putstatic, only putfield
3021 if (is_static) rc = may_not_rewrite;
3022
3023 // btos
3024 {
3025 __ pop(btos);
3026 if (!is_static) pop_and_check_object(obj);
3035 __ cmp(tos_state, (u1)ztos);
3036 __ br(Assembler::NE, notBool);
3037
3038 // ztos
3039 {
3040 __ pop(ztos);
3041 if (!is_static) pop_and_check_object(obj);
3042 __ access_store_at(T_BOOLEAN, IN_HEAP, field, r0, noreg, noreg, noreg);
3043 if (rc == may_rewrite) {
3044 patch_bytecode(Bytecodes::_fast_zputfield, bc, r1, true, byte_no);
3045 }
3046 __ b(Done);
3047 }
3048
3049 __ bind(notBool);
3050 __ cmp(tos_state, (u1)atos);
3051 __ br(Assembler::NE, notObj);
3052
3053 // atos
3054 {
3055 if (!EnableValhalla) {
3056 __ pop(atos);
3057 if (!is_static) pop_and_check_object(obj);
3058 // Store into the field
3059 do_oop_store(_masm, field, r0, IN_HEAP);
3060 if (rc == may_rewrite) {
3061 patch_bytecode(Bytecodes::_fast_aputfield, bc, r1, true, byte_no);
3062 }
3063 __ b(Done);
3064 } else { // Valhalla
3065 __ pop(atos);
3066 if (is_static) {
3067 Label is_inline_type;
3068 __ test_field_is_not_null_free_inline_type(flags, noreg /* temp */, is_inline_type);
3069 __ null_check(r0);
3070 __ bind(is_inline_type);
3071 do_oop_store(_masm, field, r0, IN_HEAP);
3072 __ b(Done);
3073 } else {
3074 Label is_inline_type, is_flat, has_null_marker, rewrite_not_inline, rewrite_inline;
3075 __ test_field_is_null_free_inline_type(flags, noreg /*temp*/, is_inline_type);
3076 __ test_field_has_null_marker(flags, noreg /*temp*/, has_null_marker);
3077 // Not an inline type
3078 pop_and_check_object(obj);
3079 // Store into the field
3080 do_oop_store(_masm, field, r0, IN_HEAP);
3081 __ bind(rewrite_not_inline);
3082 if (rc == may_rewrite) {
3083 patch_bytecode(Bytecodes::_fast_aputfield, bc, r19, true, byte_no);
3084 }
3085 __ b(Done);
3086 // Implementation of the inline type semantic
3087 __ bind(is_inline_type);
3088 __ null_check(r0);
3089 __ test_field_is_flat(flags, noreg /*temp*/, is_flat);
3090 // field is not flat
3091 pop_and_check_object(obj);
3092 // Store into the field
3093 do_oop_store(_masm, field, r0, IN_HEAP);
3094 __ b(rewrite_inline);
3095 __ bind(is_flat);
3096 __ load_field_entry(cache, index); // reload field entry (cache) because it was erased by tos_state
3097 __ load_unsigned_short(index, Address(cache, in_bytes(ResolvedFieldEntry::field_index_offset())));
3098 __ ldr(r2, Address(cache, in_bytes(ResolvedFieldEntry::field_holder_offset())));
3099 __ inline_layout_info(r2, index, r6);
3100 pop_and_check_object(obj);
3101 __ load_klass(inline_klass, r0);
3102 __ payload_address(r0, r0, inline_klass);
3103 __ add(obj, obj, off);
3104 // because we use InlineLayoutInfo, we need special value access code specialized for fields (arrays will need a different API)
3105 __ flat_field_copy(IN_HEAP, r0, obj, r6);
3106 __ b(rewrite_inline);
3107 __ bind(has_null_marker);
3108 assert_different_registers(r0, cache, r19);
3109 pop_and_check_object(r19);
3110 __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::write_nullable_flat_field), r19, r0, cache);
3111 __ bind(rewrite_inline);
3112 if (rc == may_rewrite) {
3113 patch_bytecode(Bytecodes::_fast_vputfield, bc, r19, true, byte_no);
3114 }
3115 __ b(Done);
3116 }
3117 } // Valhalla
3118 }
3119
3120 __ bind(notObj);
3121 __ cmp(tos_state, (u1)itos);
3122 __ br(Assembler::NE, notInt);
3123
3124 // itos
3125 {
3126 __ pop(itos);
3127 if (!is_static) pop_and_check_object(obj);
3128 __ access_store_at(T_INT, IN_HEAP, field, r0, noreg, noreg, noreg);
3129 if (rc == may_rewrite) {
3130 patch_bytecode(Bytecodes::_fast_iputfield, bc, r1, true, byte_no);
3131 }
3132 __ b(Done);
3133 }
3134
3135 __ bind(notInt);
3136 __ cmp(tos_state, (u1)ctos);
3137 __ br(Assembler::NE, notChar);
3202 {
3203 __ pop(dtos);
3204 if (!is_static) pop_and_check_object(obj);
3205 __ access_store_at(T_DOUBLE, IN_HEAP, field, noreg /* dtos */, noreg, noreg, noreg);
3206 if (rc == may_rewrite) {
3207 patch_bytecode(Bytecodes::_fast_dputfield, bc, r1, true, byte_no);
3208 }
3209 }
3210
3211 #ifdef ASSERT
3212 __ b(Done);
3213
3214 __ bind(notDouble);
3215 __ stop("Bad state");
3216 #endif
3217
3218 __ bind(Done);
3219
3220 {
3221 Label notVolatile;
3222 __ tbz(flags, ResolvedFieldEntry::is_volatile_shift, notVolatile);
3223 __ membar(MacroAssembler::StoreLoad | MacroAssembler::StoreStore);
3224 __ bind(notVolatile);
3225 }
3226 }
3227
3228 void TemplateTable::putfield(int byte_no)
3229 {
3230 putfield_or_static(byte_no, false);
3231 }
3232
3233 void TemplateTable::nofast_putfield(int byte_no) {
3234 putfield_or_static(byte_no, false, may_not_rewrite);
3235 }
3236
3237 void TemplateTable::putstatic(int byte_no) {
3238 putfield_or_static(byte_no, true);
3239 }
3240
3241 void TemplateTable::jvmti_post_fast_field_mod() {
3242 if (JvmtiExport::can_post_field_modification()) {
3243 // Check to see if a field modification watch has been set before
3244 // we take the time to call into the VM.
3245 Label L2;
3246 __ lea(rscratch1, ExternalAddress((address)JvmtiExport::get_field_modification_count_addr()));
3247 __ ldrw(c_rarg3, Address(rscratch1));
3248 __ cbzw(c_rarg3, L2);
3249 __ pop_ptr(r19); // copy the object pointer from tos
3250 __ verify_oop(r19);
3251 __ push_ptr(r19); // put the object pointer back on tos
3252 // Save tos values before call_VM() clobbers them. Since we have
3253 // to do it for every data type, we use the saved values as the
3254 // jvalue object.
3255 switch (bytecode()) { // load values into the jvalue object
3256 case Bytecodes::_fast_vputfield: //fall through
3257 case Bytecodes::_fast_aputfield: __ push_ptr(r0); break;
3258 case Bytecodes::_fast_bputfield: // fall through
3259 case Bytecodes::_fast_zputfield: // fall through
3260 case Bytecodes::_fast_sputfield: // fall through
3261 case Bytecodes::_fast_cputfield: // fall through
3262 case Bytecodes::_fast_iputfield: __ push_i(r0); break;
3263 case Bytecodes::_fast_dputfield: __ push_d(); break;
3264 case Bytecodes::_fast_fputfield: __ push_f(); break;
3265 case Bytecodes::_fast_lputfield: __ push_l(r0); break;
3266
3267 default:
3268 ShouldNotReachHere();
3269 }
3270 __ mov(c_rarg3, esp); // points to jvalue on the stack
3271 // access constant pool cache entry
3272 __ load_field_entry(c_rarg2, r0);
3273 __ verify_oop(r19);
3274 // r19: object pointer copied above
3275 // c_rarg2: cache entry pointer
3276 // c_rarg3: jvalue object on the stack
3277 __ call_VM(noreg,
3278 CAST_FROM_FN_PTR(address,
3279 InterpreterRuntime::post_field_modification),
3280 r19, c_rarg2, c_rarg3);
3281
3282 switch (bytecode()) { // restore tos values
3283 case Bytecodes::_fast_vputfield: //fall through
3284 case Bytecodes::_fast_aputfield: __ pop_ptr(r0); break;
3285 case Bytecodes::_fast_bputfield: // fall through
3286 case Bytecodes::_fast_zputfield: // fall through
3287 case Bytecodes::_fast_sputfield: // fall through
3288 case Bytecodes::_fast_cputfield: // fall through
3289 case Bytecodes::_fast_iputfield: __ pop_i(r0); break;
3290 case Bytecodes::_fast_dputfield: __ pop_d(); break;
3291 case Bytecodes::_fast_fputfield: __ pop_f(); break;
3292 case Bytecodes::_fast_lputfield: __ pop_l(r0); break;
3293 default: break;
3294 }
3295 __ bind(L2);
3296 }
3297 }
3298
3299 void TemplateTable::fast_storefield(TosState state)
3300 {
3301 transition(state, vtos);
3302
3303 ByteSize base = ConstantPoolCache::base_offset();
3310 // R1: field offset, R2: field holder, R3: flags
3311 load_resolved_field_entry(r2, r2, noreg, r1, r3);
3312
3313 {
3314 Label notVolatile;
3315 __ tbz(r3, ResolvedFieldEntry::is_volatile_shift, notVolatile);
3316 __ membar(MacroAssembler::StoreStore | MacroAssembler::LoadStore);
3317 __ bind(notVolatile);
3318 }
3319
3320 Label notVolatile;
3321
3322 // Get object from stack
3323 pop_and_check_object(r2);
3324
3325 // field address
3326 const Address field(r2, r1);
3327
3328 // access field
3329 switch (bytecode()) {
3330 case Bytecodes::_fast_vputfield:
3331 {
3332 Label is_flat, has_null_marker, done;
3333 __ test_field_has_null_marker(r3, noreg /* temp */, has_null_marker);
3334 __ null_check(r0);
3335 __ test_field_is_flat(r3, noreg /* temp */, is_flat);
3336 // field is not flat
3337 do_oop_store(_masm, field, r0, IN_HEAP);
3338 __ b(done);
3339 __ bind(is_flat);
3340 // field is flat
3341 __ load_field_entry(r4, r3);
3342 __ load_unsigned_short(r3, Address(r4, in_bytes(ResolvedFieldEntry::field_index_offset())));
3343 __ ldr(r4, Address(r4, in_bytes(ResolvedFieldEntry::field_holder_offset())));
3344 __ inline_layout_info(r4, r3, r5);
3345 __ load_klass(r4, r0);
3346 __ payload_address(r0, r0, r4);
3347 __ lea(rscratch1, field);
3348 __ flat_field_copy(IN_HEAP, r0, rscratch1, r5);
3349 __ b(done);
3350 __ bind(has_null_marker);
3351 __ load_field_entry(r4, r1);
3352 __ mov(r1, r2);
3353 __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::write_nullable_flat_field), r1, r0, r4);
3354 __ bind(done);
3355 }
3356 break;
3357 case Bytecodes::_fast_aputfield:
3358 do_oop_store(_masm, field, r0, IN_HEAP);
3359 break;
3360 case Bytecodes::_fast_lputfield:
3361 __ access_store_at(T_LONG, IN_HEAP, field, r0, noreg, noreg, noreg);
3362 break;
3363 case Bytecodes::_fast_iputfield:
3364 __ access_store_at(T_INT, IN_HEAP, field, r0, noreg, noreg, noreg);
3365 break;
3366 case Bytecodes::_fast_zputfield:
3367 __ access_store_at(T_BOOLEAN, IN_HEAP, field, r0, noreg, noreg, noreg);
3368 break;
3369 case Bytecodes::_fast_bputfield:
3370 __ access_store_at(T_BYTE, IN_HEAP, field, r0, noreg, noreg, noreg);
3371 break;
3372 case Bytecodes::_fast_sputfield:
3373 __ access_store_at(T_SHORT, IN_HEAP, field, r0, noreg, noreg, noreg);
3374 break;
3375 case Bytecodes::_fast_cputfield:
3376 __ access_store_at(T_CHAR, IN_HEAP, field, r0, noreg, noreg, noreg);
3429 // r0: object
3430 __ verify_oop(r0);
3431 __ null_check(r0);
3432 const Address field(r0, r1);
3433
3434 // 8179954: We need to make sure that the code generated for
3435 // volatile accesses forms a sequentially-consistent set of
3436 // operations when combined with STLR and LDAR. Without a leading
3437 // membar it's possible for a simple Dekker test to fail if loads
3438 // use LDR;DMB but stores use STLR. This can happen if C2 compiles
3439 // the stores in one method and we interpret the loads in another.
3440 if (!CompilerConfig::is_c1_or_interpreter_only_no_jvmci()) {
3441 Label notVolatile;
3442 __ tbz(r3, ResolvedFieldEntry::is_volatile_shift, notVolatile);
3443 __ membar(MacroAssembler::AnyAny);
3444 __ bind(notVolatile);
3445 }
3446
3447 // access field
3448 switch (bytecode()) {
3449 case Bytecodes::_fast_vgetfield:
3450 {
3451 Register index = r4, klass = r5, inline_klass = r6, tmp = r7;
3452 Label is_flat, has_null_marker, nonnull, Done;
3453 __ test_field_has_null_marker(r3, noreg /*temp*/, has_null_marker);
3454 __ test_field_is_flat(r3, noreg /* temp */, is_flat);
3455 // field is not flat
3456 __ load_heap_oop(r0, field, rscratch1, rscratch2);
3457 __ cbnz(r0, nonnull);
3458 __ load_unsigned_short(index, Address(r2, in_bytes(ResolvedFieldEntry::field_index_offset())));
3459 __ ldr(klass, Address(r2, in_bytes(ResolvedFieldEntry::field_holder_offset())));
3460 __ get_inline_type_field_klass(klass, index, inline_klass);
3461 __ get_default_value_oop(inline_klass, tmp /* temp */, r0);
3462 __ bind(nonnull);
3463 __ verify_oop(r0);
3464 __ b(Done);
3465 __ bind(is_flat);
3466 // field is flat
3467 __ load_unsigned_short(index, Address(r2, in_bytes(ResolvedFieldEntry::field_index_offset())));
3468 __ read_flat_field(r2, index, r1, tmp /* temp */, r0);
3469 __ verify_oop(r0);
3470 __ b(Done);
3471 __ bind(has_null_marker);
3472 call_VM(r0, CAST_FROM_FN_PTR(address, InterpreterRuntime::read_nullable_flat_field), r0, r2);
3473 __ verify_oop(r0);
3474 __ bind(Done);
3475 }
3476 break;
3477 case Bytecodes::_fast_agetfield:
3478 do_oop_load(_masm, field, r0, IN_HEAP);
3479 __ verify_oop(r0);
3480 break;
3481 case Bytecodes::_fast_lgetfield:
3482 __ access_load_at(T_LONG, IN_HEAP, r0, field, noreg, noreg);
3483 break;
3484 case Bytecodes::_fast_igetfield:
3485 __ access_load_at(T_INT, IN_HEAP, r0, field, noreg, noreg);
3486 break;
3487 case Bytecodes::_fast_bgetfield:
3488 __ access_load_at(T_BYTE, IN_HEAP, r0, field, noreg, noreg);
3489 break;
3490 case Bytecodes::_fast_sgetfield:
3491 __ access_load_at(T_SHORT, IN_HEAP, r0, field, noreg, noreg);
3492 break;
3493 case Bytecodes::_fast_cgetfield:
3494 __ access_load_at(T_CHAR, IN_HEAP, r0, field, noreg, noreg);
3495 break;
3496 case Bytecodes::_fast_fgetfield:
3875 Label initialize_header;
3876
3877 __ get_cpool_and_tags(r4, r0);
3878 // Make sure the class we're about to instantiate has been resolved.
3879 // This is done before loading InstanceKlass to be consistent with the order
3880 // how Constant Pool is updated (see ConstantPool::klass_at_put)
3881 const int tags_offset = Array<u1>::base_offset_in_bytes();
3882 __ lea(rscratch1, Address(r0, r3, Address::lsl(0)));
3883 __ lea(rscratch1, Address(rscratch1, tags_offset));
3884 __ ldarb(rscratch1, rscratch1);
3885 __ cmp(rscratch1, (u1)JVM_CONSTANT_Class);
3886 __ br(Assembler::NE, slow_case);
3887
3888 // get InstanceKlass
3889 __ load_resolved_klass_at_offset(r4, r3, r4, rscratch1);
3890
3891 // make sure klass is initialized
3892 assert(VM_Version::supports_fast_class_init_checks(), "Optimization requires support for fast class initialization checks");
3893 __ clinit_barrier(r4, rscratch1, nullptr /*L_fast_path*/, &slow_case);
3894
3895 __ allocate_instance(r4, r0, r3, r1, true, slow_case);
3896 if (DTraceAllocProbes) {
3897 // Trigger dtrace event for fastpath
3898 __ push(atos); // save the return value
3899 __ call_VM_leaf(
3900 CAST_FROM_FN_PTR(address, static_cast<int (*)(oopDesc*)>(SharedRuntime::dtrace_object_alloc)), r0);
3901 __ pop(atos); // restore the return value
3902
3903 }
3904 __ b(done);
3905
3906 // slow case
3907 __ bind(slow_case);
3908 __ get_constant_pool(c_rarg1);
3909 __ get_unsigned_2_byte_index_at_bcp(c_rarg2, 1);
3910 call_VM(r0, CAST_FROM_FN_PTR(address, InterpreterRuntime::_new), c_rarg1, c_rarg2);
3911 __ verify_oop(r0);
3912
3913 // continue
3914 __ bind(done);
3915 // Must prevent reordering of stores for object initialization with stores that publish the new object.
3916 __ membar(Assembler::StoreStore);
3917 }
3918
3919 void TemplateTable::newarray() {
3920 transition(itos, atos);
3921 __ load_unsigned_byte(c_rarg1, at_bcp(1));
3922 __ mov(c_rarg2, r0);
3923 call_VM(r0, CAST_FROM_FN_PTR(address, InterpreterRuntime::newarray),
3924 c_rarg1, c_rarg2);
3969 __ bind(quicked);
3970 __ mov(r3, r0); // Save object in r3; r0 needed for subtype check
3971 __ load_resolved_klass_at_offset(r2, r19, r0, rscratch1); // r0 = klass
3972
3973 __ bind(resolved);
3974 __ load_klass(r19, r3);
3975
3976 // Generate subtype check. Blows r2, r5. Object in r3.
3977 // Superklass in r0. Subklass in r19.
3978 __ gen_subtype_check(r19, ok_is_subtype);
3979
3980 // Come here on failure
3981 __ push(r3);
3982 // object is at TOS
3983 __ b(Interpreter::_throw_ClassCastException_entry);
3984
3985 // Come here on success
3986 __ bind(ok_is_subtype);
3987 __ mov(r0, r3); // Restore object in r3
3988
3989 __ b(done);
3990 __ bind(is_null);
3991
3992 // Collect counts on whether this test sees nulls a lot or not.
3993 if (ProfileInterpreter) {
3994 __ profile_null_seen(r2);
3995 }
3996
3997 __ bind(done);
3998 }
3999
4000 void TemplateTable::instanceof() {
4001 transition(atos, itos);
4002 Label done, is_null, ok_is_subtype, quicked, resolved;
4003 __ cbz(r0, is_null);
4004
4005 // Get cpool & tags index
4006 __ get_cpool_and_tags(r2, r3); // r2=cpool, r3=tags array
4007 __ get_unsigned_2_byte_index_at_bcp(r19, 1); // r19=index
4008 // See if bytecode has already been quicked
4009 __ add(rscratch1, r3, Array<u1>::base_offset_in_bytes());
4010 __ lea(r1, Address(rscratch1, r19));
4011 __ ldarb(r1, r1);
4012 __ cmp(r1, (u1)JVM_CONSTANT_Class);
4013 __ br(Assembler::EQ, quicked);
4014
4015 __ push(atos); // save receiver for result, and for GC
4016 call_VM(r0, CAST_FROM_FN_PTR(address, InterpreterRuntime::quicken_io_cc));
4095 // in the assembly code structure as well
4096 //
4097 // Stack layout:
4098 //
4099 // [expressions ] <--- esp = expression stack top
4100 // ..
4101 // [expressions ]
4102 // [monitor entry] <--- monitor block top = expression stack bot
4103 // ..
4104 // [monitor entry]
4105 // [frame data ] <--- monitor block bot
4106 // ...
4107 // [saved rfp ] <--- rfp
4108 void TemplateTable::monitorenter()
4109 {
4110 transition(atos, vtos);
4111
4112 // check for null object
4113 __ null_check(r0);
4114
4115 Label is_inline_type;
4116 __ ldr(rscratch1, Address(r0, oopDesc::mark_offset_in_bytes()));
4117 __ test_markword_is_inline_type(rscratch1, is_inline_type);
4118
4119 const Address monitor_block_top(
4120 rfp, frame::interpreter_frame_monitor_block_top_offset * wordSize);
4121 const Address monitor_block_bot(
4122 rfp, frame::interpreter_frame_initial_sp_offset * wordSize);
4123 const int entry_size = frame::interpreter_frame_monitor_size_in_bytes();
4124
4125 Label allocated;
4126
4127 // initialize entry pointer
4128 __ mov(c_rarg1, zr); // points to free slot or null
4129
4130 // find a free slot in the monitor block (result in c_rarg1)
4131 {
4132 Label entry, loop, exit;
4133 __ ldr(c_rarg3, monitor_block_top); // derelativize pointer
4134 __ lea(c_rarg3, Address(rfp, c_rarg3, Address::lsl(Interpreter::logStackElementSize)));
4135 // c_rarg3 points to current entry, starting with top-most entry
4136
4137 __ lea(c_rarg2, monitor_block_bot); // points to word before bottom
4138
4200 // c_rarg1: points to monitor entry
4201 __ bind(allocated);
4202
4203 // Increment bcp to point to the next bytecode, so exception
4204 // handling for async. exceptions work correctly.
4205 // The object has already been popped from the stack, so the
4206 // expression stack looks correct.
4207 __ increment(rbcp);
4208
4209 // store object
4210 __ str(r0, Address(c_rarg1, BasicObjectLock::obj_offset()));
4211 __ lock_object(c_rarg1);
4212
4213 // check to make sure this monitor doesn't cause stack overflow after locking
4214 __ save_bcp(); // in case of exception
4215 __ generate_stack_overflow_check(0);
4216
4217 // The bcp has already been incremented. Just need to dispatch to
4218 // next instruction.
4219 __ dispatch_next(vtos);
4220
4221 __ bind(is_inline_type);
4222 __ call_VM(noreg, CAST_FROM_FN_PTR(address,
4223 InterpreterRuntime::throw_identity_exception), r0);
4224 __ should_not_reach_here();
4225 }
4226
4227
4228 void TemplateTable::monitorexit()
4229 {
4230 transition(atos, vtos);
4231
4232 // check for null object
4233 __ null_check(r0);
4234
4235 const int is_inline_type_mask = markWord::inline_type_pattern;
4236 Label has_identity;
4237 __ ldr(rscratch1, Address(r0, oopDesc::mark_offset_in_bytes()));
4238 __ mov(rscratch2, is_inline_type_mask);
4239 __ andr(rscratch1, rscratch1, rscratch2);
4240 __ cmp(rscratch1, rscratch2);
4241 __ br(Assembler::NE, has_identity);
4242 __ call_VM(noreg, CAST_FROM_FN_PTR(address,
4243 InterpreterRuntime::throw_illegal_monitor_state_exception));
4244 __ should_not_reach_here();
4245 __ bind(has_identity);
4246
4247 const Address monitor_block_top(
4248 rfp, frame::interpreter_frame_monitor_block_top_offset * wordSize);
4249 const Address monitor_block_bot(
4250 rfp, frame::interpreter_frame_initial_sp_offset * wordSize);
4251 const int entry_size = frame::interpreter_frame_monitor_size_in_bytes();
4252
4253 Label found;
4254
4255 // find matching slot
4256 {
4257 Label entry, loop;
4258 __ ldr(c_rarg1, monitor_block_top); // derelativize pointer
4259 __ lea(c_rarg1, Address(rfp, c_rarg1, Address::lsl(Interpreter::logStackElementSize)));
4260 // c_rarg1 points to current entry, starting with top-most entry
4261
4262 __ lea(c_rarg2, monitor_block_bot); // points to word before bottom
4263 // of monitor block
4264 __ b(entry);
4265
4266 __ bind(loop);
|