805 Address(rdx, rax,
806 Address::times_4,
807 arrayOopDesc::base_offset_in_bytes(T_FLOAT)),
808 noreg, noreg);
809 }
810
811 void TemplateTable::daload() {
812 transition(itos, dtos);
813 // rax: index
814 // rdx: array
815 index_check(rdx, rax); // kills rbx
816 __ access_load_at(T_DOUBLE, IN_HEAP | IS_ARRAY, noreg /* dtos */,
817 Address(rdx, rax,
818 Address::times_8,
819 arrayOopDesc::base_offset_in_bytes(T_DOUBLE)),
820 noreg, noreg);
821 }
822
823 void TemplateTable::aaload() {
824 transition(itos, atos);
825
826 Register array = rcx;
827 Register index = rax;
828
829 index_check(array, index); // kills rbx
830
831 __ profile_array(rbx, array, rdx);
832
833 if (ValueArrayFlatten) {
834 Label is_flat_array, done;
835 __ test_flattened_array_oop(array, rbx, is_flat_array);
836 do_oop_load(_masm,
837 Address(array, index,
838 UseCompressedOops ? Address::times_4 : Address::times_ptr,
839 arrayOopDesc::base_offset_in_bytes(T_OBJECT)),
840 rax,
841 IS_ARRAY);
842 __ jmp(done);
843 __ bind(is_flat_array);
844 __ call_VM(rax, CAST_FROM_FN_PTR(address, InterpreterRuntime::value_array_load), array, index);
845 __ bind(done);
846 } else {
847 do_oop_load(_masm,
848 Address(array, index,
849 UseCompressedOops ? Address::times_4 : Address::times_ptr,
850 arrayOopDesc::base_offset_in_bytes(T_OBJECT)),
851 rax,
852 IS_ARRAY);
853 }
854
855 __ profile_element(rbx, rax, rdx);
856 }
857
858 void TemplateTable::baload() {
859 transition(itos, itos);
860 // rax: index
861 // rdx: array
862 index_check(rdx, rax); // kills rbx
863 __ access_load_at(T_BYTE, IN_HEAP | IS_ARRAY, rax,
864 Address(rdx, rax, Address::times_1, arrayOopDesc::base_offset_in_bytes(T_BYTE)),
865 noreg, noreg);
866 }
867
868 void TemplateTable::caload() {
869 transition(itos, itos);
870 // rax: index
871 // rdx: array
872 index_check(rdx, rax); // kills rbx
873 __ access_load_at(T_CHAR, IN_HEAP | IS_ARRAY, rax,
874 Address(rdx, rax, Address::times_2, arrayOopDesc::base_offset_in_bytes(T_CHAR)),
875 noreg, noreg);
1207 __ jmp(done);
1208
1209 if (EnableValhalla) {
1210 Label is_type_ok;
1211 __ bind(is_flat_array); // Store non-null value to flat
1212
1213 // Simplistic type check...
1214
1215 // Profile the not-null value's klass.
1216 __ load_klass(rbx, rax);
1217 // Move element klass into rax
1218 __ movptr(rax, Address(rdi, ArrayKlass::element_klass_offset()));
1219 // flat value array needs exact type match
1220 // is "rax == rbx" (value subclass == array element superclass)
1221 __ cmpptr(rax, rbx);
1222 __ jccb(Assembler::equal, is_type_ok);
1223
1224 __ jump(ExternalAddress(Interpreter::_throw_ArrayStoreException_entry));
1225
1226 __ bind(is_type_ok);
1227 __ movptr(rax, at_tos()); // value
1228 __ movl(rcx, at_tos_p1()); // index
1229 __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::value_array_store), rax, rdx, rcx);
1230 }
1231 // Pop stack arguments
1232 __ bind(done);
1233 __ addptr(rsp, 3 * Interpreter::stackElementSize);
1234 }
1235
1236 void TemplateTable::bastore() {
1237 transition(itos, vtos);
1238 __ pop_i(rbx);
1239 // rax: value
1240 // rbx: index
1241 // rdx: array
1242 index_check(rdx, rbx); // prefer index in rbx
1243 // Need to check whether array is boolean or byte
1244 // since both types share the bastore bytecode.
1245 __ load_klass(rcx, rdx);
1246 __ movl(rcx, Address(rcx, Klass::layout_helper_offset()));
1247 int diffbit = Klass::layout_helper_boolean_diffbit();
1248 __ testl(rcx, diffbit);
1249 Label L_skip;
|
805 Address(rdx, rax,
806 Address::times_4,
807 arrayOopDesc::base_offset_in_bytes(T_FLOAT)),
808 noreg, noreg);
809 }
810
811 void TemplateTable::daload() {
812 transition(itos, dtos);
813 // rax: index
814 // rdx: array
815 index_check(rdx, rax); // kills rbx
816 __ access_load_at(T_DOUBLE, IN_HEAP | IS_ARRAY, noreg /* dtos */,
817 Address(rdx, rax,
818 Address::times_8,
819 arrayOopDesc::base_offset_in_bytes(T_DOUBLE)),
820 noreg, noreg);
821 }
822
823 void TemplateTable::aaload() {
824 transition(itos, atos);
825 Register array = rdx;
826 Register index = rax;
827
828 index_check(array, index); // kills rbx
829 __ profile_array(rbx, array, rcx);
830 if (ValueArrayFlatten) {
831 Label is_flat_array, done;
832 __ test_flattened_array_oop(array, rbx, is_flat_array);
833 do_oop_load(_masm,
834 Address(array, index,
835 UseCompressedOops ? Address::times_4 : Address::times_ptr,
836 arrayOopDesc::base_offset_in_bytes(T_OBJECT)),
837 rax,
838 IS_ARRAY);
839 __ jmp(done);
840 __ bind(is_flat_array);
841 __ read_flattened_element(array, index, rbx, rcx, rax);
842 __ bind(done);
843 } else {
844 do_oop_load(_masm,
845 Address(array, index,
846 UseCompressedOops ? Address::times_4 : Address::times_ptr,
847 arrayOopDesc::base_offset_in_bytes(T_OBJECT)),
848 rax,
849 IS_ARRAY);
850 }
851 __ profile_element(rbx, rax, rcx);
852 }
853
854 void TemplateTable::baload() {
855 transition(itos, itos);
856 // rax: index
857 // rdx: array
858 index_check(rdx, rax); // kills rbx
859 __ access_load_at(T_BYTE, IN_HEAP | IS_ARRAY, rax,
860 Address(rdx, rax, Address::times_1, arrayOopDesc::base_offset_in_bytes(T_BYTE)),
861 noreg, noreg);
862 }
863
864 void TemplateTable::caload() {
865 transition(itos, itos);
866 // rax: index
867 // rdx: array
868 index_check(rdx, rax); // kills rbx
869 __ access_load_at(T_CHAR, IN_HEAP | IS_ARRAY, rax,
870 Address(rdx, rax, Address::times_2, arrayOopDesc::base_offset_in_bytes(T_CHAR)),
871 noreg, noreg);
1203 __ jmp(done);
1204
1205 if (EnableValhalla) {
1206 Label is_type_ok;
1207 __ bind(is_flat_array); // Store non-null value to flat
1208
1209 // Simplistic type check...
1210
1211 // Profile the not-null value's klass.
1212 __ load_klass(rbx, rax);
1213 // Move element klass into rax
1214 __ movptr(rax, Address(rdi, ArrayKlass::element_klass_offset()));
1215 // flat value array needs exact type match
1216 // is "rax == rbx" (value subclass == array element superclass)
1217 __ cmpptr(rax, rbx);
1218 __ jccb(Assembler::equal, is_type_ok);
1219
1220 __ jump(ExternalAddress(Interpreter::_throw_ArrayStoreException_entry));
1221
1222 __ bind(is_type_ok);
1223 // rbx: value's klass
1224 // rdx: array
1225 // rdi: array klass
1226 __ test_klass_is_empty_value(rbx, rax, done);
1227
1228 // calc dst for copy
1229 __ movl(rax, at_tos_p1()); // index
1230 __ data_for_value_array_index(rdx, rdi, rax, rax);
1231
1232 // ...and src for copy
1233 __ movptr(rcx, at_tos()); // value
1234 __ data_for_oop(rcx, rcx, rbx);
1235
1236 __ access_value_copy(IN_HEAP, rcx, rax, rbx);
1237 }
1238 // Pop stack arguments
1239 __ bind(done);
1240 __ addptr(rsp, 3 * Interpreter::stackElementSize);
1241 }
1242
1243 void TemplateTable::bastore() {
1244 transition(itos, vtos);
1245 __ pop_i(rbx);
1246 // rax: value
1247 // rbx: index
1248 // rdx: array
1249 index_check(rdx, rbx); // prefer index in rbx
1250 // Need to check whether array is boolean or byte
1251 // since both types share the bastore bytecode.
1252 __ load_klass(rcx, rdx);
1253 __ movl(rcx, Address(rcx, Klass::layout_helper_offset()));
1254 int diffbit = Klass::layout_helper_boolean_diffbit();
1255 __ testl(rcx, diffbit);
1256 Label L_skip;
|