Skip to contentSkip to conversation

target/microblaze/translate: fix reversed load/store translation

PATCH In review Philippe Mathieu-Daudé 2 participants 13 messages Jul 22 – Jul 23

lore
Share & tools
lore
#0 lore raw

v2 cover target/microblaze/translate: fix reversed load/store translation

Verbose respin of Luc's v1, but refactoring common code with TRANS() macro during review process.

Good diff-stat.

v1: <[email protected]>

Luc Michel (1):
target/microblaze/translate: fix reversed load/store translation

Philippe Mathieu-Daudé (6):
target/microblaze: Set MO_BSWAP in do_load/do_store callers target/microblaze: Use TRANS() macro for typeB load/store opcodes target/microblaze: Use TRANS() macro for typeA load/store opcodes target/microblaze: Set MO_ENDIAN in do_load/do_store callers target/microblaze: Introduce local MemOp variable in LWX/SWX opcodes target/microblaze: Factor reverse_ldst_addr() helper out

 target/microblaze/translate.c | 224 ++++++++++++----------------------
 1 file changed, 79 insertions(+), 145 deletions(-)
Signature · 1 line
2.53.0
#1 lore raw

PATCH v2 1/7 target/microblaze: Set MO_BSWAP in do_load/do_store callers

Instead of setting the MO_BSWAP bit in the do_load/do_store helpers depending on a @rev boolean argument, set it on the callers in the MemOp argument. The repeated caller pattern will allow further simplifications in the next commit.

---
 target/microblaze/translate.c | 62 +++++++++++++++--------------------
 1 file changed, 26 insertions(+), 36 deletions(-)
target/microblaze/translate.c +26 -36
index 8b219afb5dd..623980d0af5 100644
@@ -704,22 +704,17 @@ static inline MemOp mo_endian(DisasContext *dc)
 }
 
 static bool do_load(DisasContext *dc, int rd, TCGv_i32 addr, MemOp mop,
-                    int mem_index, bool rev)
+                    int mem_index)
 {
     MemOp size = mop & MO_SIZE;
 
     mop |= mo_endian(dc);
 
     /*
-     * When doing reverse accesses we need to do two things.
-     *
-     * 1. Reverse the address wrt endianness.
-     * 2. Byteswap the data lanes on the way back into the CPU core.
+     * When doing reverse accesses we need to byteswap the data
+     * lanes on the way back into the CPU core.
      */
-    if (rev) {
-        if (size > MO_8) {
-            mop ^= MO_BSWAP;
-        }
+    if (mop & MO_BSWAP) {
         if (size < MO_32) {
             tcg_gen_xori_i32(addr, addr, 3 - size);
         }
@@ -746,13 +741,13 @@ static bool do_load(DisasContext *dc, int rd, TCGv_i32 addr, MemOp mop,
 static bool trans_lbu(DisasContext *dc, arg_typea *arg)
 {
     TCGv_i32 addr = compute_ldst_addr_typea(dc, arg->ra, arg->rb);
-    return do_load(dc, arg->rd, addr, MO_UB, dc->mem_index, false);
+    return do_load(dc, arg->rd, addr, MO_UB, dc->mem_index);
 }
 
 static bool trans_lbur(DisasContext *dc, arg_typea *arg)
 {
     TCGv_i32 addr = compute_ldst_addr_typea(dc, arg->ra, arg->rb);
-    return do_load(dc, arg->rd, addr, MO_UB, dc->mem_index, true);
+    return do_load(dc, arg->rd, addr, MO_UB ^ MO_BSWAP, dc->mem_index);
 }
 
 static bool trans_lbuea(DisasContext *dc, arg_typea *arg)
@@ -772,19 +767,19 @@ static bool trans_lbuea(DisasContext *dc, arg_typea *arg)
 static bool trans_lbui(DisasContext *dc, arg_typeb *arg)
 {
     TCGv_i32 addr = compute_ldst_addr_typeb(dc, arg->ra, arg->imm);
-    return do_load(dc, arg->rd, addr, MO_UB, dc->mem_index, false);
+    return do_load(dc, arg->rd, addr, MO_UB, dc->mem_index);
 }
 
 static bool trans_lhu(DisasContext *dc, arg_typea *arg)
 {
     TCGv_i32 addr = compute_ldst_addr_typea(dc, arg->ra, arg->rb);
-    return do_load(dc, arg->rd, addr, MO_UW, dc->mem_index, false);
+    return do_load(dc, arg->rd, addr, MO_UW, dc->mem_index);
 }
 
 static bool trans_lhur(DisasContext *dc, arg_typea *arg)
 {
     TCGv_i32 addr = compute_ldst_addr_typea(dc, arg->ra, arg->rb);
-    return do_load(dc, arg->rd, addr, MO_UW, dc->mem_index, true);
+    return do_load(dc, arg->rd, addr, MO_UW ^ MO_BSWAP, dc->mem_index);
 }
 
 static bool trans_lhuea(DisasContext *dc, arg_typea *arg)
@@ -806,19 +801,19 @@ static bool trans_lhuea(DisasContext *dc, arg_typea *arg)
 static bool trans_lhui(DisasContext *dc, arg_typeb *arg)
 {
     TCGv_i32 addr = compute_ldst_addr_typeb(dc, arg->ra, arg->imm);
-    return do_load(dc, arg->rd, addr, MO_UW, dc->mem_index, false);
+    return do_load(dc, arg->rd, addr, MO_UW, dc->mem_index);
 }
 
 static bool trans_lw(DisasContext *dc, arg_typea *arg)
 {
     TCGv_i32 addr = compute_ldst_addr_typea(dc, arg->ra, arg->rb);
-    return do_load(dc, arg->rd, addr, MO_UL, dc->mem_index, false);
+    return do_load(dc, arg->rd, addr, MO_UL, dc->mem_index);
 }
 
 static bool trans_lwr(DisasContext *dc, arg_typea *arg)
 {
     TCGv_i32 addr = compute_ldst_addr_typea(dc, arg->ra, arg->rb);
-    return do_load(dc, arg->rd, addr, MO_UL, dc->mem_index, true);
+    return do_load(dc, arg->rd, addr, MO_UL ^ MO_BSWAP, dc->mem_index);
 }
 
 static bool trans_lwea(DisasContext *dc, arg_typea *arg)
@@ -840,7 +835,7 @@ static bool trans_lwea(DisasContext *dc, arg_typea *arg)
 static bool trans_lwi(DisasContext *dc, arg_typeb *arg)
 {
     TCGv_i32 addr = compute_ldst_addr_typeb(dc, arg->ra, arg->imm);
-    return do_load(dc, arg->rd, addr, MO_UL, dc->mem_index, false);
+    return do_load(dc, arg->rd, addr, MO_UL, dc->mem_index);
 }
 
 static bool trans_lwx(DisasContext *dc, arg_typea *arg)
@@ -864,22 +859,17 @@ static bool trans_lwx(DisasContext *dc, arg_typea *arg)
 }
 
 static bool do_store(DisasContext *dc, int rd, TCGv_i32 addr, MemOp mop,
-                     int mem_index, bool rev)
+                     int mem_index)
 {
     MemOp size = mop & MO_SIZE;
 
     mop |= mo_endian(dc);
 
     /*
-     * When doing reverse accesses we need to do two things.
-     *
-     * 1. Reverse the address wrt endianness.
-     * 2. Byteswap the data lanes on the way back into the CPU core.
+     * When doing reverse accesses we need to byteswap the data
+     * lanes on the way back into the CPU core.
      */
-    if (rev) {
-        if (size > MO_8) {
-            mop ^= MO_BSWAP;
-        }
+    if (mop & MO_BSWAP) {
         if (size < MO_32) {
             tcg_gen_xori_i32(addr, addr, 3 - size);
         }
@@ -906,13 +896,13 @@ static bool do_store(DisasContext *dc, int rd, TCGv_i32 addr, MemOp mop,
 static bool trans_sb(DisasContext *dc, arg_typea *arg)
 {
     TCGv_i32 addr = compute_ldst_addr_typea(dc, arg->ra, arg->rb);
-    return do_store(dc, arg->rd, addr, MO_UB, dc->mem_index, false);
+    return do_store(dc, arg->rd, addr, MO_UB, dc->mem_index);
 }
 
 static bool trans_sbr(DisasContext *dc, arg_typea *arg)
 {
     TCGv_i32 addr = compute_ldst_addr_typea(dc, arg->ra, arg->rb);
-    return do_store(dc, arg->rd, addr, MO_UB, dc->mem_index, true);
+    return do_store(dc, arg->rd, addr, MO_UB ^ MO_BSWAP, dc->mem_index);
 }
 
 static bool trans_sbea(DisasContext *dc, arg_typea *arg)
@@ -932,19 +922,19 @@ static bool trans_sbea(DisasContext *dc, arg_typea *arg)
 static bool trans_sbi(DisasContext *dc, arg_typeb *arg)
 {
     TCGv_i32 addr = compute_ldst_addr_typeb(dc, arg->ra, arg->imm);
-    return do_store(dc, arg->rd, addr, MO_UB, dc->mem_index, false);
+    return do_store(dc, arg->rd, addr, MO_UB, dc->mem_index);
 }
 
 static bool trans_sh(DisasContext *dc, arg_typea *arg)
 {
     TCGv_i32 addr = compute_ldst_addr_typea(dc, arg->ra, arg->rb);
-    return do_store(dc, arg->rd, addr, MO_UW, dc->mem_index, false);
+    return do_store(dc, arg->rd, addr, MO_UW, dc->mem_index);
 }
 
 static bool trans_shr(DisasContext *dc, arg_typea *arg)
 {
     TCGv_i32 addr = compute_ldst_addr_typea(dc, arg->ra, arg->rb);
-    return do_store(dc, arg->rd, addr, MO_UW, dc->mem_index, true);
+    return do_store(dc, arg->rd, addr, MO_UW ^ MO_BSWAP, dc->mem_index);
 }
 
 static bool trans_shea(DisasContext *dc, arg_typea *arg)
@@ -966,19 +956,19 @@ static bool trans_shea(DisasContext *dc, arg_typea *arg)
 static bool trans_shi(DisasContext *dc, arg_typeb *arg)
 {
     TCGv_i32 addr = compute_ldst_addr_typeb(dc, arg->ra, arg->imm);
-    return do_store(dc, arg->rd, addr, MO_UW, dc->mem_index, false);
+    return do_store(dc, arg->rd, addr, MO_UW, dc->mem_index);
 }
 
 static bool trans_sw(DisasContext *dc, arg_typea *arg)
 {
     TCGv_i32 addr = compute_ldst_addr_typea(dc, arg->ra, arg->rb);
-    return do_store(dc, arg->rd, addr, MO_UL, dc->mem_index, false);
+    return do_store(dc, arg->rd, addr, MO_UL, dc->mem_index);
 }
 
 static bool trans_swr(DisasContext *dc, arg_typea *arg)
 {
     TCGv_i32 addr = compute_ldst_addr_typea(dc, arg->ra, arg->rb);
-    return do_store(dc, arg->rd, addr, MO_UL, dc->mem_index, true);
+    return do_store(dc, arg->rd, addr, MO_UL ^ MO_BSWAP, dc->mem_index);
 }
 
 static bool trans_swea(DisasContext *dc, arg_typea *arg)
@@ -1000,7 +990,7 @@ static bool trans_swea(DisasContext *dc, arg_typea *arg)
 static bool trans_swi(DisasContext *dc, arg_typeb *arg)
 {
     TCGv_i32 addr = compute_ldst_addr_typeb(dc, arg->ra, arg->imm);
-    return do_store(dc, arg->rd, addr, MO_UL, dc->mem_index, false);
+    return do_store(dc, arg->rd, addr, MO_UL, dc->mem_index);
 }
 
 static bool trans_swx(DisasContext *dc, arg_typea *arg)
Signature · 1 line
2.53.0
#2 lore raw

Re: [PATCH v2 1/7] target/microblaze: Set MO_BSWAP in do_load/do_store callers

Hi Phil,

Quoted 22 lines · Philippe Mathieu-Daudé

Instead of setting the MO_BSWAP bit in the do_load/do_store helpers depending on a @rev boolean argument, set it on the callers in the MemOp argument. The repeated caller pattern will allow further simplifications in the next commit.

---
 target/microblaze/translate.c | 62 +++++++++++++++--------------------
 1 file changed, 26 insertions(+), 36 deletions(-)
target/microblaze/translate.c +1 -1
index 8b219afb5dd..623980d0af5 100644
@@ -704,22 +704,17 @@ static inline MemOp mo_endian(DisasContext *dc)
 }
 
 static bool do_load(DisasContext *dc, int rd, TCGv_i32 addr, MemOp mop,
-                    int mem_index, bool rev)
+                    int mem_index)
 {
     MemOp size = mop & MO_SIZE;

target/microblaze/translate.c static inline MemOp mo_endian(DisasContext *dc) · line 715

Quoted 10 lines
target/microblaze/translate.c +2 -4
 
     mop |= mo_endian(dc);
 
     /*
-     * When doing reverse accesses we need to do two things.
-     *
-     * 1. Reverse the address wrt endianness.
-     * 2. Byteswap the data lanes on the way back into the CPU core.
+     * When doing reverse accesses we need to byteswap the data
+     * lanes on the way back into the CPU core.

You are dropping the wrong part of the comment here. You should keep 1.

target/microblaze/translate.c static inline MemOp mo_endian(DisasContext *dc) · line 717

Quoted 6 lines
target/microblaze/translate.c +1 -4
      */
-    if (rev) {
-        if (size > MO_8) {
-            mop ^= MO_BSWAP;
-        }
+    if (mop & MO_BSWAP) {

Unfortunately in the current state of the refactoring we can't really get rid of the rev' argument and rely on mop' flags here. The MO_BSWAP flag means "Host reverse endian". So e.g., for a regular big-endian target access on a little-endian host the MO_BSWAP flag is set. Hence the 'xor' to flip the bit. ...

Quoted 6 lines
target/microblaze/translate.c +0 -0
         if (size < MO_32) {
             tcg_gen_xori_i32(addr, addr, 3 - size);
         }
@@ -746,13 +741,13 @@ static bool do_load(DisasContext *dc, int rd, TCGv_i32 addr, MemOp mop,
 static bool trans_lbu(DisasContext *dc, arg_typea *arg)
 {

target/microblaze/translate.c static bool do_load(DisasContext *dc, int rd, TCGv_i32 addr, MemOp mop, · line 750

Quoted 10 lines
target/microblaze/translate.c +2 -2
     TCGv_i32 addr = compute_ldst_addr_typea(dc, arg->ra, arg->rb);
-    return do_load(dc, arg->rd, addr, MO_UB, dc->mem_index, false);
+    return do_load(dc, arg->rd, addr, MO_UB, dc->mem_index);
 }
 
 static bool trans_lbur(DisasContext *dc, arg_typea *arg)
 {
     TCGv_i32 addr = compute_ldst_addr_typea(dc, arg->ra, arg->rb);
-    return do_load(dc, arg->rd, addr, MO_UB, dc->mem_index, true);
+    return do_load(dc, arg->rd, addr, MO_UB ^ MO_BSWAP, dc->mem_index);

... Here you are xor'ing MO_UB and MO_BSWAP, which will result in the MO_BSWAP bit to always be set. What you want is to xor MO_BSWAP with mo_endian(dc).

So what you can do instead, is to set it unconditionally:

    return do_load(dc, arg->rd, addr, MO_UB | MO_BSWAP, dc->mem_index);

And in do_load'/do_store', xor it with mo_endian(dc):

     mop ^= mo_endian(dc);

That works but needs a good comment explaining what's going on :)

Thanks

Signature · 1 line
Luc
Quoted 159 lines
target/microblaze/translate.c +20 -25
 }
 
 static bool trans_lbuea(DisasContext *dc, arg_typea *arg)
@@ -772,19 +767,19 @@ static bool trans_lbuea(DisasContext *dc, arg_typea *arg)
 static bool trans_lbui(DisasContext *dc, arg_typeb *arg)
 {
     TCGv_i32 addr = compute_ldst_addr_typeb(dc, arg->ra, arg->imm);
-    return do_load(dc, arg->rd, addr, MO_UB, dc->mem_index, false);
+    return do_load(dc, arg->rd, addr, MO_UB, dc->mem_index);
 }
 
 static bool trans_lhu(DisasContext *dc, arg_typea *arg)
 {
     TCGv_i32 addr = compute_ldst_addr_typea(dc, arg->ra, arg->rb);
-    return do_load(dc, arg->rd, addr, MO_UW, dc->mem_index, false);
+    return do_load(dc, arg->rd, addr, MO_UW, dc->mem_index);
 }
 
 static bool trans_lhur(DisasContext *dc, arg_typea *arg)
 {
     TCGv_i32 addr = compute_ldst_addr_typea(dc, arg->ra, arg->rb);
-    return do_load(dc, arg->rd, addr, MO_UW, dc->mem_index, true);
+    return do_load(dc, arg->rd, addr, MO_UW ^ MO_BSWAP, dc->mem_index);
 }
 
 static bool trans_lhuea(DisasContext *dc, arg_typea *arg)
@@ -806,19 +801,19 @@ static bool trans_lhuea(DisasContext *dc, arg_typea *arg)
 static bool trans_lhui(DisasContext *dc, arg_typeb *arg)
 {
     TCGv_i32 addr = compute_ldst_addr_typeb(dc, arg->ra, arg->imm);
-    return do_load(dc, arg->rd, addr, MO_UW, dc->mem_index, false);
+    return do_load(dc, arg->rd, addr, MO_UW, dc->mem_index);
 }
 
 static bool trans_lw(DisasContext *dc, arg_typea *arg)
 {
     TCGv_i32 addr = compute_ldst_addr_typea(dc, arg->ra, arg->rb);
-    return do_load(dc, arg->rd, addr, MO_UL, dc->mem_index, false);
+    return do_load(dc, arg->rd, addr, MO_UL, dc->mem_index);
 }
 
 static bool trans_lwr(DisasContext *dc, arg_typea *arg)
 {
     TCGv_i32 addr = compute_ldst_addr_typea(dc, arg->ra, arg->rb);
-    return do_load(dc, arg->rd, addr, MO_UL, dc->mem_index, true);
+    return do_load(dc, arg->rd, addr, MO_UL ^ MO_BSWAP, dc->mem_index);
 }
 
 static bool trans_lwea(DisasContext *dc, arg_typea *arg)
@@ -840,7 +835,7 @@ static bool trans_lwea(DisasContext *dc, arg_typea *arg)
 static bool trans_lwi(DisasContext *dc, arg_typeb *arg)
 {
     TCGv_i32 addr = compute_ldst_addr_typeb(dc, arg->ra, arg->imm);
-    return do_load(dc, arg->rd, addr, MO_UL, dc->mem_index, false);
+    return do_load(dc, arg->rd, addr, MO_UL, dc->mem_index);
 }
 
 static bool trans_lwx(DisasContext *dc, arg_typea *arg)
@@ -864,22 +859,17 @@ static bool trans_lwx(DisasContext *dc, arg_typea *arg)
 }
 
 static bool do_store(DisasContext *dc, int rd, TCGv_i32 addr, MemOp mop,
-                     int mem_index, bool rev)
+                     int mem_index)
 {
     MemOp size = mop & MO_SIZE;
 
     mop |= mo_endian(dc);
 
     /*
-     * When doing reverse accesses we need to do two things.
-     *
-     * 1. Reverse the address wrt endianness.
-     * 2. Byteswap the data lanes on the way back into the CPU core.
+     * When doing reverse accesses we need to byteswap the data
+     * lanes on the way back into the CPU core.
      */
-    if (rev) {
-        if (size > MO_8) {
-            mop ^= MO_BSWAP;
-        }
+    if (mop & MO_BSWAP) {
         if (size < MO_32) {
             tcg_gen_xori_i32(addr, addr, 3 - size);
         }
@@ -906,13 +896,13 @@ static bool do_store(DisasContext *dc, int rd, TCGv_i32 addr, MemOp mop,
 static bool trans_sb(DisasContext *dc, arg_typea *arg)
 {
     TCGv_i32 addr = compute_ldst_addr_typea(dc, arg->ra, arg->rb);
-    return do_store(dc, arg->rd, addr, MO_UB, dc->mem_index, false);
+    return do_store(dc, arg->rd, addr, MO_UB, dc->mem_index);
 }
 
 static bool trans_sbr(DisasContext *dc, arg_typea *arg)
 {
     TCGv_i32 addr = compute_ldst_addr_typea(dc, arg->ra, arg->rb);
-    return do_store(dc, arg->rd, addr, MO_UB, dc->mem_index, true);
+    return do_store(dc, arg->rd, addr, MO_UB ^ MO_BSWAP, dc->mem_index);
 }
 
 static bool trans_sbea(DisasContext *dc, arg_typea *arg)
@@ -932,19 +922,19 @@ static bool trans_sbea(DisasContext *dc, arg_typea *arg)
 static bool trans_sbi(DisasContext *dc, arg_typeb *arg)
 {
     TCGv_i32 addr = compute_ldst_addr_typeb(dc, arg->ra, arg->imm);
-    return do_store(dc, arg->rd, addr, MO_UB, dc->mem_index, false);
+    return do_store(dc, arg->rd, addr, MO_UB, dc->mem_index);
 }
 
 static bool trans_sh(DisasContext *dc, arg_typea *arg)
 {
     TCGv_i32 addr = compute_ldst_addr_typea(dc, arg->ra, arg->rb);
-    return do_store(dc, arg->rd, addr, MO_UW, dc->mem_index, false);
+    return do_store(dc, arg->rd, addr, MO_UW, dc->mem_index);
 }
 
 static bool trans_shr(DisasContext *dc, arg_typea *arg)
 {
     TCGv_i32 addr = compute_ldst_addr_typea(dc, arg->ra, arg->rb);
-    return do_store(dc, arg->rd, addr, MO_UW, dc->mem_index, true);
+    return do_store(dc, arg->rd, addr, MO_UW ^ MO_BSWAP, dc->mem_index);
 }
 
 static bool trans_shea(DisasContext *dc, arg_typea *arg)
@@ -966,19 +956,19 @@ static bool trans_shea(DisasContext *dc, arg_typea *arg)
 static bool trans_shi(DisasContext *dc, arg_typeb *arg)
 {
     TCGv_i32 addr = compute_ldst_addr_typeb(dc, arg->ra, arg->imm);
-    return do_store(dc, arg->rd, addr, MO_UW, dc->mem_index, false);
+    return do_store(dc, arg->rd, addr, MO_UW, dc->mem_index);
 }
 
 static bool trans_sw(DisasContext *dc, arg_typea *arg)
 {
     TCGv_i32 addr = compute_ldst_addr_typea(dc, arg->ra, arg->rb);
-    return do_store(dc, arg->rd, addr, MO_UL, dc->mem_index, false);
+    return do_store(dc, arg->rd, addr, MO_UL, dc->mem_index);
 }
 
 static bool trans_swr(DisasContext *dc, arg_typea *arg)
 {
     TCGv_i32 addr = compute_ldst_addr_typea(dc, arg->ra, arg->rb);
-    return do_store(dc, arg->rd, addr, MO_UL, dc->mem_index, true);
+    return do_store(dc, arg->rd, addr, MO_UL ^ MO_BSWAP, dc->mem_index);
 }
 
 static bool trans_swea(DisasContext *dc, arg_typea *arg)
@@ -1000,7 +990,7 @@ static bool trans_swea(DisasContext *dc, arg_typea *arg)
 static bool trans_swi(DisasContext *dc, arg_typeb *arg)
 {
     TCGv_i32 addr = compute_ldst_addr_typeb(dc, arg->ra, arg->imm);
-    return do_store(dc, arg->rd, addr, MO_UL, dc->mem_index, false);
+    return do_store(dc, arg->rd, addr, MO_UL, dc->mem_index);
 }
 
 static bool trans_swx(DisasContext *dc, arg_typea *arg)
Signature · 1 line
2.53.0
#3 lore raw

PATCH v2 2/7 target/microblaze: Use TRANS() macro for typeB load/store opcodes

In reply to Philippe Mathieu-Daudé

While being a no-op since the TRANS() macro expands to the same code, this is less code so less maintenance.

---
 target/microblaze/translate.c | 64 +++++++++++++++--------------------
 1 file changed, 28 insertions(+), 36 deletions(-)
target/microblaze/translate.c +28 -36
index 623980d0af5..a2a7ee8b9e0 100644
@@ -253,6 +253,14 @@ static bool do_typeb_val(DisasContext *dc, arg_typeb *arg, bool side_effects,
     return true;
 }
 
+/*
+ * Helpers for implementing sets of trans_* functions.
+ * Defer the implementation of NAME to FUNC, with optional extra arguments.
+ */
+#define TRANS(NAME, FUNC, ...) \
+    static bool trans_##NAME(DisasContext *ctx, arg_##NAME *a) \
+    { return FUNC(ctx, a, __VA_ARGS__); }
+
 #define DO_TYPEA(NAME, SE, FN) \
     static bool trans_##NAME(DisasContext *dc, arg_typea *a) \
     { return do_typea(dc, a, SE, FN); }
@@ -738,6 +746,16 @@ static bool do_load(DisasContext *dc, int rd, TCGv_i32 addr, MemOp mop,
     return true;
 }
 
+static bool trans_ld_typeb(DisasContext *dc, arg_typeb *arg, const MemOp mop)
+{
+    TCGv_i32 addr = compute_ldst_addr_typeb(dc, arg->ra, arg->imm);
+    return do_load(dc, arg->rd, addr, mop, dc->mem_index);
+}
+
+TRANS(lbui, trans_ld_typeb, MO_UB)
+TRANS(lhui, trans_ld_typeb, MO_UW)
+TRANS(lwi,  trans_ld_typeb, MO_UL)
+
 static bool trans_lbu(DisasContext *dc, arg_typea *arg)
 {
     TCGv_i32 addr = compute_ldst_addr_typea(dc, arg->ra, arg->rb);
@@ -764,12 +782,6 @@ static bool trans_lbuea(DisasContext *dc, arg_typea *arg)
 #endif
 }
 
-static bool trans_lbui(DisasContext *dc, arg_typeb *arg)
-{
-    TCGv_i32 addr = compute_ldst_addr_typeb(dc, arg->ra, arg->imm);
-    return do_load(dc, arg->rd, addr, MO_UB, dc->mem_index);
-}
-
 static bool trans_lhu(DisasContext *dc, arg_typea *arg)
 {
     TCGv_i32 addr = compute_ldst_addr_typea(dc, arg->ra, arg->rb);
@@ -798,12 +810,6 @@ static bool trans_lhuea(DisasContext *dc, arg_typea *arg)
 #endif
 }
 
-static bool trans_lhui(DisasContext *dc, arg_typeb *arg)
-{
-    TCGv_i32 addr = compute_ldst_addr_typeb(dc, arg->ra, arg->imm);
-    return do_load(dc, arg->rd, addr, MO_UW, dc->mem_index);
-}
-
 static bool trans_lw(DisasContext *dc, arg_typea *arg)
 {
     TCGv_i32 addr = compute_ldst_addr_typea(dc, arg->ra, arg->rb);
@@ -832,12 +838,6 @@ static bool trans_lwea(DisasContext *dc, arg_typea *arg)
 #endif
 }
 
-static bool trans_lwi(DisasContext *dc, arg_typeb *arg)
-{
-    TCGv_i32 addr = compute_ldst_addr_typeb(dc, arg->ra, arg->imm);
-    return do_load(dc, arg->rd, addr, MO_UL, dc->mem_index);
-}
-
 static bool trans_lwx(DisasContext *dc, arg_typea *arg)
 {
     TCGv_i32 addr = compute_ldst_addr_typea(dc, arg->ra, arg->rb);
@@ -893,6 +893,16 @@ static bool do_store(DisasContext *dc, int rd, TCGv_i32 addr, MemOp mop,
     return true;
 }
 
+static bool trans_st_typeb(DisasContext *dc, arg_typeb *arg, const MemOp mop)
+{
+    TCGv_i32 addr = compute_ldst_addr_typeb(dc, arg->ra, arg->imm);
+    return do_store(dc, arg->rd, addr, mop, dc->mem_index);
+}
+
+TRANS(sbi,  trans_st_typeb, MO_UB)
+TRANS(shi,  trans_st_typeb, MO_UW)
+TRANS(swi,  trans_st_typeb, MO_UL)
+
 static bool trans_sb(DisasContext *dc, arg_typea *arg)
 {
     TCGv_i32 addr = compute_ldst_addr_typea(dc, arg->ra, arg->rb);
@@ -919,12 +929,6 @@ static bool trans_sbea(DisasContext *dc, arg_typea *arg)
 #endif
 }
 
-static bool trans_sbi(DisasContext *dc, arg_typeb *arg)
-{
-    TCGv_i32 addr = compute_ldst_addr_typeb(dc, arg->ra, arg->imm);
-    return do_store(dc, arg->rd, addr, MO_UB, dc->mem_index);
-}
-
 static bool trans_sh(DisasContext *dc, arg_typea *arg)
 {
     TCGv_i32 addr = compute_ldst_addr_typea(dc, arg->ra, arg->rb);
@@ -953,12 +957,6 @@ static bool trans_shea(DisasContext *dc, arg_typea *arg)
 #endif
 }
 
-static bool trans_shi(DisasContext *dc, arg_typeb *arg)
-{
-    TCGv_i32 addr = compute_ldst_addr_typeb(dc, arg->ra, arg->imm);
-    return do_store(dc, arg->rd, addr, MO_UW, dc->mem_index);
-}
-
 static bool trans_sw(DisasContext *dc, arg_typea *arg)
 {
     TCGv_i32 addr = compute_ldst_addr_typea(dc, arg->ra, arg->rb);
@@ -987,12 +985,6 @@ static bool trans_swea(DisasContext *dc, arg_typea *arg)
 #endif
 }
 
-static bool trans_swi(DisasContext *dc, arg_typeb *arg)
-{
-    TCGv_i32 addr = compute_ldst_addr_typeb(dc, arg->ra, arg->imm);
-    return do_store(dc, arg->rd, addr, MO_UL, dc->mem_index);
-}
-
 static bool trans_swx(DisasContext *dc, arg_typea *arg)
 {
     TCGv_i32 addr = compute_ldst_addr_typea(dc, arg->ra, arg->rb);
Signature · 1 line
2.53.0
Reviewed-by on v2 2/7
#4 lore raw

Re: [PATCH v2 2/7] target/microblaze: Use TRANS() macro for typeB load/store opcodes

Quoted 4 lines · Philippe Mathieu-Daudé

While being a no-op since the TRANS() macro expands to the same code, this is less code so less maintenance.

Quoted 138 lines
---
 target/microblaze/translate.c | 64 +++++++++++++++--------------------
 1 file changed, 28 insertions(+), 36 deletions(-)
target/microblaze/translate.c +28 -36
index 623980d0af5..a2a7ee8b9e0 100644
@@ -253,6 +253,14 @@ static bool do_typeb_val(DisasContext *dc, arg_typeb *arg, bool side_effects,
     return true;
 }
 
+/*
+ * Helpers for implementing sets of trans_* functions.
+ * Defer the implementation of NAME to FUNC, with optional extra arguments.
+ */
+#define TRANS(NAME, FUNC, ...) \
+    static bool trans_##NAME(DisasContext *ctx, arg_##NAME *a) \
+    { return FUNC(ctx, a, __VA_ARGS__); }
+
 #define DO_TYPEA(NAME, SE, FN) \
     static bool trans_##NAME(DisasContext *dc, arg_typea *a) \
     { return do_typea(dc, a, SE, FN); }
@@ -738,6 +746,16 @@ static bool do_load(DisasContext *dc, int rd, TCGv_i32 addr, MemOp mop,
     return true;
 }
 
+static bool trans_ld_typeb(DisasContext *dc, arg_typeb *arg, const MemOp mop)
+{
+    TCGv_i32 addr = compute_ldst_addr_typeb(dc, arg->ra, arg->imm);
+    return do_load(dc, arg->rd, addr, mop, dc->mem_index);
+}
+
+TRANS(lbui, trans_ld_typeb, MO_UB)
+TRANS(lhui, trans_ld_typeb, MO_UW)
+TRANS(lwi,  trans_ld_typeb, MO_UL)
+
 static bool trans_lbu(DisasContext *dc, arg_typea *arg)
 {
     TCGv_i32 addr = compute_ldst_addr_typea(dc, arg->ra, arg->rb);
@@ -764,12 +782,6 @@ static bool trans_lbuea(DisasContext *dc, arg_typea *arg)
 #endif
 }
 
-static bool trans_lbui(DisasContext *dc, arg_typeb *arg)
-{
-    TCGv_i32 addr = compute_ldst_addr_typeb(dc, arg->ra, arg->imm);
-    return do_load(dc, arg->rd, addr, MO_UB, dc->mem_index);
-}
-
 static bool trans_lhu(DisasContext *dc, arg_typea *arg)
 {
     TCGv_i32 addr = compute_ldst_addr_typea(dc, arg->ra, arg->rb);
@@ -798,12 +810,6 @@ static bool trans_lhuea(DisasContext *dc, arg_typea *arg)
 #endif
 }
 
-static bool trans_lhui(DisasContext *dc, arg_typeb *arg)
-{
-    TCGv_i32 addr = compute_ldst_addr_typeb(dc, arg->ra, arg->imm);
-    return do_load(dc, arg->rd, addr, MO_UW, dc->mem_index);
-}
-
 static bool trans_lw(DisasContext *dc, arg_typea *arg)
 {
     TCGv_i32 addr = compute_ldst_addr_typea(dc, arg->ra, arg->rb);
@@ -832,12 +838,6 @@ static bool trans_lwea(DisasContext *dc, arg_typea *arg)
 #endif
 }
 
-static bool trans_lwi(DisasContext *dc, arg_typeb *arg)
-{
-    TCGv_i32 addr = compute_ldst_addr_typeb(dc, arg->ra, arg->imm);
-    return do_load(dc, arg->rd, addr, MO_UL, dc->mem_index);
-}
-
 static bool trans_lwx(DisasContext *dc, arg_typea *arg)
 {
     TCGv_i32 addr = compute_ldst_addr_typea(dc, arg->ra, arg->rb);
@@ -893,6 +893,16 @@ static bool do_store(DisasContext *dc, int rd, TCGv_i32 addr, MemOp mop,
     return true;
 }
 
+static bool trans_st_typeb(DisasContext *dc, arg_typeb *arg, const MemOp mop)
+{
+    TCGv_i32 addr = compute_ldst_addr_typeb(dc, arg->ra, arg->imm);
+    return do_store(dc, arg->rd, addr, mop, dc->mem_index);
+}
+
+TRANS(sbi,  trans_st_typeb, MO_UB)
+TRANS(shi,  trans_st_typeb, MO_UW)
+TRANS(swi,  trans_st_typeb, MO_UL)
+
 static bool trans_sb(DisasContext *dc, arg_typea *arg)
 {
     TCGv_i32 addr = compute_ldst_addr_typea(dc, arg->ra, arg->rb);
@@ -919,12 +929,6 @@ static bool trans_sbea(DisasContext *dc, arg_typea *arg)
 #endif
 }
 
-static bool trans_sbi(DisasContext *dc, arg_typeb *arg)
-{
-    TCGv_i32 addr = compute_ldst_addr_typeb(dc, arg->ra, arg->imm);
-    return do_store(dc, arg->rd, addr, MO_UB, dc->mem_index);
-}
-
 static bool trans_sh(DisasContext *dc, arg_typea *arg)
 {
     TCGv_i32 addr = compute_ldst_addr_typea(dc, arg->ra, arg->rb);
@@ -953,12 +957,6 @@ static bool trans_shea(DisasContext *dc, arg_typea *arg)
 #endif
 }
 
-static bool trans_shi(DisasContext *dc, arg_typeb *arg)
-{
-    TCGv_i32 addr = compute_ldst_addr_typeb(dc, arg->ra, arg->imm);
-    return do_store(dc, arg->rd, addr, MO_UW, dc->mem_index);
-}
-
 static bool trans_sw(DisasContext *dc, arg_typea *arg)
 {
     TCGv_i32 addr = compute_ldst_addr_typea(dc, arg->ra, arg->rb);
@@ -987,12 +985,6 @@ static bool trans_swea(DisasContext *dc, arg_typea *arg)
 #endif
 }
 
-static bool trans_swi(DisasContext *dc, arg_typeb *arg)
-{
-    TCGv_i32 addr = compute_ldst_addr_typeb(dc, arg->ra, arg->imm);
-    return do_store(dc, arg->rd, addr, MO_UL, dc->mem_index);
-}
-
 static bool trans_swx(DisasContext *dc, arg_typea *arg)
 {
     TCGv_i32 addr = compute_ldst_addr_typea(dc, arg->ra, arg->rb);
Signature · 1 line
2.53.0
#5 lore raw

PATCH v2 3/7 target/microblaze: Use TRANS() macro for typeA load/store opcodes

In reply to Philippe Mathieu-Daudé

While being a no-op since the TRANS() macro expands to the same code, this is less code so less maintenance.

---
 target/microblaze/translate.c | 96 +++++++++--------------------------
 1 file changed, 24 insertions(+), 72 deletions(-)
target/microblaze/translate.c +24 -72
index a2a7ee8b9e0..3f2de375d97 100644
@@ -746,28 +746,28 @@ static bool do_load(DisasContext *dc, int rd, TCGv_i32 addr, MemOp mop,
     return true;
 }
 
+static bool trans_ld_typea(DisasContext *dc, arg_typea *arg, const MemOp mop)
+{
+    TCGv_i32 addr = compute_ldst_addr_typea(dc, arg->ra, arg->rb);
+    return do_load(dc, arg->rd, addr, mop, dc->mem_index);
+}
+
 static bool trans_ld_typeb(DisasContext *dc, arg_typeb *arg, const MemOp mop)
 {
     TCGv_i32 addr = compute_ldst_addr_typeb(dc, arg->ra, arg->imm);
     return do_load(dc, arg->rd, addr, mop, dc->mem_index);
 }
 
+TRANS(lbu,  trans_ld_typea, MO_UB)
+TRANS(lbur, trans_ld_typea, MO_UB ^ MO_BSWAP)
 TRANS(lbui, trans_ld_typeb, MO_UB)
+TRANS(lhu,  trans_ld_typea, MO_UW)
+TRANS(lhur, trans_ld_typea, MO_UW ^ MO_BSWAP)
 TRANS(lhui, trans_ld_typeb, MO_UW)
+TRANS(lw,   trans_ld_typea, MO_UL)
+TRANS(lwr,  trans_ld_typea, MO_UL ^ MO_BSWAP)
 TRANS(lwi,  trans_ld_typeb, MO_UL)
 
-static bool trans_lbu(DisasContext *dc, arg_typea *arg)
-{
-    TCGv_i32 addr = compute_ldst_addr_typea(dc, arg->ra, arg->rb);
-    return do_load(dc, arg->rd, addr, MO_UB, dc->mem_index);
-}
-
-static bool trans_lbur(DisasContext *dc, arg_typea *arg)
-{
-    TCGv_i32 addr = compute_ldst_addr_typea(dc, arg->ra, arg->rb);
-    return do_load(dc, arg->rd, addr, MO_UB ^ MO_BSWAP, dc->mem_index);
-}
-
 static bool trans_lbuea(DisasContext *dc, arg_typea *arg)
 {
     if (trap_userspace(dc, true)) {
@@ -782,18 +782,6 @@ static bool trans_lbuea(DisasContext *dc, arg_typea *arg)
 #endif
 }
 
-static bool trans_lhu(DisasContext *dc, arg_typea *arg)
-{
-    TCGv_i32 addr = compute_ldst_addr_typea(dc, arg->ra, arg->rb);
-    return do_load(dc, arg->rd, addr, MO_UW, dc->mem_index);
-}
-
-static bool trans_lhur(DisasContext *dc, arg_typea *arg)
-{
-    TCGv_i32 addr = compute_ldst_addr_typea(dc, arg->ra, arg->rb);
-    return do_load(dc, arg->rd, addr, MO_UW ^ MO_BSWAP, dc->mem_index);
-}
-
 static bool trans_lhuea(DisasContext *dc, arg_typea *arg)
 {
     if (trap_userspace(dc, true)) {
@@ -810,18 +798,6 @@ static bool trans_lhuea(DisasContext *dc, arg_typea *arg)
 #endif
 }
 
-static bool trans_lw(DisasContext *dc, arg_typea *arg)
-{
-    TCGv_i32 addr = compute_ldst_addr_typea(dc, arg->ra, arg->rb);
-    return do_load(dc, arg->rd, addr, MO_UL, dc->mem_index);
-}
-
-static bool trans_lwr(DisasContext *dc, arg_typea *arg)
-{
-    TCGv_i32 addr = compute_ldst_addr_typea(dc, arg->ra, arg->rb);
-    return do_load(dc, arg->rd, addr, MO_UL ^ MO_BSWAP, dc->mem_index);
-}
-
 static bool trans_lwea(DisasContext *dc, arg_typea *arg)
 {
     if (trap_userspace(dc, true)) {
@@ -893,28 +869,28 @@ static bool do_store(DisasContext *dc, int rd, TCGv_i32 addr, MemOp mop,
     return true;
 }
 
+static bool trans_st_typea(DisasContext *dc, arg_typea *arg, const MemOp mop)
+{
+    TCGv_i32 addr = compute_ldst_addr_typea(dc, arg->ra, arg->rb);
+    return do_store(dc, arg->rd, addr, mop, dc->mem_index);
+}
+
 static bool trans_st_typeb(DisasContext *dc, arg_typeb *arg, const MemOp mop)
 {
     TCGv_i32 addr = compute_ldst_addr_typeb(dc, arg->ra, arg->imm);
     return do_store(dc, arg->rd, addr, mop, dc->mem_index);
 }
 
+TRANS(sb,   trans_st_typea, MO_UB)
+TRANS(sbr,  trans_st_typea, MO_UB ^ MO_BSWAP)
 TRANS(sbi,  trans_st_typeb, MO_UB)
+TRANS(sh,   trans_st_typea, MO_UW)
+TRANS(shr,  trans_st_typea, MO_UW ^ MO_BSWAP)
 TRANS(shi,  trans_st_typeb, MO_UW)
+TRANS(sw,   trans_st_typea, MO_UL)
+TRANS(swr,  trans_st_typea, MO_UL ^ MO_BSWAP)
 TRANS(swi,  trans_st_typeb, MO_UL)
 
-static bool trans_sb(DisasContext *dc, arg_typea *arg)
-{
-    TCGv_i32 addr = compute_ldst_addr_typea(dc, arg->ra, arg->rb);
-    return do_store(dc, arg->rd, addr, MO_UB, dc->mem_index);
-}
-
-static bool trans_sbr(DisasContext *dc, arg_typea *arg)
-{
-    TCGv_i32 addr = compute_ldst_addr_typea(dc, arg->ra, arg->rb);
-    return do_store(dc, arg->rd, addr, MO_UB ^ MO_BSWAP, dc->mem_index);
-}
-
 static bool trans_sbea(DisasContext *dc, arg_typea *arg)
 {
     if (trap_userspace(dc, true)) {
@@ -929,18 +905,6 @@ static bool trans_sbea(DisasContext *dc, arg_typea *arg)
 #endif
 }
 
-static bool trans_sh(DisasContext *dc, arg_typea *arg)
-{
-    TCGv_i32 addr = compute_ldst_addr_typea(dc, arg->ra, arg->rb);
-    return do_store(dc, arg->rd, addr, MO_UW, dc->mem_index);
-}
-
-static bool trans_shr(DisasContext *dc, arg_typea *arg)
-{
-    TCGv_i32 addr = compute_ldst_addr_typea(dc, arg->ra, arg->rb);
-    return do_store(dc, arg->rd, addr, MO_UW ^ MO_BSWAP, dc->mem_index);
-}
-
 static bool trans_shea(DisasContext *dc, arg_typea *arg)
 {
     if (trap_userspace(dc, true)) {
@@ -957,18 +921,6 @@ static bool trans_shea(DisasContext *dc, arg_typea *arg)
 #endif
 }
 
-static bool trans_sw(DisasContext *dc, arg_typea *arg)
-{
-    TCGv_i32 addr = compute_ldst_addr_typea(dc, arg->ra, arg->rb);
-    return do_store(dc, arg->rd, addr, MO_UL, dc->mem_index);
-}
-
-static bool trans_swr(DisasContext *dc, arg_typea *arg)
-{
-    TCGv_i32 addr = compute_ldst_addr_typea(dc, arg->ra, arg->rb);
-    return do_store(dc, arg->rd, addr, MO_UL ^ MO_BSWAP, dc->mem_index);
-}
-
 static bool trans_swea(DisasContext *dc, arg_typea *arg)
 {
     if (trap_userspace(dc, true)) {
Signature · 1 line
2.53.0
Reviewed-by on v2 3/7
#6 lore raw

Re: [PATCH v2 3/7] target/microblaze: Use TRANS() macro for typeA load/store opcodes

Hi Phil,

Quoted 20 lines · Philippe Mathieu-Daudé

While being a no-op since the TRANS() macro expands to the same code, this is less code so less maintenance.

---
 target/microblaze/translate.c | 96 +++++++++--------------------------
 1 file changed, 24 insertions(+), 72 deletions(-)
target/microblaze/translate.c +4 -0
index a2a7ee8b9e0..3f2de375d97 100644
@@ -746,28 +746,28 @@ static bool do_load(DisasContext *dc, int rd, TCGv_i32 addr, MemOp mop,
     return true;
 }
 
+static bool trans_ld_typea(DisasContext *dc, arg_typea *arg, const MemOp mop)
+{
+    TCGv_i32 addr = compute_ldst_addr_typea(dc, arg->ra, arg->rb);
+    return do_load(dc, arg->rd, addr, mop, dc->mem_index);

target/microblaze/translate.c static bool do_load(DisasContext *dc, int rd, TCGv_i32 addr, MemOp mop, · line 762

Quoted 10 lines
target/microblaze/translate.c +4 -0
+}
+
 static bool trans_ld_typeb(DisasContext *dc, arg_typeb *arg, const MemOp mop)
 {
     TCGv_i32 addr = compute_ldst_addr_typeb(dc, arg->ra, arg->imm);
     return do_load(dc, arg->rd, addr, mop, dc->mem_index);
 }
 
+TRANS(lbu,  trans_ld_typea, MO_UB)
+TRANS(lbur, trans_ld_typea, MO_UB ^ MO_BSWAP)

See my comment on patch 1. Otherwise for the refactoring part:

Quoted 143 lines
target/microblaze/translate.c +16 -72
 TRANS(lbui, trans_ld_typeb, MO_UB)
+TRANS(lhu,  trans_ld_typea, MO_UW)
+TRANS(lhur, trans_ld_typea, MO_UW ^ MO_BSWAP)
 TRANS(lhui, trans_ld_typeb, MO_UW)
+TRANS(lw,   trans_ld_typea, MO_UL)
+TRANS(lwr,  trans_ld_typea, MO_UL ^ MO_BSWAP)
 TRANS(lwi,  trans_ld_typeb, MO_UL)
 
-static bool trans_lbu(DisasContext *dc, arg_typea *arg)
-{
-    TCGv_i32 addr = compute_ldst_addr_typea(dc, arg->ra, arg->rb);
-    return do_load(dc, arg->rd, addr, MO_UB, dc->mem_index);
-}
-
-static bool trans_lbur(DisasContext *dc, arg_typea *arg)
-{
-    TCGv_i32 addr = compute_ldst_addr_typea(dc, arg->ra, arg->rb);
-    return do_load(dc, arg->rd, addr, MO_UB ^ MO_BSWAP, dc->mem_index);
-}
-
 static bool trans_lbuea(DisasContext *dc, arg_typea *arg)
 {
     if (trap_userspace(dc, true)) {
@@ -782,18 +782,6 @@ static bool trans_lbuea(DisasContext *dc, arg_typea *arg)
 #endif
 }
 
-static bool trans_lhu(DisasContext *dc, arg_typea *arg)
-{
-    TCGv_i32 addr = compute_ldst_addr_typea(dc, arg->ra, arg->rb);
-    return do_load(dc, arg->rd, addr, MO_UW, dc->mem_index);
-}
-
-static bool trans_lhur(DisasContext *dc, arg_typea *arg)
-{
-    TCGv_i32 addr = compute_ldst_addr_typea(dc, arg->ra, arg->rb);
-    return do_load(dc, arg->rd, addr, MO_UW ^ MO_BSWAP, dc->mem_index);
-}
-
 static bool trans_lhuea(DisasContext *dc, arg_typea *arg)
 {
     if (trap_userspace(dc, true)) {
@@ -810,18 +798,6 @@ static bool trans_lhuea(DisasContext *dc, arg_typea *arg)
 #endif
 }
 
-static bool trans_lw(DisasContext *dc, arg_typea *arg)
-{
-    TCGv_i32 addr = compute_ldst_addr_typea(dc, arg->ra, arg->rb);
-    return do_load(dc, arg->rd, addr, MO_UL, dc->mem_index);
-}
-
-static bool trans_lwr(DisasContext *dc, arg_typea *arg)
-{
-    TCGv_i32 addr = compute_ldst_addr_typea(dc, arg->ra, arg->rb);
-    return do_load(dc, arg->rd, addr, MO_UL ^ MO_BSWAP, dc->mem_index);
-}
-
 static bool trans_lwea(DisasContext *dc, arg_typea *arg)
 {
     if (trap_userspace(dc, true)) {
@@ -893,28 +869,28 @@ static bool do_store(DisasContext *dc, int rd, TCGv_i32 addr, MemOp mop,
     return true;
 }
 
+static bool trans_st_typea(DisasContext *dc, arg_typea *arg, const MemOp mop)
+{
+    TCGv_i32 addr = compute_ldst_addr_typea(dc, arg->ra, arg->rb);
+    return do_store(dc, arg->rd, addr, mop, dc->mem_index);
+}
+
 static bool trans_st_typeb(DisasContext *dc, arg_typeb *arg, const MemOp mop)
 {
     TCGv_i32 addr = compute_ldst_addr_typeb(dc, arg->ra, arg->imm);
     return do_store(dc, arg->rd, addr, mop, dc->mem_index);
 }
 
+TRANS(sb,   trans_st_typea, MO_UB)
+TRANS(sbr,  trans_st_typea, MO_UB ^ MO_BSWAP)
 TRANS(sbi,  trans_st_typeb, MO_UB)
+TRANS(sh,   trans_st_typea, MO_UW)
+TRANS(shr,  trans_st_typea, MO_UW ^ MO_BSWAP)
 TRANS(shi,  trans_st_typeb, MO_UW)
+TRANS(sw,   trans_st_typea, MO_UL)
+TRANS(swr,  trans_st_typea, MO_UL ^ MO_BSWAP)
 TRANS(swi,  trans_st_typeb, MO_UL)
 
-static bool trans_sb(DisasContext *dc, arg_typea *arg)
-{
-    TCGv_i32 addr = compute_ldst_addr_typea(dc, arg->ra, arg->rb);
-    return do_store(dc, arg->rd, addr, MO_UB, dc->mem_index);
-}
-
-static bool trans_sbr(DisasContext *dc, arg_typea *arg)
-{
-    TCGv_i32 addr = compute_ldst_addr_typea(dc, arg->ra, arg->rb);
-    return do_store(dc, arg->rd, addr, MO_UB ^ MO_BSWAP, dc->mem_index);
-}
-
 static bool trans_sbea(DisasContext *dc, arg_typea *arg)
 {
     if (trap_userspace(dc, true)) {
@@ -929,18 +905,6 @@ static bool trans_sbea(DisasContext *dc, arg_typea *arg)
 #endif
 }
 
-static bool trans_sh(DisasContext *dc, arg_typea *arg)
-{
-    TCGv_i32 addr = compute_ldst_addr_typea(dc, arg->ra, arg->rb);
-    return do_store(dc, arg->rd, addr, MO_UW, dc->mem_index);
-}
-
-static bool trans_shr(DisasContext *dc, arg_typea *arg)
-{
-    TCGv_i32 addr = compute_ldst_addr_typea(dc, arg->ra, arg->rb);
-    return do_store(dc, arg->rd, addr, MO_UW ^ MO_BSWAP, dc->mem_index);
-}
-
 static bool trans_shea(DisasContext *dc, arg_typea *arg)
 {
     if (trap_userspace(dc, true)) {
@@ -957,18 +921,6 @@ static bool trans_shea(DisasContext *dc, arg_typea *arg)
 #endif
 }
 
-static bool trans_sw(DisasContext *dc, arg_typea *arg)
-{
-    TCGv_i32 addr = compute_ldst_addr_typea(dc, arg->ra, arg->rb);
-    return do_store(dc, arg->rd, addr, MO_UL, dc->mem_index);
-}
-
-static bool trans_swr(DisasContext *dc, arg_typea *arg)
-{
-    TCGv_i32 addr = compute_ldst_addr_typea(dc, arg->ra, arg->rb);
-    return do_store(dc, arg->rd, addr, MO_UL ^ MO_BSWAP, dc->mem_index);
-}
-
 static bool trans_swea(DisasContext *dc, arg_typea *arg)
 {
     if (trap_userspace(dc, true)) {
Signature · 1 line
2.53.0
#7 lore raw

PATCH v2 4/7 target/microblaze: Set MO_ENDIAN in do_load/do_store callers

In reply to Philippe Mathieu-Daudé

Again set the MO_ENDIAN bit in the caller rather than the callee, allowing to further simplify.

---
 target/microblaze/translate.c | 12 ++++--------
 1 file changed, 4 insertions(+), 8 deletions(-)
target/microblaze/translate.c +4 -8
index 3f2de375d97..d4826981913 100644
@@ -716,8 +716,6 @@ static bool do_load(DisasContext *dc, int rd, TCGv_i32 addr, MemOp mop,
 {
     MemOp size = mop & MO_SIZE;
 
-    mop |= mo_endian(dc);
-
     /*
      * When doing reverse accesses we need to byteswap the data
      * lanes on the way back into the CPU core.
@@ -749,13 +747,13 @@ static bool do_load(DisasContext *dc, int rd, TCGv_i32 addr, MemOp mop,
 static bool trans_ld_typea(DisasContext *dc, arg_typea *arg, const MemOp mop)
 {
     TCGv_i32 addr = compute_ldst_addr_typea(dc, arg->ra, arg->rb);
-    return do_load(dc, arg->rd, addr, mop, dc->mem_index);
+    return do_load(dc, arg->rd, addr, mop | mo_endian(dc), dc->mem_index);
 }
 
 static bool trans_ld_typeb(DisasContext *dc, arg_typeb *arg, const MemOp mop)
 {
     TCGv_i32 addr = compute_ldst_addr_typeb(dc, arg->ra, arg->imm);
-    return do_load(dc, arg->rd, addr, mop, dc->mem_index);
+    return do_load(dc, arg->rd, addr, mop | mo_endian(dc), dc->mem_index);
 }
 
 TRANS(lbu,  trans_ld_typea, MO_UB)
@@ -839,8 +837,6 @@ static bool do_store(DisasContext *dc, int rd, TCGv_i32 addr, MemOp mop,
 {
     MemOp size = mop & MO_SIZE;
 
-    mop |= mo_endian(dc);
-
     /*
      * When doing reverse accesses we need to byteswap the data
      * lanes on the way back into the CPU core.
@@ -872,13 +868,13 @@ static bool do_store(DisasContext *dc, int rd, TCGv_i32 addr, MemOp mop,
 static bool trans_st_typea(DisasContext *dc, arg_typea *arg, const MemOp mop)
 {
     TCGv_i32 addr = compute_ldst_addr_typea(dc, arg->ra, arg->rb);
-    return do_store(dc, arg->rd, addr, mop, dc->mem_index);
+    return do_store(dc, arg->rd, addr, mop | mo_endian(dc), dc->mem_index);
 }
 
 static bool trans_st_typeb(DisasContext *dc, arg_typeb *arg, const MemOp mop)
 {
     TCGv_i32 addr = compute_ldst_addr_typeb(dc, arg->ra, arg->imm);
-    return do_store(dc, arg->rd, addr, mop, dc->mem_index);
+    return do_store(dc, arg->rd, addr, mop | mo_endian(dc), dc->mem_index);
 }
 
 TRANS(sb,   trans_st_typea, MO_UB)
Signature · 1 line
2.53.0
#8 lore raw

Re: [PATCH v2 4/7] target/microblaze: Set MO_ENDIAN in do_load/do_store callers

Hi Phil,

Quoted 2 lines · Philippe Mathieu-Daudé

Again set the MO_ENDIAN bit in the caller rather than the callee, allowing to further simplify.

I'm not sure I see the benefit of this one. Instead of having the mo_endian() call in two places, you end up having it in four places.

Add to this my previous remarks on patch 1 where this is replaced with a `mop ^= mo_endian(dc)' plus a comment expliciting things, I guess I would leave this in do_load/do_store.

Signature · 1 line
Luc
Quoted 63 lines
---
 target/microblaze/translate.c | 12 ++++--------
 1 file changed, 4 insertions(+), 8 deletions(-)
target/microblaze/translate.c +4 -8
index 3f2de375d97..d4826981913 100644
@@ -716,8 +716,6 @@ static bool do_load(DisasContext *dc, int rd, TCGv_i32 addr, MemOp mop,
 {
     MemOp size = mop & MO_SIZE;
 
-    mop |= mo_endian(dc);
-
     /*
      * When doing reverse accesses we need to byteswap the data
      * lanes on the way back into the CPU core.
@@ -749,13 +747,13 @@ static bool do_load(DisasContext *dc, int rd, TCGv_i32 addr, MemOp mop,
 static bool trans_ld_typea(DisasContext *dc, arg_typea *arg, const MemOp mop)
 {
     TCGv_i32 addr = compute_ldst_addr_typea(dc, arg->ra, arg->rb);
-    return do_load(dc, arg->rd, addr, mop, dc->mem_index);
+    return do_load(dc, arg->rd, addr, mop | mo_endian(dc), dc->mem_index);
 }
 
 static bool trans_ld_typeb(DisasContext *dc, arg_typeb *arg, const MemOp mop)
 {
     TCGv_i32 addr = compute_ldst_addr_typeb(dc, arg->ra, arg->imm);
-    return do_load(dc, arg->rd, addr, mop, dc->mem_index);
+    return do_load(dc, arg->rd, addr, mop | mo_endian(dc), dc->mem_index);
 }
 
 TRANS(lbu,  trans_ld_typea, MO_UB)
@@ -839,8 +837,6 @@ static bool do_store(DisasContext *dc, int rd, TCGv_i32 addr, MemOp mop,
 {
     MemOp size = mop & MO_SIZE;
 
-    mop |= mo_endian(dc);
-
     /*
      * When doing reverse accesses we need to byteswap the data
      * lanes on the way back into the CPU core.
@@ -872,13 +868,13 @@ static bool do_store(DisasContext *dc, int rd, TCGv_i32 addr, MemOp mop,
 static bool trans_st_typea(DisasContext *dc, arg_typea *arg, const MemOp mop)
 {
     TCGv_i32 addr = compute_ldst_addr_typea(dc, arg->ra, arg->rb);
-    return do_store(dc, arg->rd, addr, mop, dc->mem_index);
+    return do_store(dc, arg->rd, addr, mop | mo_endian(dc), dc->mem_index);
 }
 
 static bool trans_st_typeb(DisasContext *dc, arg_typeb *arg, const MemOp mop)
 {
     TCGv_i32 addr = compute_ldst_addr_typeb(dc, arg->ra, arg->imm);
-    return do_store(dc, arg->rd, addr, mop, dc->mem_index);
+    return do_store(dc, arg->rd, addr, mop | mo_endian(dc), dc->mem_index);
 }
 
 TRANS(sb,   trans_st_typea, MO_UB)
Signature · 1 line
2.53.0
#9 lore raw

PATCH v2 5/7 target/microblaze: Introduce local MemOp variable in LWX/SWX opcodes

In reply to Philippe Mathieu-Daudé

Next patch will pass this MemOp argument to compute_ldst_addr_typea. Add the local variable in a preliminary change to simplify the next change review.

---
 target/microblaze/translate.c | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)
target/microblaze/translate.c +4 -3
index d4826981913..581f4b48c92 100644
@@ -814,13 +814,13 @@ static bool trans_lwea(DisasContext *dc, arg_typea *arg)
 
 static bool trans_lwx(DisasContext *dc, arg_typea *arg)
 {
+    const MemOp mop = mo_endian(dc) | MO_UL;
     TCGv_i32 addr = compute_ldst_addr_typea(dc, arg->ra, arg->rb);
 
     /* lwx does not throw unaligned access errors, so force alignment */
     tcg_gen_andi_i32(addr, addr, ~3);
 
-    tcg_gen_qemu_ld_i32(cpu_res_val, addr, dc->mem_index,
-                        mo_endian(dc) | MO_UL);
+    tcg_gen_qemu_ld_i32(cpu_res_val, addr, dc->mem_index, mop);
     tcg_gen_mov_i32(cpu_res_addr, addr);
 
     if (arg->rd) {
@@ -935,6 +935,7 @@ static bool trans_swea(DisasContext *dc, arg_typea *arg)
 
 static bool trans_swx(DisasContext *dc, arg_typea *arg)
 {
+    const MemOp mop = mo_endian(dc) | MO_UL;
     TCGv_i32 addr = compute_ldst_addr_typea(dc, arg->ra, arg->rb);
     TCGLabel *swx_done = gen_new_label();
     TCGLabel *swx_fail = gen_new_label();
@@ -959,7 +960,7 @@ static bool trans_swx(DisasContext *dc, arg_typea *arg)
 
     tcg_gen_atomic_cmpxchg_i32(tval, cpu_res_addr, cpu_res_val,
                                reg_for_write(dc, arg->rd),
-                               dc->mem_index, mo_endian(dc) | MO_UL);
+                               dc->mem_index, mop);
 
     tcg_gen_brcond_i32(TCG_COND_NE, cpu_res_val, tval, swx_fail);
 
Signature · 1 line
2.53.0
#10 lore raw

PATCH v2 6/7 target/microblaze: Factor reverse_ldst_addr() helper out

In reply to Philippe Mathieu-Daudé

Instead of burying the address reversion in the load/store opcode helpers, hoist that to compute_ldst_addr_type*(). Pass the necessary information with a MemOp argument.

---
 target/microblaze/translate.c | 64 +++++++++++++++++------------------
 1 file changed, 32 insertions(+), 32 deletions(-)
target/microblaze/translate.c +32 -32
index 581f4b48c92..8c530ed1191 100644
@@ -607,7 +607,24 @@ static bool trans_wdic(DisasContext *dc, arg_wdic *a)
 DO_TYPEA(xor, false, tcg_gen_xor_i32)
 DO_TYPEBI(xori, false, tcg_gen_xori_i32)
 
-static TCGv_i32 compute_ldst_addr_typea(DisasContext *dc, int ra, int rb)
+static TCGv_i32 reverse_ldst_addr(TCGv_i32 addr, MemOp mop)
+{
+    MemOp mo_size = mop & MO_SIZE;
+
+    /*
+     * When doing reverse accesses we need to byteswap the data
+     * lanes on the way back into the CPU core.
+     */
+
+    if (mo_size < MO_32) {
+        tcg_gen_xori_i32(addr, addr, 3 - mo_size);
+    }
+
+    return addr;
+}
+
+static TCGv_i32 compute_ldst_addr_typea(DisasContext *dc, int ra, int rb,
+                                        MemOp mop)
 {
     TCGv_i32 ret;
 
@@ -622,6 +639,7 @@ static TCGv_i32 compute_ldst_addr_typea(DisasContext *dc, int ra, int rb)
     } else {
         ret = tcg_constant_i32(0);
     }
+    ret = reverse_ldst_addr(ret, mop);
 
     if ((ra == 1 || rb == 1) && dc->cfg->stackprot) {
         gen_helper_stackprot(tcg_env, ret);
@@ -629,7 +647,8 @@ static TCGv_i32 compute_ldst_addr_typea(DisasContext *dc, int ra, int rb)
     return ret;
 }
 
-static TCGv_i32 compute_ldst_addr_typeb(DisasContext *dc, int ra, int imm)
+static TCGv_i32 compute_ldst_addr_typeb(DisasContext *dc, int ra, int imm,
+                                        MemOp mop)
 {
     TCGv_i32 ret;
 
@@ -642,6 +661,7 @@ static TCGv_i32 compute_ldst_addr_typeb(DisasContext *dc, int ra, int imm)
     } else {
         ret = tcg_constant_i32(imm);
     }
+    ret = reverse_ldst_addr(ret, mop);
 
     if (ra == 1 && dc->cfg->stackprot) {
         gen_helper_stackprot(tcg_env, ret);
@@ -714,24 +734,14 @@ static inline MemOp mo_endian(DisasContext *dc)
 static bool do_load(DisasContext *dc, int rd, TCGv_i32 addr, MemOp mop,
                     int mem_index)
 {
-    MemOp size = mop & MO_SIZE;
-
-    /*
-     * When doing reverse accesses we need to byteswap the data
-     * lanes on the way back into the CPU core.
-     */
-    if (mop & MO_BSWAP) {
-        if (size < MO_32) {
-            tcg_gen_xori_i32(addr, addr, 3 - size);
-        }
-    }
-
     /*
      * For system mode, enforce alignment if the cpu configuration
      * requires it.  For user-mode, the Linux kernel will have fixed up
      * any unaligned access, so emulate that by *not* setting MO_ALIGN.
      */
 #ifndef CONFIG_USER_ONLY
+    MemOp size = mop & MO_SIZE;
+
     if (size > MO_8 &&
         (dc->tb_flags & MSR_EE) &&
         dc->cfg->unaligned_exceptions) {
@@ -746,13 +756,13 @@ static bool do_load(DisasContext *dc, int rd, TCGv_i32 addr, MemOp mop,
 
 static bool trans_ld_typea(DisasContext *dc, arg_typea *arg, const MemOp mop)
 {
-    TCGv_i32 addr = compute_ldst_addr_typea(dc, arg->ra, arg->rb);
+    TCGv_i32 addr = compute_ldst_addr_typea(dc, arg->ra, arg->rb, mop);
     return do_load(dc, arg->rd, addr, mop | mo_endian(dc), dc->mem_index);
 }
 
 static bool trans_ld_typeb(DisasContext *dc, arg_typeb *arg, const MemOp mop)
 {
-    TCGv_i32 addr = compute_ldst_addr_typeb(dc, arg->ra, arg->imm);
+    TCGv_i32 addr = compute_ldst_addr_typeb(dc, arg->ra, arg->imm, mop);
     return do_load(dc, arg->rd, addr, mop | mo_endian(dc), dc->mem_index);
 }
 
@@ -815,7 +825,7 @@ static bool trans_lwea(DisasContext *dc, arg_typea *arg)
 static bool trans_lwx(DisasContext *dc, arg_typea *arg)
 {
     const MemOp mop = mo_endian(dc) | MO_UL;
-    TCGv_i32 addr = compute_ldst_addr_typea(dc, arg->ra, arg->rb);
+    TCGv_i32 addr = compute_ldst_addr_typea(dc, arg->ra, arg->rb, mop);
 
     /* lwx does not throw unaligned access errors, so force alignment */
     tcg_gen_andi_i32(addr, addr, ~3);
@@ -835,24 +845,14 @@ static bool trans_lwx(DisasContext *dc, arg_typea *arg)
 static bool do_store(DisasContext *dc, int rd, TCGv_i32 addr, MemOp mop,
                      int mem_index)
 {
-    MemOp size = mop & MO_SIZE;
-
-    /*
-     * When doing reverse accesses we need to byteswap the data
-     * lanes on the way back into the CPU core.
-     */
-    if (mop & MO_BSWAP) {
-        if (size < MO_32) {
-            tcg_gen_xori_i32(addr, addr, 3 - size);
-        }
-    }
-
     /*
      * For system mode, enforce alignment if the cpu configuration
      * requires it.  For user-mode, the Linux kernel will have fixed up
      * any unaligned access, so emulate that by *not* setting MO_ALIGN.
      */
 #ifndef CONFIG_USER_ONLY
+    MemOp size = mop & MO_SIZE;
+
     if (size > MO_8 &&
         (dc->tb_flags & MSR_EE) &&
         dc->cfg->unaligned_exceptions) {
@@ -867,13 +867,13 @@ static bool do_store(DisasContext *dc, int rd, TCGv_i32 addr, MemOp mop,
 
 static bool trans_st_typea(DisasContext *dc, arg_typea *arg, const MemOp mop)
 {
-    TCGv_i32 addr = compute_ldst_addr_typea(dc, arg->ra, arg->rb);
+    TCGv_i32 addr = compute_ldst_addr_typea(dc, arg->ra, arg->rb, mop);
     return do_store(dc, arg->rd, addr, mop | mo_endian(dc), dc->mem_index);
 }
 
 static bool trans_st_typeb(DisasContext *dc, arg_typeb *arg, const MemOp mop)
 {
-    TCGv_i32 addr = compute_ldst_addr_typeb(dc, arg->ra, arg->imm);
+    TCGv_i32 addr = compute_ldst_addr_typeb(dc, arg->ra, arg->imm, mop);
     return do_store(dc, arg->rd, addr, mop | mo_endian(dc), dc->mem_index);
 }
 
@@ -936,7 +936,7 @@ static bool trans_swea(DisasContext *dc, arg_typea *arg)
 static bool trans_swx(DisasContext *dc, arg_typea *arg)
 {
     const MemOp mop = mo_endian(dc) | MO_UL;
-    TCGv_i32 addr = compute_ldst_addr_typea(dc, arg->ra, arg->rb);
+    TCGv_i32 addr = compute_ldst_addr_typea(dc, arg->ra, arg->rb, mop);
     TCGLabel *swx_done = gen_new_label();
     TCGLabel *swx_fail = gen_new_label();
     TCGv_i32 tval;
Signature · 1 line
2.53.0
#11 lore raw

Re: [PATCH v2 6/7] target/microblaze: Factor reverse_ldst_addr() helper out

Hi Phil,

Quoted 17 lines · Philippe Mathieu-Daudé

Instead of burying the address reversion in the load/store opcode helpers, hoist that to compute_ldst_addr_type*(). Pass the necessary information with a MemOp argument.

---
 target/microblaze/translate.c | 64 +++++++++++++++++------------------
 1 file changed, 32 insertions(+), 32 deletions(-)
target/microblaze/translate.c +0 -0
index 581f4b48c92..8c530ed1191 100644
@@ -607,7 +607,24 @@ static bool trans_wdic(DisasContext *dc, arg_wdic *a)
 DO_TYPEA(xor, false, tcg_gen_xor_i32)
 DO_TYPEBI(xori, false, tcg_gen_xori_i32)
 

target/microblaze/translate.c static bool trans_wdic(DisasContext *dc, arg_wdic *a) · line 618

Quoted 10 lines
target/microblaze/translate.c +9 -1
-static TCGv_i32 compute_ldst_addr_typea(DisasContext *dc, int ra, int rb)
+static TCGv_i32 reverse_ldst_addr(TCGv_i32 addr, MemOp mop)
+{
+    MemOp mo_size = mop & MO_SIZE;
+
+    /*
+     * When doing reverse accesses we need to byteswap the data
+     * lanes on the way back into the CPU core.
+     */
+

You are missing the check against MO_SWAP. Here you are unconditionally swapping all the addresses.

This is OK to check the MO_SWAP flag here because mop' has not been xor'ed with mo_endian(dc)' yet. So a MO_SWAP flag set here means "we are translating a reversed load/store".

Quoted 31 lines
target/microblaze/translate.c +12 -1
+    if (mo_size < MO_32) {
+        tcg_gen_xori_i32(addr, addr, 3 - mo_size);
+    }
+
+    return addr;
+}
+
+static TCGv_i32 compute_ldst_addr_typea(DisasContext *dc, int ra, int rb,
+                                        MemOp mop)
 {
     TCGv_i32 ret;
 
@@ -622,6 +639,7 @@ static TCGv_i32 compute_ldst_addr_typea(DisasContext *dc, int ra, int rb)
     } else {
         ret = tcg_constant_i32(0);
     }
+    ret = reverse_ldst_addr(ret, mop);
 
     if ((ra == 1 || rb == 1) && dc->cfg->stackprot) {
         gen_helper_stackprot(tcg_env, ret);
@@ -629,7 +647,8 @@ static TCGv_i32 compute_ldst_addr_typea(DisasContext *dc, int ra, int rb)
     return ret;
 }
 
-static TCGv_i32 compute_ldst_addr_typeb(DisasContext *dc, int ra, int imm)
+static TCGv_i32 compute_ldst_addr_typeb(DisasContext *dc, int ra, int imm,
+                                        MemOp mop)
 {
     TCGv_i32 ret;
 

target/microblaze/translate.c static TCGv_i32 compute_ldst_addr_typeb(DisasContext *dc, int ra, int imm) · line 664

Quoted 4 lines
target/microblaze/translate.c +1 -0
@@ -642,6 +661,7 @@ static TCGv_i32 compute_ldst_addr_typeb(DisasContext *dc, int ra, int imm)
     } else {
         ret = tcg_constant_i32(imm);
     }
+    ret = reverse_ldst_addr(ret, mop);

As you noted previously typeb (load/store immediate) does not have reversed variants. I guess you can drop this and even replace it with a g_assert(!(mop & MO_SWAP)).

Thanks

Luc

Quoted 110 lines
target/microblaze/translate.c +10 -30
     if (ra == 1 && dc->cfg->stackprot) {
         gen_helper_stackprot(tcg_env, ret);
@@ -714,24 +734,14 @@ static inline MemOp mo_endian(DisasContext *dc)
 static bool do_load(DisasContext *dc, int rd, TCGv_i32 addr, MemOp mop,
                     int mem_index)
 {
-    MemOp size = mop & MO_SIZE;
-
-    /*
-     * When doing reverse accesses we need to byteswap the data
-     * lanes on the way back into the CPU core.
-     */
-    if (mop & MO_BSWAP) {
-        if (size < MO_32) {
-            tcg_gen_xori_i32(addr, addr, 3 - size);
-        }
-    }
-
     /*
      * For system mode, enforce alignment if the cpu configuration
      * requires it.  For user-mode, the Linux kernel will have fixed up
      * any unaligned access, so emulate that by *not* setting MO_ALIGN.
      */
 #ifndef CONFIG_USER_ONLY
+    MemOp size = mop & MO_SIZE;
+
     if (size > MO_8 &&
         (dc->tb_flags & MSR_EE) &&
         dc->cfg->unaligned_exceptions) {
@@ -746,13 +756,13 @@ static bool do_load(DisasContext *dc, int rd, TCGv_i32 addr, MemOp mop,
 
 static bool trans_ld_typea(DisasContext *dc, arg_typea *arg, const MemOp mop)
 {
-    TCGv_i32 addr = compute_ldst_addr_typea(dc, arg->ra, arg->rb);
+    TCGv_i32 addr = compute_ldst_addr_typea(dc, arg->ra, arg->rb, mop);
     return do_load(dc, arg->rd, addr, mop | mo_endian(dc), dc->mem_index);
 }
 
 static bool trans_ld_typeb(DisasContext *dc, arg_typeb *arg, const MemOp mop)
 {
-    TCGv_i32 addr = compute_ldst_addr_typeb(dc, arg->ra, arg->imm);
+    TCGv_i32 addr = compute_ldst_addr_typeb(dc, arg->ra, arg->imm, mop);
     return do_load(dc, arg->rd, addr, mop | mo_endian(dc), dc->mem_index);
 }
 
@@ -815,7 +825,7 @@ static bool trans_lwea(DisasContext *dc, arg_typea *arg)
 static bool trans_lwx(DisasContext *dc, arg_typea *arg)
 {
     const MemOp mop = mo_endian(dc) | MO_UL;
-    TCGv_i32 addr = compute_ldst_addr_typea(dc, arg->ra, arg->rb);
+    TCGv_i32 addr = compute_ldst_addr_typea(dc, arg->ra, arg->rb, mop);
 
     /* lwx does not throw unaligned access errors, so force alignment */
     tcg_gen_andi_i32(addr, addr, ~3);
@@ -835,24 +845,14 @@ static bool trans_lwx(DisasContext *dc, arg_typea *arg)
 static bool do_store(DisasContext *dc, int rd, TCGv_i32 addr, MemOp mop,
                      int mem_index)
 {
-    MemOp size = mop & MO_SIZE;
-
-    /*
-     * When doing reverse accesses we need to byteswap the data
-     * lanes on the way back into the CPU core.
-     */
-    if (mop & MO_BSWAP) {
-        if (size < MO_32) {
-            tcg_gen_xori_i32(addr, addr, 3 - size);
-        }
-    }
-
     /*
      * For system mode, enforce alignment if the cpu configuration
      * requires it.  For user-mode, the Linux kernel will have fixed up
      * any unaligned access, so emulate that by *not* setting MO_ALIGN.
      */
 #ifndef CONFIG_USER_ONLY
+    MemOp size = mop & MO_SIZE;
+
     if (size > MO_8 &&
         (dc->tb_flags & MSR_EE) &&
         dc->cfg->unaligned_exceptions) {
@@ -867,13 +867,13 @@ static bool do_store(DisasContext *dc, int rd, TCGv_i32 addr, MemOp mop,
 
 static bool trans_st_typea(DisasContext *dc, arg_typea *arg, const MemOp mop)
 {
-    TCGv_i32 addr = compute_ldst_addr_typea(dc, arg->ra, arg->rb);
+    TCGv_i32 addr = compute_ldst_addr_typea(dc, arg->ra, arg->rb, mop);
     return do_store(dc, arg->rd, addr, mop | mo_endian(dc), dc->mem_index);
 }
 
 static bool trans_st_typeb(DisasContext *dc, arg_typeb *arg, const MemOp mop)
 {
-    TCGv_i32 addr = compute_ldst_addr_typeb(dc, arg->ra, arg->imm);
+    TCGv_i32 addr = compute_ldst_addr_typeb(dc, arg->ra, arg->imm, mop);
     return do_store(dc, arg->rd, addr, mop | mo_endian(dc), dc->mem_index);
 }
 
@@ -936,7 +936,7 @@ static bool trans_swea(DisasContext *dc, arg_typea *arg)
 static bool trans_swx(DisasContext *dc, arg_typea *arg)
 {
     const MemOp mop = mo_endian(dc) | MO_UL;
-    TCGv_i32 addr = compute_ldst_addr_typea(dc, arg->ra, arg->rb);
+    TCGv_i32 addr = compute_ldst_addr_typea(dc, arg->ra, arg->rb, mop);
     TCGLabel *swx_done = gen_new_label();
     TCGLabel *swx_fail = gen_new_label();
     TCGv_i32 tval;
Signature · 1 line
2.53.0
#12 lore raw

PATCH v2 7/7 target/microblaze/translate: fix reversed load/store translation

In reply to Philippe Mathieu-Daudé

From: Luc Michel <[email protected]>

Since 36a9529e60e0 the TCGv returned by compute_ldst_addr_type{a,b} for the address can be a target register or a constant. However do_{load,store} might modify it in the case of a reversed load/store.

Fix this by factoring out the reversed access logic and copying the address in a new TCGv_i32 if it needs to be modified.

Fixes 36a9529e60e0 (target/microblaze: Simplify compute_ldst_addr_type{a,b})
[PMD: Return early for tcg_constant_i32() calls]
---
 target/microblaze/translate.c | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)
target/microblaze/translate.c +6 -3
index 8c530ed1191..1ad96410598 100644
@@ -617,7 +617,10 @@ static TCGv_i32 reverse_ldst_addr(TCGv_i32 addr, MemOp mop)
      */
 
     if (mo_size < MO_32) {
-        tcg_gen_xori_i32(addr, addr, 3 - mo_size);
+        TCGv_i32 new_addr = tcg_temp_new_i32();
+
+        tcg_gen_xori_i32(new_addr, addr, 3 - mo_size);
+        return new_addr;
     }
 
     return addr;
@@ -637,7 +640,7 @@ static TCGv_i32 compute_ldst_addr_typea(DisasContext *dc, int ra, int rb,
     } else if (rb) {
         ret = cpu_R[rb];
     } else {
-        ret = tcg_constant_i32(0);
+        return tcg_constant_i32(0);
     }
     ret = reverse_ldst_addr(ret, mop);
 
@@ -659,7 +662,7 @@ static TCGv_i32 compute_ldst_addr_typeb(DisasContext *dc, int ra, int imm,
     } else if (ra) {
         ret = cpu_R[ra];
     } else {
-        ret = tcg_constant_i32(imm);
+        return tcg_constant_i32(imm);
     }
     ret = reverse_ldst_addr(ret, mop);
 
Signature · 1 line
2.53.0