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);
2560 }
2561 // c_rarg1: object pointer or null
2562 // c_rarg2: cache entry pointer
2563 __ call_VM(noreg, CAST_FROM_FN_PTR(address,
2564 InterpreterRuntime::post_field_access),
2565 c_rarg1, c_rarg2);
2566 __ load_field_entry(cache, index);
2567 __ bind(L1);
2568 }
2569 }
2570
2571 void TemplateTable::pop_and_check_object(Register r)
2572 {
2573 __ pop_ptr(r);
2574 __ null_check(r); // for field access must check obj.
2575 __ verify_oop(r);
2576 }
2577
2578 void TemplateTable::getfield_or_static(int byte_no, bool is_static, RewriteControl rc)
2579 {
2580 const Register cache = r4;
2581 const Register obj = r4;
2582 const Register index = r3;
2583 const Register tos_state = r3;
2584 const Register off = r19;
2585 const Register flags = r6;
2586 const Register bc = r4; // uses same reg as obj, so don't mix them
2587
2588 resolve_cache_and_index_for_field(byte_no, cache, index);
2589 jvmti_post_field_access(cache, index, is_static, false);
2590 load_resolved_field_entry(obj, cache, tos_state, off, flags, is_static);
2591
2592 if (!is_static) {
2593 // obj is on the stack
2594 pop_and_check_object(obj);
2595 }
2596
2597 // 8179954: We need to make sure that the code generated for
2598 // volatile accesses forms a sequentially-consistent set of
2599 // operations when combined with STLR and LDAR. Without a leading
2600 // membar it's possible for a simple Dekker test to fail if loads
2601 // use LDR;DMB but stores use STLR. This can happen if C2 compiles
2602 // the stores in one method and we interpret the loads in another.
2603 if (!CompilerConfig::is_c1_or_interpreter_only_no_jvmci()){
2604 Label notVolatile;
2605 __ tbz(flags, ResolvedFieldEntry::is_volatile_shift, notVolatile);
2606 __ membar(MacroAssembler::AnyAny);
2607 __ bind(notVolatile);
2608 }
2609
2628 __ b(Done);
2629
2630 __ bind(notByte);
2631 __ cmp(tos_state, (u1)ztos);
2632 __ br(Assembler::NE, notBool);
2633
2634 // ztos (same code as btos)
2635 __ access_load_at(T_BOOLEAN, IN_HEAP, r0, field, noreg, noreg);
2636 __ push(ztos);
2637 // Rewrite bytecode to be faster
2638 if (rc == may_rewrite) {
2639 // use btos rewriting, no truncating to t/f bit is needed for getfield.
2640 patch_bytecode(Bytecodes::_fast_bgetfield, bc, r1);
2641 }
2642 __ b(Done);
2643
2644 __ bind(notBool);
2645 __ cmp(tos_state, (u1)atos);
2646 __ br(Assembler::NE, notObj);
2647 // atos
2648 do_oop_load(_masm, field, r0, IN_HEAP);
2649 __ push(atos);
2650 if (rc == may_rewrite) {
2651 patch_bytecode(Bytecodes::_fast_agetfield, bc, r1);
2652 }
2653 __ b(Done);
2654
2655 __ bind(notObj);
2656 __ cmp(tos_state, (u1)itos);
2657 __ br(Assembler::NE, notInt);
2658 // itos
2659 __ access_load_at(T_INT, IN_HEAP, r0, field, noreg, noreg);
2660 __ push(itos);
2661 // Rewrite bytecode to be faster
2662 if (rc == may_rewrite) {
2663 patch_bytecode(Bytecodes::_fast_igetfield, bc, r1);
2664 }
2665 __ b(Done);
2666
2667 __ bind(notInt);
2668 __ cmp(tos_state, (u1)ctos);
2669 __ br(Assembler::NE, notChar);
2670 // ctos
2671 __ access_load_at(T_CHAR, IN_HEAP, r0, field, noreg, noreg);
2672 __ push(ctos);
2673 // Rewrite bytecode to be faster
2794 // c_rarg1: object pointer set up above (null if static)
2795 // c_rarg2: cache entry pointer
2796 // c_rarg3: jvalue object on the stack
2797 __ call_VM(noreg,
2798 CAST_FROM_FN_PTR(address,
2799 InterpreterRuntime::post_field_modification),
2800 c_rarg1, c_rarg2, c_rarg3);
2801 __ load_field_entry(cache, index);
2802 __ bind(L1);
2803 }
2804 }
2805
2806 void TemplateTable::putfield_or_static(int byte_no, bool is_static, RewriteControl rc) {
2807 transition(vtos, vtos);
2808
2809 const Register cache = r2;
2810 const Register index = r3;
2811 const Register tos_state = r3;
2812 const Register obj = r2;
2813 const Register off = r19;
2814 const Register flags = r0;
2815 const Register bc = r4;
2816
2817 resolve_cache_and_index_for_field(byte_no, cache, index);
2818 jvmti_post_field_mod(cache, index, is_static);
2819 load_resolved_field_entry(obj, cache, tos_state, off, flags, is_static);
2820
2821 Label Done;
2822 __ mov(r5, flags);
2823
2824 {
2825 Label notVolatile;
2826 __ tbz(r5, ResolvedFieldEntry::is_volatile_shift, notVolatile);
2827 __ membar(MacroAssembler::StoreStore | MacroAssembler::LoadStore);
2828 __ bind(notVolatile);
2829 }
2830
2831 // field address
2832 const Address field(obj, off);
2833
2834 Label notByte, notBool, notInt, notShort, notChar,
2835 notLong, notFloat, notObj, notDouble;
2836
2837 assert(btos == 0, "change code, btos != 0");
2838 __ cbnz(tos_state, notByte);
2839
2840 // Don't rewrite putstatic, only putfield
2841 if (is_static) rc = may_not_rewrite;
2842
2843 // btos
2844 {
2845 __ pop(btos);
2846 if (!is_static) pop_and_check_object(obj);
2855 __ cmp(tos_state, (u1)ztos);
2856 __ br(Assembler::NE, notBool);
2857
2858 // ztos
2859 {
2860 __ pop(ztos);
2861 if (!is_static) pop_and_check_object(obj);
2862 __ access_store_at(T_BOOLEAN, IN_HEAP, field, r0, noreg, noreg, noreg);
2863 if (rc == may_rewrite) {
2864 patch_bytecode(Bytecodes::_fast_zputfield, bc, r1, true, byte_no);
2865 }
2866 __ b(Done);
2867 }
2868
2869 __ bind(notBool);
2870 __ cmp(tos_state, (u1)atos);
2871 __ br(Assembler::NE, notObj);
2872
2873 // atos
2874 {
2875 __ pop(atos);
2876 if (!is_static) pop_and_check_object(obj);
2877 // Store into the field
2878 do_oop_store(_masm, field, r0, IN_HEAP);
2879 if (rc == may_rewrite) {
2880 patch_bytecode(Bytecodes::_fast_aputfield, bc, r1, true, byte_no);
2881 }
2882 __ b(Done);
2883 }
2884
2885 __ bind(notObj);
2886 __ cmp(tos_state, (u1)itos);
2887 __ br(Assembler::NE, notInt);
2888
2889 // itos
2890 {
2891 __ pop(itos);
2892 if (!is_static) pop_and_check_object(obj);
2893 __ access_store_at(T_INT, IN_HEAP, field, r0, noreg, noreg, noreg);
2894 if (rc == may_rewrite) {
2895 patch_bytecode(Bytecodes::_fast_iputfield, bc, r1, true, byte_no);
2896 }
2897 __ b(Done);
2898 }
2899
2900 __ bind(notInt);
2901 __ cmp(tos_state, (u1)ctos);
2902 __ br(Assembler::NE, notChar);
2967 {
2968 __ pop(dtos);
2969 if (!is_static) pop_and_check_object(obj);
2970 __ access_store_at(T_DOUBLE, IN_HEAP, field, noreg /* dtos */, noreg, noreg, noreg);
2971 if (rc == may_rewrite) {
2972 patch_bytecode(Bytecodes::_fast_dputfield, bc, r1, true, byte_no);
2973 }
2974 }
2975
2976 #ifdef ASSERT
2977 __ b(Done);
2978
2979 __ bind(notDouble);
2980 __ stop("Bad state");
2981 #endif
2982
2983 __ bind(Done);
2984
2985 {
2986 Label notVolatile;
2987 __ tbz(r5, ResolvedFieldEntry::is_volatile_shift, notVolatile);
2988 __ membar(MacroAssembler::StoreLoad | MacroAssembler::StoreStore);
2989 __ bind(notVolatile);
2990 }
2991 }
2992
2993 void TemplateTable::putfield(int byte_no)
2994 {
2995 putfield_or_static(byte_no, false);
2996 }
2997
2998 void TemplateTable::nofast_putfield(int byte_no) {
2999 putfield_or_static(byte_no, false, may_not_rewrite);
3000 }
3001
3002 void TemplateTable::putstatic(int byte_no) {
3003 putfield_or_static(byte_no, true);
3004 }
3005
3006 void TemplateTable::jvmti_post_fast_field_mod() {
3007 if (JvmtiExport::can_post_field_modification()) {
3008 // Check to see if a field modification watch has been set before
3009 // we take the time to call into the VM.
3010 Label L2;
3011 __ lea(rscratch1, ExternalAddress((address)JvmtiExport::get_field_modification_count_addr()));
3012 __ ldrw(c_rarg3, Address(rscratch1));
3013 __ cbzw(c_rarg3, L2);
3014 __ pop_ptr(r19); // copy the object pointer from tos
3015 __ verify_oop(r19);
3016 __ push_ptr(r19); // put the object pointer back on tos
3017 // Save tos values before call_VM() clobbers them. Since we have
3018 // to do it for every data type, we use the saved values as the
3019 // jvalue object.
3020 switch (bytecode()) { // load values into the jvalue object
3021 case Bytecodes::_fast_aputfield: __ push_ptr(r0); break;
3022 case Bytecodes::_fast_bputfield: // fall through
3023 case Bytecodes::_fast_zputfield: // fall through
3024 case Bytecodes::_fast_sputfield: // fall through
3025 case Bytecodes::_fast_cputfield: // fall through
3026 case Bytecodes::_fast_iputfield: __ push_i(r0); break;
3027 case Bytecodes::_fast_dputfield: __ push_d(); break;
3028 case Bytecodes::_fast_fputfield: __ push_f(); break;
3029 case Bytecodes::_fast_lputfield: __ push_l(r0); break;
3030
3031 default:
3032 ShouldNotReachHere();
3033 }
3034 __ mov(c_rarg3, esp); // points to jvalue on the stack
3035 // access constant pool cache entry
3036 __ load_field_entry(c_rarg2, r0);
3037 __ verify_oop(r19);
3038 // r19: object pointer copied above
3039 // c_rarg2: cache entry pointer
3040 // c_rarg3: jvalue object on the stack
3041 __ call_VM(noreg,
3042 CAST_FROM_FN_PTR(address,
3043 InterpreterRuntime::post_field_modification),
3044 r19, c_rarg2, c_rarg3);
3045
3046 switch (bytecode()) { // restore tos values
3047 case Bytecodes::_fast_aputfield: __ pop_ptr(r0); break;
3048 case Bytecodes::_fast_bputfield: // fall through
3049 case Bytecodes::_fast_zputfield: // fall through
3050 case Bytecodes::_fast_sputfield: // fall through
3051 case Bytecodes::_fast_cputfield: // fall through
3052 case Bytecodes::_fast_iputfield: __ pop_i(r0); break;
3053 case Bytecodes::_fast_dputfield: __ pop_d(); break;
3054 case Bytecodes::_fast_fputfield: __ pop_f(); break;
3055 case Bytecodes::_fast_lputfield: __ pop_l(r0); break;
3056 default: break;
3057 }
3058 __ bind(L2);
3059 }
3060 }
3061
3062 void TemplateTable::fast_storefield(TosState state)
3063 {
3064 transition(state, vtos);
3065
3066 ByteSize base = ConstantPoolCache::base_offset();
3077 // Must prevent reordering of the following cp cache loads with bytecode load
3078 __ membar(MacroAssembler::LoadLoad);
3079
3080 {
3081 Label notVolatile;
3082 __ tbz(r3, ResolvedFieldEntry::is_volatile_shift, notVolatile);
3083 __ membar(MacroAssembler::StoreStore | MacroAssembler::LoadStore);
3084 __ bind(notVolatile);
3085 }
3086
3087 Label notVolatile;
3088
3089 // Get object from stack
3090 pop_and_check_object(r2);
3091
3092 // field address
3093 const Address field(r2, r1);
3094
3095 // access field
3096 switch (bytecode()) {
3097 case Bytecodes::_fast_aputfield:
3098 do_oop_store(_masm, field, r0, IN_HEAP);
3099 break;
3100 case Bytecodes::_fast_lputfield:
3101 __ access_store_at(T_LONG, IN_HEAP, field, r0, noreg, noreg, noreg);
3102 break;
3103 case Bytecodes::_fast_iputfield:
3104 __ access_store_at(T_INT, IN_HEAP, field, r0, noreg, noreg, noreg);
3105 break;
3106 case Bytecodes::_fast_zputfield:
3107 __ access_store_at(T_BOOLEAN, IN_HEAP, field, r0, noreg, noreg, noreg);
3108 break;
3109 case Bytecodes::_fast_bputfield:
3110 __ access_store_at(T_BYTE, IN_HEAP, field, r0, noreg, noreg, noreg);
3111 break;
3112 case Bytecodes::_fast_sputfield:
3113 __ access_store_at(T_SHORT, IN_HEAP, field, r0, noreg, noreg, noreg);
3114 break;
3115 case Bytecodes::_fast_cputfield:
3116 __ access_store_at(T_CHAR, IN_HEAP, field, r0, noreg, noreg, noreg);
3172 // r0: object
3173 __ verify_oop(r0);
3174 __ null_check(r0);
3175 const Address field(r0, r1);
3176
3177 // 8179954: We need to make sure that the code generated for
3178 // volatile accesses forms a sequentially-consistent set of
3179 // operations when combined with STLR and LDAR. Without a leading
3180 // membar it's possible for a simple Dekker test to fail if loads
3181 // use LDR;DMB but stores use STLR. This can happen if C2 compiles
3182 // the stores in one method and we interpret the loads in another.
3183 if (!CompilerConfig::is_c1_or_interpreter_only_no_jvmci()) {
3184 Label notVolatile;
3185 __ tbz(r3, ResolvedFieldEntry::is_volatile_shift, notVolatile);
3186 __ membar(MacroAssembler::AnyAny);
3187 __ bind(notVolatile);
3188 }
3189
3190 // access field
3191 switch (bytecode()) {
3192 case Bytecodes::_fast_agetfield:
3193 do_oop_load(_masm, field, r0, IN_HEAP);
3194 __ verify_oop(r0);
3195 break;
3196 case Bytecodes::_fast_lgetfield:
3197 __ access_load_at(T_LONG, IN_HEAP, r0, field, noreg, noreg);
3198 break;
3199 case Bytecodes::_fast_igetfield:
3200 __ access_load_at(T_INT, IN_HEAP, r0, field, noreg, noreg);
3201 break;
3202 case Bytecodes::_fast_bgetfield:
3203 __ access_load_at(T_BYTE, IN_HEAP, r0, field, noreg, noreg);
3204 break;
3205 case Bytecodes::_fast_sgetfield:
3206 __ access_load_at(T_SHORT, IN_HEAP, r0, field, noreg, noreg);
3207 break;
3208 case Bytecodes::_fast_cgetfield:
3209 __ access_load_at(T_CHAR, IN_HEAP, r0, field, noreg, noreg);
3210 break;
3211 case Bytecodes::_fast_fgetfield:
3590 Label initialize_header;
3591
3592 __ get_cpool_and_tags(r4, r0);
3593 // Make sure the class we're about to instantiate has been resolved.
3594 // This is done before loading InstanceKlass to be consistent with the order
3595 // how Constant Pool is updated (see ConstantPool::klass_at_put)
3596 const int tags_offset = Array<u1>::base_offset_in_bytes();
3597 __ lea(rscratch1, Address(r0, r3, Address::lsl(0)));
3598 __ lea(rscratch1, Address(rscratch1, tags_offset));
3599 __ ldarb(rscratch1, rscratch1);
3600 __ cmp(rscratch1, (u1)JVM_CONSTANT_Class);
3601 __ br(Assembler::NE, slow_case);
3602
3603 // get InstanceKlass
3604 __ load_resolved_klass_at_offset(r4, r3, r4, rscratch1);
3605
3606 // make sure klass is initialized
3607 assert(VM_Version::supports_fast_class_init_checks(), "Optimization requires support for fast class initialization checks");
3608 __ clinit_barrier(r4, rscratch1, nullptr /*L_fast_path*/, &slow_case);
3609
3610 // get instance_size in InstanceKlass (scaled to a count of bytes)
3611 __ ldrw(r3,
3612 Address(r4,
3613 Klass::layout_helper_offset()));
3614 // test to see if it has a finalizer or is malformed in some way
3615 __ tbnz(r3, exact_log2(Klass::_lh_instance_slow_path_bit), slow_case);
3616
3617 // Allocate the instance:
3618 // If TLAB is enabled:
3619 // Try to allocate in the TLAB.
3620 // If fails, go to the slow path.
3621 // Initialize the allocation.
3622 // Exit.
3623 //
3624 // Go to slow path.
3625
3626 if (UseTLAB) {
3627 __ tlab_allocate(r0, r3, 0, noreg, r1, slow_case);
3628
3629 if (ZeroTLAB) {
3630 // the fields have been already cleared
3631 __ b(initialize_header);
3632 }
3633
3634 // The object is initialized before the header. If the object size is
3635 // zero, go directly to the header initialization.
3636 __ sub(r3, r3, sizeof(oopDesc));
3637 __ cbz(r3, initialize_header);
3638
3639 // Initialize object fields
3640 {
3641 __ add(r2, r0, sizeof(oopDesc));
3642 Label loop;
3643 __ bind(loop);
3644 __ str(zr, Address(__ post(r2, BytesPerLong)));
3645 __ sub(r3, r3, BytesPerLong);
3646 __ cbnz(r3, loop);
3647 }
3648
3649 // initialize object header only.
3650 __ bind(initialize_header);
3651 __ mov(rscratch1, (intptr_t)markWord::prototype().value());
3652 __ str(rscratch1, Address(r0, oopDesc::mark_offset_in_bytes()));
3653 __ store_klass_gap(r0, zr); // zero klass gap for compressed oops
3654 __ store_klass(r0, r4); // store klass last
3655
3656 {
3657 SkipIfEqual skip(_masm, &DTraceAllocProbes, false);
3658 // Trigger dtrace event for fastpath
3659 __ push(atos); // save the return value
3660 __ call_VM_leaf(
3661 CAST_FROM_FN_PTR(address, static_cast<int (*)(oopDesc*)>(SharedRuntime::dtrace_object_alloc)), r0);
3662 __ pop(atos); // restore the return value
3663
3664 }
3665 __ b(done);
3666 }
3667
3668 // slow case
3669 __ bind(slow_case);
3670 __ get_constant_pool(c_rarg1);
3671 __ get_unsigned_2_byte_index_at_bcp(c_rarg2, 1);
3672 call_VM(r0, CAST_FROM_FN_PTR(address, InterpreterRuntime::_new), c_rarg1, c_rarg2);
3673 __ verify_oop(r0);
3674
3675 // continue
3676 __ bind(done);
3677 // Must prevent reordering of stores for object initialization with stores that publish the new object.
3678 __ membar(Assembler::StoreStore);
3679 }
3680
3681 void TemplateTable::newarray() {
3682 transition(itos, atos);
3683 __ load_unsigned_byte(c_rarg1, at_bcp(1));
3684 __ mov(c_rarg2, r0);
3685 call_VM(r0, CAST_FROM_FN_PTR(address, InterpreterRuntime::newarray),
3686 c_rarg1, c_rarg2);
3731 __ bind(quicked);
3732 __ mov(r3, r0); // Save object in r3; r0 needed for subtype check
3733 __ load_resolved_klass_at_offset(r2, r19, r0, rscratch1); // r0 = klass
3734
3735 __ bind(resolved);
3736 __ load_klass(r19, r3);
3737
3738 // Generate subtype check. Blows r2, r5. Object in r3.
3739 // Superklass in r0. Subklass in r19.
3740 __ gen_subtype_check(r19, ok_is_subtype);
3741
3742 // Come here on failure
3743 __ push(r3);
3744 // object is at TOS
3745 __ b(Interpreter::_throw_ClassCastException_entry);
3746
3747 // Come here on success
3748 __ bind(ok_is_subtype);
3749 __ mov(r0, r3); // Restore object in r3
3750
3751 // Collect counts on whether this test sees nulls a lot or not.
3752 if (ProfileInterpreter) {
3753 __ b(done);
3754 __ bind(is_null);
3755 __ profile_null_seen(r2);
3756 } else {
3757 __ bind(is_null); // same as 'done'
3758 }
3759 __ bind(done);
3760 }
3761
3762 void TemplateTable::instanceof() {
3763 transition(atos, itos);
3764 Label done, is_null, ok_is_subtype, quicked, resolved;
3765 __ cbz(r0, is_null);
3766
3767 // Get cpool & tags index
3768 __ get_cpool_and_tags(r2, r3); // r2=cpool, r3=tags array
3769 __ get_unsigned_2_byte_index_at_bcp(r19, 1); // r19=index
3770 // See if bytecode has already been quicked
3771 __ add(rscratch1, r3, Array<u1>::base_offset_in_bytes());
3772 __ lea(r1, Address(rscratch1, r19));
3773 __ ldarb(r1, r1);
3774 __ cmp(r1, (u1)JVM_CONSTANT_Class);
3775 __ br(Assembler::EQ, quicked);
3776
3777 __ push(atos); // save receiver for result, and for GC
3778 call_VM(r0, CAST_FROM_FN_PTR(address, InterpreterRuntime::quicken_io_cc));
3857 // in the assembly code structure as well
3858 //
3859 // Stack layout:
3860 //
3861 // [expressions ] <--- esp = expression stack top
3862 // ..
3863 // [expressions ]
3864 // [monitor entry] <--- monitor block top = expression stack bot
3865 // ..
3866 // [monitor entry]
3867 // [frame data ] <--- monitor block bot
3868 // ...
3869 // [saved rfp ] <--- rfp
3870 void TemplateTable::monitorenter()
3871 {
3872 transition(atos, vtos);
3873
3874 // check for null object
3875 __ null_check(r0);
3876
3877 const Address monitor_block_top(
3878 rfp, frame::interpreter_frame_monitor_block_top_offset * wordSize);
3879 const Address monitor_block_bot(
3880 rfp, frame::interpreter_frame_initial_sp_offset * wordSize);
3881 const int entry_size = frame::interpreter_frame_monitor_size_in_bytes();
3882
3883 Label allocated;
3884
3885 // initialize entry pointer
3886 __ mov(c_rarg1, zr); // points to free slot or null
3887
3888 // find a free slot in the monitor block (result in c_rarg1)
3889 {
3890 Label entry, loop, exit;
3891 __ ldr(c_rarg3, monitor_block_top); // derelativize pointer
3892 __ lea(c_rarg3, Address(rfp, c_rarg3, Address::lsl(Interpreter::logStackElementSize)));
3893 // c_rarg3 points to current entry, starting with top-most entry
3894
3895 __ lea(c_rarg2, monitor_block_bot); // points to word before bottom
3896
3958 // c_rarg1: points to monitor entry
3959 __ bind(allocated);
3960
3961 // Increment bcp to point to the next bytecode, so exception
3962 // handling for async. exceptions work correctly.
3963 // The object has already been popped from the stack, so the
3964 // expression stack looks correct.
3965 __ increment(rbcp);
3966
3967 // store object
3968 __ str(r0, Address(c_rarg1, BasicObjectLock::obj_offset()));
3969 __ lock_object(c_rarg1);
3970
3971 // check to make sure this monitor doesn't cause stack overflow after locking
3972 __ save_bcp(); // in case of exception
3973 __ generate_stack_overflow_check(0);
3974
3975 // The bcp has already been incremented. Just need to dispatch to
3976 // next instruction.
3977 __ dispatch_next(vtos);
3978 }
3979
3980
3981 void TemplateTable::monitorexit()
3982 {
3983 transition(atos, vtos);
3984
3985 // check for null object
3986 __ null_check(r0);
3987
3988 const Address monitor_block_top(
3989 rfp, frame::interpreter_frame_monitor_block_top_offset * wordSize);
3990 const Address monitor_block_bot(
3991 rfp, frame::interpreter_frame_initial_sp_offset * wordSize);
3992 const int entry_size = frame::interpreter_frame_monitor_size_in_bytes();
3993
3994 Label found;
3995
3996 // find matching slot
3997 {
3998 Label entry, loop;
3999 __ ldr(c_rarg1, monitor_block_top); // derelativize pointer
4000 __ lea(c_rarg1, Address(rfp, c_rarg1, Address::lsl(Interpreter::logStackElementSize)));
4001 // c_rarg1 points to current entry, starting with top-most entry
4002
4003 __ lea(c_rarg2, monitor_block_bot); // points to word before bottom
4004 // of monitor block
4005 __ b(entry);
4006
4007 __ 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 (UseFlatArray) {
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::value_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 (UseFlatArray) {
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 // No way to store null in flat null-free array
1185 __ test_null_free_array_oop(r3, r8, is_null_into_value_array_npe);
1186 __ b(store_null);
1187
1188 __ bind(is_null_into_value_array_npe);
1189 __ b(ExternalAddress(Interpreter::_throw_NullPointerException_entry));
1190
1191 __ bind(store_null);
1192 }
1193
1194 // Store a null
1195 do_oop_store(_masm, element_address, noreg, IS_ARRAY);
1196 __ b(done);
1197
1198 if (UseFlatArray) {
1199 Label is_type_ok;
1200 __ bind(is_flat_array); // Store non-null value to flat
1201
1202 // Simplistic type check...
1203 // r0 - value, r2 - index, r3 - array.
1204
1205 // Profile the not-null value's klass.
1206 // Load value class
1207 __ load_klass(r1, r0);
1208
1209 // Move element klass into r7
1210 __ ldr(r7, Address(r5, ArrayKlass::element_klass_offset()));
1211
1212 // flat value array needs exact type match
1213 // is "r1 == r7" (value subclass == array element superclass)
1214
1215 __ cmp(r7, r1);
1216 __ br(Assembler::EQ, is_type_ok);
1217
1218 __ b(ExternalAddress(Interpreter::_throw_ArrayStoreException_entry));
1219
1220 __ bind(is_type_ok);
1221 // r1: value's klass
1222 // r3: array
1223 // r5: array klass
1224 __ test_klass_is_empty_inline_type(r1, r7, done);
1225
1226 // calc dst for copy
1227 __ ldrw(r7, at_tos_p1()); // index
1228 __ data_for_value_array_index(r3, r5, r7, r7);
1229
1230 // ...and src for copy
1231 __ ldr(r6, at_tos()); // value
1232 __ data_for_oop(r6, r6, r1);
1233
1234 __ mov(r4, r1); // Shuffle arguments to avoid conflict with c_rarg1
1235 __ access_value_copy(IN_HEAP, r6, r7, r4);
1236 }
1237
1238 // Pop stack arguments
1239 __ bind(done);
1240 __ add(esp, esp, 3 * Interpreter::stackElementSize);
1241 }
1242
1243 void TemplateTable::bastore()
1244 {
1245 transition(itos, vtos);
1246 __ pop_i(r1);
1247 __ pop_ptr(r3);
1248 // r0: value
1249 // r1: index
1250 // r3: array
1251 index_check(r3, r1); // prefer index in r1
1252
1253 // Need to check whether array is boolean or byte
1254 // since both types share the bastore bytecode.
1255 __ load_klass(r2, r3);
1256 __ ldrw(r2, Address(r2, Klass::layout_helper_offset()));
2021 __ br(j_not(cc), not_taken);
2022 branch(false, false);
2023 __ bind(not_taken);
2024 __ profile_not_taken_branch(r0);
2025 }
2026
2027 void TemplateTable::if_nullcmp(Condition cc)
2028 {
2029 transition(atos, vtos);
2030 // assume branch is more often taken than not (loops use backward branches)
2031 Label not_taken;
2032 if (cc == equal)
2033 __ cbnz(r0, not_taken);
2034 else
2035 __ cbz(r0, not_taken);
2036 branch(false, false);
2037 __ bind(not_taken);
2038 __ profile_not_taken_branch(r0);
2039 }
2040
2041 void TemplateTable::if_acmp(Condition cc) {
2042 transition(atos, vtos);
2043 // assume branch is more often taken than not (loops use backward branches)
2044 Label taken, not_taken;
2045 __ pop_ptr(r1);
2046
2047 __ profile_acmp(r2, r1, r0, r4);
2048
2049 Register is_inline_type_mask = rscratch1;
2050 __ mov(is_inline_type_mask, markWord::inline_type_pattern);
2051
2052 if (EnableValhalla) {
2053 __ cmp(r1, r0);
2054 __ br(Assembler::EQ, (cc == equal) ? taken : not_taken);
2055
2056 // might be substitutable, test if either r0 or r1 is null
2057 __ andr(r2, r0, r1);
2058 __ cbz(r2, (cc == equal) ? not_taken : taken);
2059
2060 // and both are values ?
2061 __ ldr(r2, Address(r1, oopDesc::mark_offset_in_bytes()));
2062 __ andr(r2, r2, is_inline_type_mask);
2063 __ ldr(r4, Address(r0, oopDesc::mark_offset_in_bytes()));
2064 __ andr(r4, r4, is_inline_type_mask);
2065 __ andr(r2, r2, r4);
2066 __ cmp(r2, is_inline_type_mask);
2067 __ br(Assembler::NE, (cc == equal) ? not_taken : taken);
2068
2069 // same value klass ?
2070 __ load_metadata(r2, r1);
2071 __ load_metadata(r4, r0);
2072 __ cmp(r2, r4);
2073 __ br(Assembler::NE, (cc == equal) ? not_taken : taken);
2074
2075 // Know both are the same type, let's test for substitutability...
2076 if (cc == equal) {
2077 invoke_is_substitutable(r0, r1, taken, not_taken);
2078 } else {
2079 invoke_is_substitutable(r0, r1, not_taken, taken);
2080 }
2081 __ stop("Not reachable");
2082 }
2083
2084 __ cmpoop(r1, r0);
2085 __ br(j_not(cc), not_taken);
2086 __ bind(taken);
2087 branch(false, false);
2088 __ bind(not_taken);
2089 __ profile_not_taken_branch(r0, true);
2090 }
2091
2092 void TemplateTable::invoke_is_substitutable(Register aobj, Register bobj,
2093 Label& is_subst, Label& not_subst) {
2094
2095 __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::is_substitutable), aobj, bobj);
2096 // Restored... r0 answer, jmp to outcome...
2097 __ cbz(r0, not_subst);
2098 __ b(is_subst);
2099 }
2100
2101
2102 void TemplateTable::ret() {
2103 transition(vtos, vtos);
2104 locals_index(r1);
2105 __ ldr(r1, aaddress(r1)); // get return bci, compute return bcp
2106 __ profile_ret(r1, r2);
2107 __ ldr(rbcp, Address(rmethod, Method::const_offset()));
2108 __ lea(rbcp, Address(rbcp, r1));
2109 __ add(rbcp, rbcp, in_bytes(ConstMethod::codes_offset()));
2110 __ dispatch_next(vtos, 0, /*generate_poll*/true);
2111 }
2112
2113 void TemplateTable::wide_ret() {
2114 transition(vtos, vtos);
2115 locals_index_wide(r1);
2116 __ ldr(r1, aaddress(r1)); // get return bci, compute return bcp
2117 __ profile_ret(r1, r2);
2118 __ ldr(rbcp, Address(rmethod, Method::const_offset()));
2119 __ lea(rbcp, Address(rbcp, r1));
2120 __ add(rbcp, rbcp, in_bytes(ConstMethod::codes_offset()));
2121 __ dispatch_next(vtos, 0, /*generate_poll*/true);
2689 }
2690 // c_rarg1: object pointer or null
2691 // c_rarg2: cache entry pointer
2692 __ call_VM(noreg, CAST_FROM_FN_PTR(address,
2693 InterpreterRuntime::post_field_access),
2694 c_rarg1, c_rarg2);
2695 __ load_field_entry(cache, index);
2696 __ bind(L1);
2697 }
2698 }
2699
2700 void TemplateTable::pop_and_check_object(Register r)
2701 {
2702 __ pop_ptr(r);
2703 __ null_check(r); // for field access must check obj.
2704 __ verify_oop(r);
2705 }
2706
2707 void TemplateTable::getfield_or_static(int byte_no, bool is_static, RewriteControl rc)
2708 {
2709 const Register cache = r2;
2710 const Register obj = r4;
2711 const Register klass = r5;
2712 const Register inline_klass = r7;
2713 const Register field_index = r23;
2714 const Register index = r3;
2715 const Register tos_state = r3;
2716 const Register off = r19;
2717 const Register flags = r6;
2718 const Register bc = r4; // uses same reg as obj, so don't mix them
2719
2720 resolve_cache_and_index_for_field(byte_no, cache, index);
2721 jvmti_post_field_access(cache, index, is_static, false);
2722
2723 // Valhalla extras
2724 __ load_unsigned_short(field_index, Address(cache, in_bytes(ResolvedFieldEntry::field_index_offset())));
2725 __ ldr(klass, Address(cache, ResolvedFieldEntry::field_holder_offset()));
2726
2727 load_resolved_field_entry(obj, cache, tos_state, off, flags, is_static);
2728
2729 if (!is_static) {
2730 // obj is on the stack
2731 pop_and_check_object(obj);
2732 }
2733
2734 // 8179954: We need to make sure that the code generated for
2735 // volatile accesses forms a sequentially-consistent set of
2736 // operations when combined with STLR and LDAR. Without a leading
2737 // membar it's possible for a simple Dekker test to fail if loads
2738 // use LDR;DMB but stores use STLR. This can happen if C2 compiles
2739 // the stores in one method and we interpret the loads in another.
2740 if (!CompilerConfig::is_c1_or_interpreter_only_no_jvmci()){
2741 Label notVolatile;
2742 __ tbz(flags, ResolvedFieldEntry::is_volatile_shift, notVolatile);
2743 __ membar(MacroAssembler::AnyAny);
2744 __ bind(notVolatile);
2745 }
2746
2765 __ b(Done);
2766
2767 __ bind(notByte);
2768 __ cmp(tos_state, (u1)ztos);
2769 __ br(Assembler::NE, notBool);
2770
2771 // ztos (same code as btos)
2772 __ access_load_at(T_BOOLEAN, IN_HEAP, r0, field, noreg, noreg);
2773 __ push(ztos);
2774 // Rewrite bytecode to be faster
2775 if (rc == may_rewrite) {
2776 // use btos rewriting, no truncating to t/f bit is needed for getfield.
2777 patch_bytecode(Bytecodes::_fast_bgetfield, bc, r1);
2778 }
2779 __ b(Done);
2780
2781 __ bind(notBool);
2782 __ cmp(tos_state, (u1)atos);
2783 __ br(Assembler::NE, notObj);
2784 // atos
2785 if (!EnableValhalla) {
2786 do_oop_load(_masm, field, r0, IN_HEAP);
2787 __ push(atos);
2788 if (rc == may_rewrite) {
2789 patch_bytecode(Bytecodes::_fast_agetfield, bc, r1);
2790 }
2791 __ b(Done);
2792 } else { // Valhalla
2793 if (is_static) {
2794 __ load_heap_oop(r0, field, rscratch1, rscratch2);
2795 Label is_null_free_inline_type, uninitialized;
2796 // Issue below if the static field has not been initialized yet
2797 __ test_field_is_null_free_inline_type(flags, noreg /*temp*/, is_null_free_inline_type);
2798 // field is not a null free inline type
2799 __ push(atos);
2800 __ b(Done);
2801 // field is a null free inline type, must not return null even if uninitialized
2802 __ bind(is_null_free_inline_type);
2803 __ cbz(r0, uninitialized);
2804 __ push(atos);
2805 __ b(Done);
2806 __ bind(uninitialized);
2807 Label slow_case, finish;
2808 __ ldrb(rscratch1, Address(klass, InstanceKlass::init_state_offset()));
2809 __ cmp(rscratch1, (u1)InstanceKlass::fully_initialized);
2810 __ br(Assembler::NE, slow_case);
2811 __ get_default_value_oop(klass, off /* temp */, r0);
2812 __ b(finish);
2813 __ bind(slow_case);
2814 __ call_VM(r0, CAST_FROM_FN_PTR(address, InterpreterRuntime::uninitialized_static_inline_type_field), obj, cache);
2815 __ bind(finish);
2816 __ verify_oop(r0);
2817 __ push(atos);
2818 __ b(Done);
2819 } else {
2820 Label is_flat, nonnull, is_inline_type, has_null_marker, rewrite_inline;
2821 __ test_field_is_null_free_inline_type(flags, noreg /*temp*/, is_inline_type);
2822 __ test_field_has_null_marker(flags, noreg /*temp*/, has_null_marker);
2823 // Non-inline field case
2824 __ load_heap_oop(r0, field, rscratch1, rscratch2);
2825 __ push(atos);
2826 if (rc == may_rewrite) {
2827 patch_bytecode(Bytecodes::_fast_agetfield, bc, r1);
2828 }
2829 __ b(Done);
2830 __ bind(is_inline_type);
2831 __ test_field_is_flat(flags, noreg /* temp */, is_flat);
2832 // field is not flat
2833 __ load_heap_oop(r0, field, rscratch1, rscratch2);
2834 __ cbnz(r0, nonnull);
2835 __ get_inline_type_field_klass(klass, field_index, inline_klass);
2836 __ get_default_value_oop(inline_klass, klass /* temp */, r0);
2837 __ bind(nonnull);
2838 __ verify_oop(r0);
2839 __ push(atos);
2840 __ b(rewrite_inline);
2841 __ bind(is_flat);
2842 // field is flat
2843 __ mov(r0, obj);
2844 __ read_flat_field(klass, field_index, off, inline_klass /* temp */, r0);
2845 __ verify_oop(r0);
2846 __ push(atos);
2847 __ b(rewrite_inline);
2848 __ bind(has_null_marker);
2849 call_VM(r0, CAST_FROM_FN_PTR(address, InterpreterRuntime::read_nullable_flat_field), obj, cache);
2850 __ verify_oop(r0);
2851 __ push(atos);
2852 __ bind(rewrite_inline);
2853 if (rc == may_rewrite) {
2854 patch_bytecode(Bytecodes::_fast_vgetfield, bc, r1);
2855 }
2856 __ b(Done);
2857 }
2858 }
2859
2860 __ bind(notObj);
2861 __ cmp(tos_state, (u1)itos);
2862 __ br(Assembler::NE, notInt);
2863 // itos
2864 __ access_load_at(T_INT, IN_HEAP, r0, field, noreg, noreg);
2865 __ push(itos);
2866 // Rewrite bytecode to be faster
2867 if (rc == may_rewrite) {
2868 patch_bytecode(Bytecodes::_fast_igetfield, bc, r1);
2869 }
2870 __ b(Done);
2871
2872 __ bind(notInt);
2873 __ cmp(tos_state, (u1)ctos);
2874 __ br(Assembler::NE, notChar);
2875 // ctos
2876 __ access_load_at(T_CHAR, IN_HEAP, r0, field, noreg, noreg);
2877 __ push(ctos);
2878 // Rewrite bytecode to be faster
2999 // c_rarg1: object pointer set up above (null if static)
3000 // c_rarg2: cache entry pointer
3001 // c_rarg3: jvalue object on the stack
3002 __ call_VM(noreg,
3003 CAST_FROM_FN_PTR(address,
3004 InterpreterRuntime::post_field_modification),
3005 c_rarg1, c_rarg2, c_rarg3);
3006 __ load_field_entry(cache, index);
3007 __ bind(L1);
3008 }
3009 }
3010
3011 void TemplateTable::putfield_or_static(int byte_no, bool is_static, RewriteControl rc) {
3012 transition(vtos, vtos);
3013
3014 const Register cache = r2;
3015 const Register index = r3;
3016 const Register tos_state = r3;
3017 const Register obj = r2;
3018 const Register off = r19;
3019 const Register flags = r6;
3020 const Register bc = r4;
3021 const Register inline_klass = r5;
3022
3023 resolve_cache_and_index_for_field(byte_no, cache, index);
3024 jvmti_post_field_mod(cache, index, is_static);
3025 load_resolved_field_entry(obj, cache, tos_state, off, flags, is_static);
3026
3027 Label Done;
3028 {
3029 Label notVolatile;
3030 __ tbz(flags, ResolvedFieldEntry::is_volatile_shift, notVolatile);
3031 __ membar(MacroAssembler::StoreStore | MacroAssembler::LoadStore);
3032 __ bind(notVolatile);
3033 }
3034
3035 // field address
3036 const Address field(obj, off);
3037
3038 Label notByte, notBool, notInt, notShort, notChar,
3039 notLong, notFloat, notObj, notDouble;
3040
3041 assert(btos == 0, "change code, btos != 0");
3042 __ cbnz(tos_state, notByte);
3043
3044 // Don't rewrite putstatic, only putfield
3045 if (is_static) rc = may_not_rewrite;
3046
3047 // btos
3048 {
3049 __ pop(btos);
3050 if (!is_static) pop_and_check_object(obj);
3059 __ cmp(tos_state, (u1)ztos);
3060 __ br(Assembler::NE, notBool);
3061
3062 // ztos
3063 {
3064 __ pop(ztos);
3065 if (!is_static) pop_and_check_object(obj);
3066 __ access_store_at(T_BOOLEAN, IN_HEAP, field, r0, noreg, noreg, noreg);
3067 if (rc == may_rewrite) {
3068 patch_bytecode(Bytecodes::_fast_zputfield, bc, r1, true, byte_no);
3069 }
3070 __ b(Done);
3071 }
3072
3073 __ bind(notBool);
3074 __ cmp(tos_state, (u1)atos);
3075 __ br(Assembler::NE, notObj);
3076
3077 // atos
3078 {
3079 if (!EnableValhalla) {
3080 __ pop(atos);
3081 if (!is_static) pop_and_check_object(obj);
3082 // Store into the field
3083 do_oop_store(_masm, field, r0, IN_HEAP);
3084 if (rc == may_rewrite) {
3085 patch_bytecode(Bytecodes::_fast_aputfield, bc, r1, true, byte_no);
3086 }
3087 __ b(Done);
3088 } else { // Valhalla
3089 __ pop(atos);
3090 if (is_static) {
3091 Label is_inline_type;
3092 __ test_field_is_not_null_free_inline_type(flags, noreg /* temp */, is_inline_type);
3093 __ null_check(r0);
3094 __ bind(is_inline_type);
3095 do_oop_store(_masm, field, r0, IN_HEAP);
3096 __ b(Done);
3097 } else {
3098 Label is_inline_type, is_flat, has_null_marker, rewrite_not_inline, rewrite_inline;
3099 __ test_field_is_null_free_inline_type(flags, noreg /*temp*/, is_inline_type);
3100 __ test_field_has_null_marker(flags, noreg /*temp*/, has_null_marker);
3101 // Not an inline type
3102 pop_and_check_object(obj);
3103 // Store into the field
3104 do_oop_store(_masm, field, r0, IN_HEAP);
3105 __ bind(rewrite_not_inline);
3106 if (rc == may_rewrite) {
3107 patch_bytecode(Bytecodes::_fast_aputfield, bc, r19, true, byte_no);
3108 }
3109 __ b(Done);
3110 // Implementation of the inline type semantic
3111 __ bind(is_inline_type);
3112 __ null_check(r0);
3113 __ test_field_is_flat(flags, noreg /*temp*/, is_flat);
3114 // field is not flat
3115 pop_and_check_object(obj);
3116 // Store into the field
3117 do_oop_store(_masm, field, r0, IN_HEAP);
3118 __ b(rewrite_inline);
3119 __ bind(is_flat);
3120 // field is flat
3121 pop_and_check_object(obj);
3122 assert_different_registers(r0, inline_klass, obj, off);
3123 __ load_klass(inline_klass, r0);
3124 __ data_for_oop(r0, r0, inline_klass);
3125 __ add(obj, obj, off);
3126 __ access_value_copy(IN_HEAP, r0, obj, inline_klass);
3127 __ b(rewrite_inline);
3128 __ bind(has_null_marker);
3129 assert_different_registers(r0, cache, r19);
3130 pop_and_check_object(r19);
3131 __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::write_nullable_flat_field), r19, r0, cache);
3132 __ bind(rewrite_inline);
3133 if (rc == may_rewrite) {
3134 patch_bytecode(Bytecodes::_fast_vputfield, bc, r19, true, byte_no);
3135 }
3136 __ b(Done);
3137 }
3138 } // Valhalla
3139 }
3140
3141 __ bind(notObj);
3142 __ cmp(tos_state, (u1)itos);
3143 __ br(Assembler::NE, notInt);
3144
3145 // itos
3146 {
3147 __ pop(itos);
3148 if (!is_static) pop_and_check_object(obj);
3149 __ access_store_at(T_INT, IN_HEAP, field, r0, noreg, noreg, noreg);
3150 if (rc == may_rewrite) {
3151 patch_bytecode(Bytecodes::_fast_iputfield, bc, r1, true, byte_no);
3152 }
3153 __ b(Done);
3154 }
3155
3156 __ bind(notInt);
3157 __ cmp(tos_state, (u1)ctos);
3158 __ br(Assembler::NE, notChar);
3223 {
3224 __ pop(dtos);
3225 if (!is_static) pop_and_check_object(obj);
3226 __ access_store_at(T_DOUBLE, IN_HEAP, field, noreg /* dtos */, noreg, noreg, noreg);
3227 if (rc == may_rewrite) {
3228 patch_bytecode(Bytecodes::_fast_dputfield, bc, r1, true, byte_no);
3229 }
3230 }
3231
3232 #ifdef ASSERT
3233 __ b(Done);
3234
3235 __ bind(notDouble);
3236 __ stop("Bad state");
3237 #endif
3238
3239 __ bind(Done);
3240
3241 {
3242 Label notVolatile;
3243 __ tbz(flags, ResolvedFieldEntry::is_volatile_shift, notVolatile);
3244 __ membar(MacroAssembler::StoreLoad | MacroAssembler::StoreStore);
3245 __ bind(notVolatile);
3246 }
3247 }
3248
3249 void TemplateTable::putfield(int byte_no)
3250 {
3251 putfield_or_static(byte_no, false);
3252 }
3253
3254 void TemplateTable::nofast_putfield(int byte_no) {
3255 putfield_or_static(byte_no, false, may_not_rewrite);
3256 }
3257
3258 void TemplateTable::putstatic(int byte_no) {
3259 putfield_or_static(byte_no, true);
3260 }
3261
3262 void TemplateTable::jvmti_post_fast_field_mod() {
3263 if (JvmtiExport::can_post_field_modification()) {
3264 // Check to see if a field modification watch has been set before
3265 // we take the time to call into the VM.
3266 Label L2;
3267 __ lea(rscratch1, ExternalAddress((address)JvmtiExport::get_field_modification_count_addr()));
3268 __ ldrw(c_rarg3, Address(rscratch1));
3269 __ cbzw(c_rarg3, L2);
3270 __ pop_ptr(r19); // copy the object pointer from tos
3271 __ verify_oop(r19);
3272 __ push_ptr(r19); // put the object pointer back on tos
3273 // Save tos values before call_VM() clobbers them. Since we have
3274 // to do it for every data type, we use the saved values as the
3275 // jvalue object.
3276 switch (bytecode()) { // load values into the jvalue object
3277 case Bytecodes::_fast_vputfield: //fall through
3278 case Bytecodes::_fast_aputfield: __ push_ptr(r0); break;
3279 case Bytecodes::_fast_bputfield: // fall through
3280 case Bytecodes::_fast_zputfield: // fall through
3281 case Bytecodes::_fast_sputfield: // fall through
3282 case Bytecodes::_fast_cputfield: // fall through
3283 case Bytecodes::_fast_iputfield: __ push_i(r0); break;
3284 case Bytecodes::_fast_dputfield: __ push_d(); break;
3285 case Bytecodes::_fast_fputfield: __ push_f(); break;
3286 case Bytecodes::_fast_lputfield: __ push_l(r0); break;
3287
3288 default:
3289 ShouldNotReachHere();
3290 }
3291 __ mov(c_rarg3, esp); // points to jvalue on the stack
3292 // access constant pool cache entry
3293 __ load_field_entry(c_rarg2, r0);
3294 __ verify_oop(r19);
3295 // r19: object pointer copied above
3296 // c_rarg2: cache entry pointer
3297 // c_rarg3: jvalue object on the stack
3298 __ call_VM(noreg,
3299 CAST_FROM_FN_PTR(address,
3300 InterpreterRuntime::post_field_modification),
3301 r19, c_rarg2, c_rarg3);
3302
3303 switch (bytecode()) { // restore tos values
3304 case Bytecodes::_fast_vputfield: //fall through
3305 case Bytecodes::_fast_aputfield: __ pop_ptr(r0); break;
3306 case Bytecodes::_fast_bputfield: // fall through
3307 case Bytecodes::_fast_zputfield: // fall through
3308 case Bytecodes::_fast_sputfield: // fall through
3309 case Bytecodes::_fast_cputfield: // fall through
3310 case Bytecodes::_fast_iputfield: __ pop_i(r0); break;
3311 case Bytecodes::_fast_dputfield: __ pop_d(); break;
3312 case Bytecodes::_fast_fputfield: __ pop_f(); break;
3313 case Bytecodes::_fast_lputfield: __ pop_l(r0); break;
3314 default: break;
3315 }
3316 __ bind(L2);
3317 }
3318 }
3319
3320 void TemplateTable::fast_storefield(TosState state)
3321 {
3322 transition(state, vtos);
3323
3324 ByteSize base = ConstantPoolCache::base_offset();
3335 // Must prevent reordering of the following cp cache loads with bytecode load
3336 __ membar(MacroAssembler::LoadLoad);
3337
3338 {
3339 Label notVolatile;
3340 __ tbz(r3, ResolvedFieldEntry::is_volatile_shift, notVolatile);
3341 __ membar(MacroAssembler::StoreStore | MacroAssembler::LoadStore);
3342 __ bind(notVolatile);
3343 }
3344
3345 Label notVolatile;
3346
3347 // Get object from stack
3348 pop_and_check_object(r2);
3349
3350 // field address
3351 const Address field(r2, r1);
3352
3353 // access field
3354 switch (bytecode()) {
3355 case Bytecodes::_fast_vputfield:
3356 {
3357 Label is_flat, has_null_marker, done;
3358 __ test_field_has_null_marker(r3, noreg /* temp */, has_null_marker);
3359 __ null_check(r0);
3360 __ test_field_is_flat(r3, noreg /* temp */, is_flat);
3361 // field is not flat
3362 do_oop_store(_masm, field, r0, IN_HEAP);
3363 __ b(done);
3364 __ bind(is_flat);
3365 // field is flat
3366 __ load_klass(r4, r0);
3367 __ data_for_oop(r0, r0, r4);
3368 __ lea(rscratch1, field);
3369 __ access_value_copy(IN_HEAP, r0, rscratch1, r4);
3370 __ b(done);
3371 __ bind(has_null_marker);
3372 __ load_field_entry(r4, r1);
3373 __ mov(r1, r2);
3374 __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::write_nullable_flat_field), r1, r0, r4);
3375 __ bind(done);
3376 }
3377 break;
3378 case Bytecodes::_fast_aputfield:
3379 do_oop_store(_masm, field, r0, IN_HEAP);
3380 break;
3381 case Bytecodes::_fast_lputfield:
3382 __ access_store_at(T_LONG, IN_HEAP, field, r0, noreg, noreg, noreg);
3383 break;
3384 case Bytecodes::_fast_iputfield:
3385 __ access_store_at(T_INT, IN_HEAP, field, r0, noreg, noreg, noreg);
3386 break;
3387 case Bytecodes::_fast_zputfield:
3388 __ access_store_at(T_BOOLEAN, IN_HEAP, field, r0, noreg, noreg, noreg);
3389 break;
3390 case Bytecodes::_fast_bputfield:
3391 __ access_store_at(T_BYTE, IN_HEAP, field, r0, noreg, noreg, noreg);
3392 break;
3393 case Bytecodes::_fast_sputfield:
3394 __ access_store_at(T_SHORT, IN_HEAP, field, r0, noreg, noreg, noreg);
3395 break;
3396 case Bytecodes::_fast_cputfield:
3397 __ access_store_at(T_CHAR, IN_HEAP, field, r0, noreg, noreg, noreg);
3453 // r0: object
3454 __ verify_oop(r0);
3455 __ null_check(r0);
3456 const Address field(r0, r1);
3457
3458 // 8179954: We need to make sure that the code generated for
3459 // volatile accesses forms a sequentially-consistent set of
3460 // operations when combined with STLR and LDAR. Without a leading
3461 // membar it's possible for a simple Dekker test to fail if loads
3462 // use LDR;DMB but stores use STLR. This can happen if C2 compiles
3463 // the stores in one method and we interpret the loads in another.
3464 if (!CompilerConfig::is_c1_or_interpreter_only_no_jvmci()) {
3465 Label notVolatile;
3466 __ tbz(r3, ResolvedFieldEntry::is_volatile_shift, notVolatile);
3467 __ membar(MacroAssembler::AnyAny);
3468 __ bind(notVolatile);
3469 }
3470
3471 // access field
3472 switch (bytecode()) {
3473 case Bytecodes::_fast_vgetfield:
3474 {
3475 Register index = r4, klass = r5, inline_klass = r6, tmp = r7;
3476 Label is_flat, has_null_marker, nonnull, Done;
3477 __ test_field_has_null_marker(r3, noreg /*temp*/, has_null_marker);
3478 __ test_field_is_flat(r3, noreg /* temp */, is_flat);
3479 // field is not flat
3480 __ load_heap_oop(r0, field, rscratch1, rscratch2);
3481 __ cbnz(r0, nonnull);
3482 __ load_unsigned_short(index, Address(r2, in_bytes(ResolvedFieldEntry::field_index_offset())));
3483 __ ldr(klass, Address(r2, in_bytes(ResolvedFieldEntry::field_holder_offset())));
3484 __ get_inline_type_field_klass(klass, index, inline_klass);
3485 __ get_default_value_oop(inline_klass, tmp /* temp */, r0);
3486 __ bind(nonnull);
3487 __ verify_oop(r0);
3488 __ b(Done);
3489 __ bind(is_flat);
3490 // field is flat
3491 __ load_unsigned_short(index, Address(r2, in_bytes(ResolvedFieldEntry::field_index_offset())));
3492 __ ldr(klass, Address(r2, in_bytes(ResolvedFieldEntry::field_holder_offset())));
3493 __ read_flat_field(klass, index, r1, tmp /* temp */, r0);
3494 __ verify_oop(r0);
3495 __ b(Done);
3496 __ bind(has_null_marker);
3497 call_VM(r0, CAST_FROM_FN_PTR(address, InterpreterRuntime::read_nullable_flat_field), r0, r2);
3498 __ verify_oop(r0);
3499 __ bind(Done);
3500 }
3501 break;
3502 case Bytecodes::_fast_agetfield:
3503 do_oop_load(_masm, field, r0, IN_HEAP);
3504 __ verify_oop(r0);
3505 break;
3506 case Bytecodes::_fast_lgetfield:
3507 __ access_load_at(T_LONG, IN_HEAP, r0, field, noreg, noreg);
3508 break;
3509 case Bytecodes::_fast_igetfield:
3510 __ access_load_at(T_INT, IN_HEAP, r0, field, noreg, noreg);
3511 break;
3512 case Bytecodes::_fast_bgetfield:
3513 __ access_load_at(T_BYTE, IN_HEAP, r0, field, noreg, noreg);
3514 break;
3515 case Bytecodes::_fast_sgetfield:
3516 __ access_load_at(T_SHORT, IN_HEAP, r0, field, noreg, noreg);
3517 break;
3518 case Bytecodes::_fast_cgetfield:
3519 __ access_load_at(T_CHAR, IN_HEAP, r0, field, noreg, noreg);
3520 break;
3521 case Bytecodes::_fast_fgetfield:
3900 Label initialize_header;
3901
3902 __ get_cpool_and_tags(r4, r0);
3903 // Make sure the class we're about to instantiate has been resolved.
3904 // This is done before loading InstanceKlass to be consistent with the order
3905 // how Constant Pool is updated (see ConstantPool::klass_at_put)
3906 const int tags_offset = Array<u1>::base_offset_in_bytes();
3907 __ lea(rscratch1, Address(r0, r3, Address::lsl(0)));
3908 __ lea(rscratch1, Address(rscratch1, tags_offset));
3909 __ ldarb(rscratch1, rscratch1);
3910 __ cmp(rscratch1, (u1)JVM_CONSTANT_Class);
3911 __ br(Assembler::NE, slow_case);
3912
3913 // get InstanceKlass
3914 __ load_resolved_klass_at_offset(r4, r3, r4, rscratch1);
3915
3916 // make sure klass is initialized
3917 assert(VM_Version::supports_fast_class_init_checks(), "Optimization requires support for fast class initialization checks");
3918 __ clinit_barrier(r4, rscratch1, nullptr /*L_fast_path*/, &slow_case);
3919
3920 __ allocate_instance(r4, r0, r3, r1, true, slow_case);
3921 __ b(done);
3922
3923 // slow case
3924 __ bind(slow_case);
3925 __ get_constant_pool(c_rarg1);
3926 __ get_unsigned_2_byte_index_at_bcp(c_rarg2, 1);
3927 call_VM(r0, CAST_FROM_FN_PTR(address, InterpreterRuntime::_new), c_rarg1, c_rarg2);
3928 __ verify_oop(r0);
3929
3930 // continue
3931 __ bind(done);
3932 // Must prevent reordering of stores for object initialization with stores that publish the new object.
3933 __ membar(Assembler::StoreStore);
3934 }
3935
3936 void TemplateTable::newarray() {
3937 transition(itos, atos);
3938 __ load_unsigned_byte(c_rarg1, at_bcp(1));
3939 __ mov(c_rarg2, r0);
3940 call_VM(r0, CAST_FROM_FN_PTR(address, InterpreterRuntime::newarray),
3941 c_rarg1, c_rarg2);
3986 __ bind(quicked);
3987 __ mov(r3, r0); // Save object in r3; r0 needed for subtype check
3988 __ load_resolved_klass_at_offset(r2, r19, r0, rscratch1); // r0 = klass
3989
3990 __ bind(resolved);
3991 __ load_klass(r19, r3);
3992
3993 // Generate subtype check. Blows r2, r5. Object in r3.
3994 // Superklass in r0. Subklass in r19.
3995 __ gen_subtype_check(r19, ok_is_subtype);
3996
3997 // Come here on failure
3998 __ push(r3);
3999 // object is at TOS
4000 __ b(Interpreter::_throw_ClassCastException_entry);
4001
4002 // Come here on success
4003 __ bind(ok_is_subtype);
4004 __ mov(r0, r3); // Restore object in r3
4005
4006 __ b(done);
4007 __ bind(is_null);
4008
4009 // Collect counts on whether this test sees nulls a lot or not.
4010 if (ProfileInterpreter) {
4011 __ profile_null_seen(r2);
4012 }
4013
4014 __ bind(done);
4015 }
4016
4017 void TemplateTable::instanceof() {
4018 transition(atos, itos);
4019 Label done, is_null, ok_is_subtype, quicked, resolved;
4020 __ cbz(r0, is_null);
4021
4022 // Get cpool & tags index
4023 __ get_cpool_and_tags(r2, r3); // r2=cpool, r3=tags array
4024 __ get_unsigned_2_byte_index_at_bcp(r19, 1); // r19=index
4025 // See if bytecode has already been quicked
4026 __ add(rscratch1, r3, Array<u1>::base_offset_in_bytes());
4027 __ lea(r1, Address(rscratch1, r19));
4028 __ ldarb(r1, r1);
4029 __ cmp(r1, (u1)JVM_CONSTANT_Class);
4030 __ br(Assembler::EQ, quicked);
4031
4032 __ push(atos); // save receiver for result, and for GC
4033 call_VM(r0, CAST_FROM_FN_PTR(address, InterpreterRuntime::quicken_io_cc));
4112 // in the assembly code structure as well
4113 //
4114 // Stack layout:
4115 //
4116 // [expressions ] <--- esp = expression stack top
4117 // ..
4118 // [expressions ]
4119 // [monitor entry] <--- monitor block top = expression stack bot
4120 // ..
4121 // [monitor entry]
4122 // [frame data ] <--- monitor block bot
4123 // ...
4124 // [saved rfp ] <--- rfp
4125 void TemplateTable::monitorenter()
4126 {
4127 transition(atos, vtos);
4128
4129 // check for null object
4130 __ null_check(r0);
4131
4132 Label is_inline_type;
4133 __ ldr(rscratch1, Address(r0, oopDesc::mark_offset_in_bytes()));
4134 __ test_markword_is_inline_type(rscratch1, is_inline_type);
4135
4136 const Address monitor_block_top(
4137 rfp, frame::interpreter_frame_monitor_block_top_offset * wordSize);
4138 const Address monitor_block_bot(
4139 rfp, frame::interpreter_frame_initial_sp_offset * wordSize);
4140 const int entry_size = frame::interpreter_frame_monitor_size_in_bytes();
4141
4142 Label allocated;
4143
4144 // initialize entry pointer
4145 __ mov(c_rarg1, zr); // points to free slot or null
4146
4147 // find a free slot in the monitor block (result in c_rarg1)
4148 {
4149 Label entry, loop, exit;
4150 __ ldr(c_rarg3, monitor_block_top); // derelativize pointer
4151 __ lea(c_rarg3, Address(rfp, c_rarg3, Address::lsl(Interpreter::logStackElementSize)));
4152 // c_rarg3 points to current entry, starting with top-most entry
4153
4154 __ lea(c_rarg2, monitor_block_bot); // points to word before bottom
4155
4217 // c_rarg1: points to monitor entry
4218 __ bind(allocated);
4219
4220 // Increment bcp to point to the next bytecode, so exception
4221 // handling for async. exceptions work correctly.
4222 // The object has already been popped from the stack, so the
4223 // expression stack looks correct.
4224 __ increment(rbcp);
4225
4226 // store object
4227 __ str(r0, Address(c_rarg1, BasicObjectLock::obj_offset()));
4228 __ lock_object(c_rarg1);
4229
4230 // check to make sure this monitor doesn't cause stack overflow after locking
4231 __ save_bcp(); // in case of exception
4232 __ generate_stack_overflow_check(0);
4233
4234 // The bcp has already been incremented. Just need to dispatch to
4235 // next instruction.
4236 __ dispatch_next(vtos);
4237
4238 __ bind(is_inline_type);
4239 __ call_VM(noreg, CAST_FROM_FN_PTR(address,
4240 InterpreterRuntime::throw_identity_exception), r0);
4241 __ should_not_reach_here();
4242 }
4243
4244
4245 void TemplateTable::monitorexit()
4246 {
4247 transition(atos, vtos);
4248
4249 // check for null object
4250 __ null_check(r0);
4251
4252 const int is_inline_type_mask = markWord::inline_type_pattern;
4253 Label has_identity;
4254 __ ldr(rscratch1, Address(r0, oopDesc::mark_offset_in_bytes()));
4255 __ mov(rscratch2, is_inline_type_mask);
4256 __ andr(rscratch1, rscratch1, rscratch2);
4257 __ cmp(rscratch1, rscratch2);
4258 __ br(Assembler::NE, has_identity);
4259 __ call_VM(noreg, CAST_FROM_FN_PTR(address,
4260 InterpreterRuntime::throw_illegal_monitor_state_exception));
4261 __ should_not_reach_here();
4262 __ bind(has_identity);
4263
4264 const Address monitor_block_top(
4265 rfp, frame::interpreter_frame_monitor_block_top_offset * wordSize);
4266 const Address monitor_block_bot(
4267 rfp, frame::interpreter_frame_initial_sp_offset * wordSize);
4268 const int entry_size = frame::interpreter_frame_monitor_size_in_bytes();
4269
4270 Label found;
4271
4272 // find matching slot
4273 {
4274 Label entry, loop;
4275 __ ldr(c_rarg1, monitor_block_top); // derelativize pointer
4276 __ lea(c_rarg1, Address(rfp, c_rarg1, Address::lsl(Interpreter::logStackElementSize)));
4277 // c_rarg1 points to current entry, starting with top-most entry
4278
4279 __ lea(c_rarg2, monitor_block_bot); // points to word before bottom
4280 // of monitor block
4281 __ b(entry);
4282
4283 __ bind(loop);
|