motorhead/qemu
1
0
Fork 0
mirror of https://github.com/Motorhead1991/qemu.git synced 2025-08-03 07:43:54 -06:00
Code Issues Projects Releases Packages Wiki Activity Actions

target/arm: Load/store integer pair with one tcg operation

Browse source 
This is required for LSE2, where the pair must be treated atomically if
it does not cross a 16-byte boundary.  But it simplifies the code to do
this always.

Reviewed-by: Peter Maydell <peter.maydell@linaro.org>
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
Message-id: 20230530191438.411344-10-richard.henderson@linaro.org
Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
This commit is contained in:
Richard Henderson 2023-06-06 10:19:36 +01:00 • committed by Peter Maydell
parent 5c13983e23
commit 6f47e7c189
1 changed files with 55 additions and 15 deletions
Download patch file Download diff file Expand all files Collapse all files

70
target/arm/tcg/translate-a64.c
View file

@ -2942,26 +2942,66 @@ static void disas_ldst_pair(DisasContext *s, uint32_t insn)
} else { } else {
TCGv_i64 tcg_rt = cpu_reg(s, rt); TCGv_i64 tcg_rt = cpu_reg(s, rt);
TCGv_i64 tcg_rt2 = cpu_reg(s, rt2); TCGv_i64 tcg_rt2 = cpu_reg(s, rt2);
MemOp mop = size + 1;
/*
* With LSE2, non-sign-extending pairs are treated atomically if
* aligned, and if unaligned one of the pair will be completely
* within a 16-byte block and that element will be atomic.
* Otherwise each element is separately atomic.
* In all cases, issue one operation with the correct atomicity.
*
* This treats sign-extending loads like zero-extending loads,
* since that reuses the most code below.
*/
if (s->align_mem) {
mop |= (size == 2 ? MO_ALIGN_4 : MO_ALIGN_8);
}
mop = finalize_memop_pair(s, mop);
if (is_load) { if (is_load) {
TCGv_i64 tmp = tcg_temp_new_i64(); if (size == 2) {
int o2 = s->be_data == MO_LE ? 32 : 0;
int o1 = o2 ^ 32;
/* Do not modify tcg_rt before recognizing any exception tcg_gen_qemu_ld_i64(tcg_rt, clean_addr, get_mem_index(s), mop);
* from the second load. if (is_signed) {
*/ tcg_gen_sextract_i64(tcg_rt2, tcg_rt, o2, 32);
do_gpr_ld(s, tmp, clean_addr, size + is_signed * MO_SIGN, tcg_gen_sextract_i64(tcg_rt, tcg_rt, o1, 32);
false, false, 0, false, false); } else {
tcg_gen_addi_i64(clean_addr, clean_addr, 1 << size); tcg_gen_extract_i64(tcg_rt2, tcg_rt, o2, 32);
do_gpr_ld(s, tcg_rt2, clean_addr, size + is_signed * MO_SIGN, tcg_gen_extract_i64(tcg_rt, tcg_rt, o1, 32);
false, false, 0, false, false); }
} else {
TCGv_i128 tmp = tcg_temp_new_i128();
tcg_gen_mov_i64(tcg_rt, tmp); tcg_gen_qemu_ld_i128(tmp, clean_addr, get_mem_index(s), mop);
if (s->be_data == MO_LE) {
tcg_gen_extr_i128_i64(tcg_rt, tcg_rt2, tmp);
} else {
tcg_gen_extr_i128_i64(tcg_rt2, tcg_rt, tmp);
}
}
} else { } else {
do_gpr_st(s, tcg_rt, clean_addr, size, if (size == 2) {
false, 0, false, false); TCGv_i64 tmp = tcg_temp_new_i64();
tcg_gen_addi_i64(clean_addr, clean_addr, 1 << size);
do_gpr_st(s, tcg_rt2, clean_addr, size, if (s->be_data == MO_LE) {
false, 0, false, false); tcg_gen_concat32_i64(tmp, tcg_rt, tcg_rt2);
} else {
tcg_gen_concat32_i64(tmp, tcg_rt2, tcg_rt);
}
tcg_gen_qemu_st_i64(tmp, clean_addr, get_mem_index(s), mop);
} else {
TCGv_i128 tmp = tcg_temp_new_i128();
if (s->be_data == MO_LE) {
tcg_gen_concat_i64_i128(tmp, tcg_rt, tcg_rt2);
} else {
tcg_gen_concat_i64_i128(tmp, tcg_rt2, tcg_rt);
}
tcg_gen_qemu_st_i128(tmp, clean_addr, get_mem_index(s), mop);
}
} }
} }