Skip to contentSkip to conversation

gdbstub: add support for switchable endianness

PATCH In review Changbin Du 3 participants 13 messages Aug 23, 2021 – Aug 28, 2021 RISC-V

lore
Share & tools
lore
#0 lore raw

cover gdbstub: add support for switchable endianness

To resolve the issue to debug switchable targets, this serias introduces basic infrastructure for gdbstub and enable support for ARM and RISC-V targets.

For example, now there is no problem to debug an big-enadian aarch64 target on x86 host.

  $ qemu-system-aarch64 -gdb tcp::1234,endianness=big ...

Changbin Du (3):
gdbstub: add basic infrastructure to support switchable endianness
arm: gdbstub: add support for switchable endianness
riscv: gdbstub: add support for switchable endianness

 configs/targets/aarch64-softmmu.mak |  1 +
 configs/targets/arm-softmmu.mak     |  1 +
 configs/targets/riscv32-softmmu.mak |  1 +
 configs/targets/riscv64-softmmu.mak |  1 +
 gdbstub.c                           | 11 +++++
 include/exec/gdbstub.h              | 72 +++++++++++++++++++++--------
 qemu-options.hx                     |  7 ++-
 softmmu/vl.c                        | 50 +++++++++++++++++++-
 target/arm/gdbstub.c                |  2 +-
 target/arm/gdbstub64.c              |  2 +-
 target/riscv/gdbstub.c              | 12 ++---
 11 files changed, 131 insertions(+), 29 deletions(-)
Signature · 1 line
2.32.0
#1 lore raw

PATCH 1/3 gdbstub: add basic infrastructure to support switchable endianness

Some architectures (e.g. ARM versions 3 and above, RISC-V, PowerPC, Alpha, MIPS, IA-64...) allow switchable endianness. Now our emulation code can handle both endianness well, but the gdbstub can only handle one of them.

For example, it is problematic to debug a ARM big endian guest on x86 host. This because the GDB remote protocol transfers values in target byte order but qemu always take it as little endian on x86 host.

To support switchable endianness targets, this patch introduces:
- a new sub-option 'endianness' for '-gdb'.
- common interfaces to swap byte order according to host and target byte order.
- a new configuration option TARGET_SWICHABLE_ENDIANNESS.

For example, to debug a arm64 big endian target, you could start qemu as below:

  $ qemu-system-aarch64 -gdb tcp::1234,endianness=big ...

Latter we will add switchable endianness support for ARM and RISC-V targets. For other switchable targets them can be supported in future.

---
 gdbstub.c              | 11 +++++++
 include/exec/gdbstub.h | 72 +++++++++++++++++++++++++++++++-----------
 qemu-options.hx        |  7 ++--
 softmmu/vl.c           | 50 ++++++++++++++++++++++++++++-
 4 files changed, 119 insertions(+), 21 deletions(-)
gdbstub.c +11 -0
index 52bde5bdc9..ec67d6a299 100644
@@ -62,6 +62,17 @@
 static int phy_memory_mode;
 #endif
 
+#ifdef HOST_WORDS_BIGENDIAN
+const bool gdb_host_bigendian = true;
+#else
+const bool gdb_host_bigendian = false;
+#endif
+#ifdef TARGET_WORDS_BIGENDIAN
+bool gdb_target_bigendian = true;
+#else
+bool gdb_target_bigendian = false;
+#endif
+
 static inline int target_memory_rw_debug(CPUState *cpu, target_ulong addr,
                                          uint8_t *buf, int len, bool is_write)
 {
include/exec/gdbstub.h +54 -18

114 lines not on this page · raw message

qemu-options.hx +5 -2
index 83aa59a920..779b861331 100644
@@ -3954,9 +3954,12 @@ SRST
 ERST
 
 DEF("gdb", HAS_ARG, QEMU_OPTION_gdb, \
-    "-gdb dev        accept gdb connection on 'dev'. (QEMU defaults to starting\n"
+    "-gdb [dev=]device[,endianness=default|little|big]\n"
+    "                accept gdb connection on 'dev'. (QEMU defaults to starting\n"
     "                the guest without waiting for gdb to connect; use -S too\n"
-    "                if you want it to not start execution.)\n",
+    "                if you want it to not start execution.) The 'endianness'\n"
+    "                specifies the endianness mode of the target which supports\n"
+    "                switchable endianness.\n",
     QEMU_ARCH_ALL)
 SRST
 ``-gdb dev``
softmmu/vl.c +49 -1

68 lines not on this page · raw message

Signature · 1 line
2.32.0
#2 lore raw

PATCH 2/3 arm: gdbstub: add support for switchable endianness

In reply to Changbin Du

Apply new gdbstub interfaces we added previously to support both little and big endian guest debugging for ARM. And enable the TARGET_SWICHABLE_ENDIANNESS option.

---
 configs/targets/aarch64-softmmu.mak | 1 +
 configs/targets/arm-softmmu.mak     | 1 +
 target/arm/gdbstub.c                | 2 +-
 target/arm/gdbstub64.c              | 2 +-
 4 files changed, 4 insertions(+), 2 deletions(-)
configs/targets/aarch64-softmmu.mak +1 -0
index 7703127674..14e7f166a7 100644
@@ -3,3 +3,4 @@ TARGET_BASE_ARCH=arm
 TARGET_SUPPORTS_MTTCG=y
 TARGET_XML_FILES= gdb-xml/aarch64-core.xml gdb-xml/aarch64-fpu.xml gdb-xml/arm-core.xml gdb-xml/arm-vfp.xml gdb-xml/arm-vfp3.xml gdb-xml/arm-neon.xml gdb-xml/arm-m-profile.xml
 TARGET_NEED_FDT=y
+TARGET_SWICHABLE_ENDIANNESS=y
configs/targets/arm-softmmu.mak +1 -0
index 84a98f4818..5f40e858f9 100644
@@ -2,3 +2,4 @@ TARGET_ARCH=arm
 TARGET_SUPPORTS_MTTCG=y
 TARGET_XML_FILES= gdb-xml/arm-core.xml gdb-xml/arm-vfp.xml gdb-xml/arm-vfp3.xml gdb-xml/arm-neon.xml gdb-xml/arm-m-profile.xml
 TARGET_NEED_FDT=y
+TARGET_SWICHABLE_ENDIANNESS=y
target/arm/gdbstub.c +1 -1
index 826601b341..188e82d938 100644
@@ -74,7 +74,7 @@ int arm_cpu_gdb_write_register(CPUState *cs, uint8_t *mem_buf, int n)
     CPUARMState *env = &cpu->env;
     uint32_t tmp;
 
-    tmp = ldl_p(mem_buf);
+    tmp = gdb_read_reg32(mem_buf);
 
     /* Mask out low bit of PC to workaround gdb bugs.  This will probably
        cause problems if we ever implement the Jazelle DBX extensions.  */
target/arm/gdbstub64.c +1 -1
index 251539ef79..5358ad31b4 100644
@@ -47,7 +47,7 @@ int aarch64_cpu_gdb_write_register(CPUState *cs, uint8_t *mem_buf, int n)
     CPUARMState *env = &cpu->env;
     uint64_t tmp;
 
-    tmp = ldq_p(mem_buf);
+    tmp = gdb_read_reg64(mem_buf);
 
     if (n < 31) {
         /* Core integer register.  */
Signature · 1 line
2.32.0
#3 lore raw

PATCH 3/3 riscv: gdbstub: add support for switchable endianness

In reply to Changbin Du

Apply new gdbstub interfaces we added previously to support both little and big endian guest debugging for RISC-V. And enable the TARGET_SWICHABLE_ENDIANNESS option.

---
 configs/targets/riscv32-softmmu.mak |  1 +
 configs/targets/riscv64-softmmu.mak |  1 +
 target/riscv/gdbstub.c              | 12 ++++++------
 3 files changed, 8 insertions(+), 6 deletions(-)
configs/targets/riscv32-softmmu.mak +1 -0
index d8b71cddcd..7f02e67c72 100644
@@ -3,3 +3,4 @@ TARGET_BASE_ARCH=riscv
 TARGET_SUPPORTS_MTTCG=y
 TARGET_XML_FILES= gdb-xml/riscv-32bit-cpu.xml gdb-xml/riscv-32bit-fpu.xml gdb-xml/riscv-64bit-fpu.xml gdb-xml/riscv-32bit-virtual.xml
 TARGET_NEED_FDT=y
+TARGET_SWICHABLE_ENDIANNESS=y
configs/targets/riscv64-softmmu.mak +1 -0
index 7c0e7eeb42..c3e812495c 100644
@@ -3,3 +3,4 @@ TARGET_BASE_ARCH=riscv
 TARGET_SUPPORTS_MTTCG=y
 TARGET_XML_FILES= gdb-xml/riscv-64bit-cpu.xml gdb-xml/riscv-32bit-fpu.xml gdb-xml/riscv-64bit-fpu.xml gdb-xml/riscv-64bit-virtual.xml
 TARGET_NEED_FDT=y
+TARGET_SWICHABLE_ENDIANNESS=y
target/riscv/gdbstub.c +6 -6
index a7a9c0b1fe..d639cea859 100644
@@ -42,10 +42,10 @@ int riscv_cpu_gdb_write_register(CPUState *cs, uint8_t *mem_buf, int n)
         /* discard writes to x0 */
         return sizeof(target_ulong);
     } else if (n < 32) {
-        env->gpr[n] = ldtul_p(mem_buf);
+        env->gpr[n] = gdb_read_regl(mem_buf);
         return sizeof(target_ulong);
     } else if (n == 32) {
-        env->pc = ldtul_p(mem_buf);
+        env->pc = gdb_read_regl(mem_buf);
         return sizeof(target_ulong);
     }
     return 0;
@@ -81,11 +81,11 @@ static int riscv_gdb_get_fpu(CPURISCVState *env, GByteArray *buf, int n)
 static int riscv_gdb_set_fpu(CPURISCVState *env, uint8_t *mem_buf, int n)
 {
     if (n < 32) {
-        env->fpr[n] = ldq_p(mem_buf); /* always 64-bit */
+        env->fpr[n] = gdb_read_reg64(mem_buf); /* always 64-bit */
         return sizeof(uint64_t);
     /* there is hole between ft11 and fflags in fpu.xml */
     } else if (n < 36 && n > 32) {
-        target_ulong val = ldtul_p(mem_buf);
+        target_ulong val = gdb_read_regl(mem_buf);
         int result;
         /*
          * CSR_FFLAGS is at index 1 in csr_register, and gdb says it is FP
@@ -118,7 +118,7 @@ static int riscv_gdb_get_csr(CPURISCVState *env, GByteArray *buf, int n)
 static int riscv_gdb_set_csr(CPURISCVState *env, uint8_t *mem_buf, int n)
 {
     if (n < CSR_TABLE_SIZE) {
-        target_ulong val = ldtul_p(mem_buf);
+        target_ulong val = gdb_read_regl(mem_buf);
         int result;
 
         result = riscv_csrrw_debug(env, n, NULL, val, -1);
@@ -145,7 +145,7 @@ static int riscv_gdb_set_virtual(CPURISCVState *cs, uint8_t *mem_buf, int n)
 {
     if (n == 0) {
 #ifndef CONFIG_USER_ONLY
-        cs->priv = ldtul_p(mem_buf) & 0x3;
+        cs->priv = gdb_read_regl(mem_buf) & 0x3;
         if (cs->priv == PRV_H) {
             cs->priv = PRV_S;
         }
Signature · 1 line
2.32.0
#4 lore raw
In reply to Changbin Du
Quoted 8 lines · Changbin Du

To resolve the issue to debug switchable targets, this serias introduces basic infrastructure for gdbstub and enable support for ARM and RISC-V targets.

For example, now there is no problem to debug an big-enadian aarch64 target on x86 host.

  $ qemu-system-aarch64 -gdb tcp::1234,endianness=big ...

I don't understand why you need all that. Maybe you aren't using gdb-multiarch?

You can install it or start it via QEMU Debian Docker image:

$ docker run -it --rm -v /tmp:/tmp -u $UID --network=host \
  registry.gitlab.com/qemu-project/qemu/qemu/debian10 \
  gdb-multiarch -q \
    --ex 'set architecture aarch64' \
    --ex 'set endian big'
The target architecture is assumed to be aarch64
The target is assumed to be big endian
(gdb) target remote 172.17.0.1:1234
(gdb)
#5 lore raw
Quoted 16 lines · Philippe Mathieu-Daudé
Quoted 8 lines · Changbin Du

To resolve the issue to debug switchable targets, this serias introduces basic infrastructure for gdbstub and enable support for ARM and RISC-V targets.

For example, now there is no problem to debug an big-enadian aarch64 target on x86 host.

  $ qemu-system-aarch64 -gdb tcp::1234,endianness=big ...

I don't understand why you need all that. Maybe you aren't using gdb-multiarch?

You can install it or start it via QEMU Debian Docker image:

Quoted 8 lines
$ docker run -it --rm -v /tmp:/tmp -u $UID --network=host \
  registry.gitlab.com/qemu-project/qemu/qemu/debian10 \
  gdb-multiarch -q \
    --ex 'set architecture aarch64' \
    --ex 'set endian big'
The target architecture is assumed to be aarch64
The target is assumed to be big endian
(gdb) target remote 172.17.0.1:1234

I don't think that will help, because an AArch64 CPU (at least in the boards we model) will always start up in little-endian, and our gdbstub will always transfer register data etc in little-endian order, because gdb cannot cope with a target that isn't always the same endianness. Fixing this requires gdb changes to be more capable of handling dynamic target changes (this would also help with eg debugging across 32<->64 bit switches); as I understand it that gdb work would be pretty significant, and at least for aarch64 pretty much nobody cares about big-endian, so nobody's got round to doing it yet.

Our target/ppc/gdbstub.c code takes a different tack: it always sends register data in the same order the CPU is currently in, which has a different set of cases when it goes wrong.

thanks
-- PMM

#6 lore raw
Quoted 37 lines · Peter Maydell
Quoted 16 lines · Philippe Mathieu-Daudé
Quoted 8 lines · Changbin Du

To resolve the issue to debug switchable targets, this serias introduces basic infrastructure for gdbstub and enable support for ARM and RISC-V targets.

For example, now there is no problem to debug an big-enadian aarch64 target on x86 host.

  $ qemu-system-aarch64 -gdb tcp::1234,endianness=big ...

I don't understand why you need all that. Maybe you aren't using gdb-multiarch?

You can install it or start it via QEMU Debian Docker image:

Quoted 8 lines
$ docker run -it --rm -v /tmp:/tmp -u $UID --network=host \
  registry.gitlab.com/qemu-project/qemu/qemu/debian10 \
  gdb-multiarch -q \
    --ex 'set architecture aarch64' \
    --ex 'set endian big'
The target architecture is assumed to be aarch64
The target is assumed to be big endian
(gdb) target remote 172.17.0.1:1234

I don't think that will help, because an AArch64 CPU (at least in the boards we model) will always start up in little-endian, and our gdbstub will always transfer register data etc in little-endian order, because gdb cannot cope with a target that isn't always the same endianness. Fixing this requires gdb changes to be more capable of handling dynamic target changes (this would also help with eg debugging across 32<->64 bit switches); as I understand it that gdb work would be pretty significant, and at least for aarch64 pretty much nobody cares about big-endian, so nobody's got round to doing it yet.

Quoted 4 lines

Our target/ppc/gdbstub.c code takes a different tack: it always sends register data in the same order the CPU is currently in, which has a different set of cases when it goes wrong.

I remember having tested the 'setend be' instruction (from
https://github.com/pcrost/arm-be-test) 3 years ago using it. Connected as little endian, set breakpoint, on BP hit disconnect, set big-endian, reconnect, keep single-stepping (in the same gdb session).

I doubt anything changed since.

#7 lore raw
In reply to Peter Maydell
Quoted 26 lines · Peter Maydell
Quoted 16 lines · Philippe Mathieu-Daudé
Quoted 8 lines · Changbin Du

To resolve the issue to debug switchable targets, this serias introduces basic infrastructure for gdbstub and enable support for ARM and RISC-V targets.

For example, now there is no problem to debug an big-enadian aarch64 target on x86 host.

  $ qemu-system-aarch64 -gdb tcp::1234,endianness=big ...

I don't understand why you need all that. Maybe you aren't using gdb-multiarch?

You can install it or start it via QEMU Debian Docker image:

Quoted 8 lines
$ docker run -it --rm -v /tmp:/tmp -u $UID --network=host \
  registry.gitlab.com/qemu-project/qemu/qemu/debian10 \
  gdb-multiarch -q \
    --ex 'set architecture aarch64' \
    --ex 'set endian big'
The target architecture is assumed to be aarch64
The target is assumed to be big endian
(gdb) target remote 172.17.0.1:1234
Quoted 5 lines

I don't think that will help, because an AArch64 CPU (at least in the boards we model) will always start up in little-endian, and our gdbstub will always transfer register data etc in little-endian order, because gdb cannot cope with a target that isn't always the same endianness. Fixing this requires gdb

Yes, that's the problem.

Quoted 6 lines

changes to be more capable of handling dynamic target changes (this would also help with eg debugging across 32<->64 bit switches); as I understand it that gdb work would be pretty significant, and at least for aarch64 pretty much nobody cares about big-endian, so nobody's got round to doing it yet.

Mostly we do not care dynamic target changes because nearly all OS will setup endianness mode by its first instruction. And dynamic changes for gdb is hard since the byte order of debugging info in elf is fixed. And currently the GDB remote protocol does not support querying endianness info from remote.

So usually we needn't change byte order during a debug session, but we just want the qemu gdbstub can send data in and handle data it received in right byte order. This patch does this work with the help of users via the option 'endianness='.

Quoted 5 lines

Our target/ppc/gdbstub.c code takes a different tack: it always sends register data in the same order the CPU is currently in, which has a different set of cases when it goes wrong.

Yes, I tried to do this before. But as I said above GDB unable to handle dynamic target changing. Maybe we can take this way as 'endianness=default'? Anyway, this requires each target provides a interface to determine the current byte order.

Quoted 2 lines

thanks
-- PMM

Signature · 2 lines
Cheers,
Changbin Du
#8 lore raw
Quoted 8 lines · Changbin Du
Quoted 6 lines · Peter Maydell

changes to be more capable of handling dynamic target changes (this would also help with eg debugging across 32<->64 bit switches); as I understand it that gdb work would be pretty significant, and at least for aarch64 pretty much nobody cares about big-endian, so nobody's got round to doing it yet.

Quoted 8 lines

Mostly we do not care dynamic target changes because nearly all OS will setup endianness mode by its first instruction. And dynamic changes for gdb is hard since the byte order of debugging info in elf is fixed. And currently the GDB remote protocol does not support querying endianness info from remote.

So usually we needn't change byte order during a debug session, but we just want the qemu gdbstub can send data in and handle data it received in right byte order. This patch does this work with the help of users via the option 'endianness='.

I'm not a huge fan of putting in workarounds that deal with the problem for specific cases and require users to tweak options settings, rather than solving the problem in a more general way that would let it all Just Work for all cases.

-- PMM

#9 lore raw
Quoted 14 lines · Peter Maydell
Quoted 13 lines · Changbin Du
Quoted 6 lines · Peter Maydell

changes to be more capable of handling dynamic target changes (this would also help with eg debugging across 32<->64 bit switches); as I understand it that gdb work would be pretty significant, and at least for aarch64 pretty much nobody cares about big-endian, so nobody's got round to doing it yet.

Mostly we do not care dynamic target changes because nearly all OS will setup endianness mode by its first instruction. And dynamic changes for gdb is hard since the byte order of debugging info in elf is fixed. And currently the GDB remote protocol does not support querying endianness info from remote.

Quoted 9 lines
Quoted 3 lines

So usually we needn't change byte order during a debug session, but we just want the qemu gdbstub can send data in and handle data it received in right byte order. This patch does this work with the help of users via the option 'endianness='.

I'm not a huge fan of putting in workarounds that deal with the problem for specific cases and require users to tweak options settings, rather than solving the problem in a more general way that would let it all Just Work for all cases.

Probably we can add a new callback 'gdb_get_endianness' for CPUClass, and use this callback to determine if bswap is needed every time we read/write cpu registers. What's your thought?

Quoted 1 line

-- PMM

Signature · 2 lines
Cheers,
Changbin Du
#10 lore raw
Quoted 20 lines · Changbin Du
Quoted 18 lines · Peter Maydell
Quoted 16 lines · Changbin Du
Quoted 6 lines · Peter Maydell

changes to be more capable of handling dynamic target changes (this would also help with eg debugging across 32<->64 bit switches); as I understand it that gdb work would be pretty significant, and at least for aarch64 pretty much nobody cares about big-endian, so nobody's got round to doing it yet.

Mostly we do not care dynamic target changes because nearly all OS will setup endianness mode by its first instruction. And dynamic changes for gdb is hard since the byte order of debugging info in elf is fixed. And currently the GDB remote protocol does not support querying endianness info from remote.

So usually we needn't change byte order during a debug session, but we just want the qemu gdbstub can send data in and handle data it received in right byte order. This patch does this work with the help of users via the option 'endianness='.

Quoted 8 lines
Quoted 5 lines

I'm not a huge fan of putting in workarounds that deal with the problem for specific cases and require users to tweak options settings, rather than solving the problem in a more general way that would let it all Just Work for all cases.

Probably we can add a new callback 'gdb_get_endianness' for CPUClass, and use this callback to determine if bswap is needed every time we read/write cpu registers. What's your thought?

I think that you need to start by talking to the gdb folks about how debugging a dynamic endianness target should work. Fixing this probably goes something like:
* agree on design for how dynamic endianness, 32-64 mode changes, etc, should be handled by gdb
* make gdb changes
* document required gdbstub protocol enhancements (ie how the stub tells gdb about endianness changes, whether this changes how we send register information, memory data, etc)
* implement those changes in QEMU

You seem to be trying to start with the final step, not the first one :-)

-- PMM

#11 lore raw
In reply to Philippe Mathieu-Daudé
Quoted 5 lines · Philippe Mathieu-Daudé
Quoted 4 lines · Changbin Du

To resolve the issue to debug switchable targets, this serias introduces basic infrastructure for gdbstub and enable support for ARM and RISC-V targets.

Quoted 8 lines
Quoted 4 lines

For example, now there is no problem to debug an big-enadian aarch64 target on x86 host.

  $ qemu-system-aarch64 -gdb tcp::1234,endianness=big ...

I don't understand why you need all that. Maybe you aren't using gdb-multiarch?

Nope, my gdb support all architectures.

Quoted 12 lines

You can install it or start it via QEMU Debian Docker image:

$ docker run -it --rm -v /tmp:/tmp -u $UID --network=host \
  registry.gitlab.com/qemu-project/qemu/qemu/debian10 \
  gdb-multiarch -q \
    --ex 'set architecture aarch64' \
    --ex 'set endian big'
The target architecture is assumed to be aarch64
The target is assumed to be big endian
(gdb) target remote 172.17.0.1:1234
(gdb)

The gdb has no problem to read endianness and arch info from elf. The problem is how qemu gdbstub handles the byte order it received.

Now let's try to debug a big-enadian aarch64 linux kernel.

1) start qemu with '-gdb tcp::1234'

$ gdb-multiarch vmlinux
(gdb) target remote :1234
Remote debugging using :1234
0x0000004000000000 in ?? ()
=> 0x0000004000000000:	Cannot access memory at address 0x4000000000
(gdb) ni
Cannot access memory at address 0x4000000000
(gdb) show architecture 
The target architecture is set to "auto" (currently "aarch64").
(gdb) show endian 
The target endianness is set automatically (currently big endian).

You see it an't work, not to mention adding breakpoints.

2) start qemu with '-gdb tcp::1234,endianness=big'

$ gdb-multiarch vmlinux
(gdb) target remote :1234
Remote debugging using :1234
0x0000000040000000 in ?? ()
=> 0x0000000040000000:	c0 00 00 58	ldr	x0, 0x40000018
(gdb) ni
0x0000000040000004 in ?? ()
=> 0x0000000040000004:	e1 03 1f aa	mov	x1, xzr
(gdb) b start_kernel
Breakpoint 1 at 0xffff800011130ee8 (2 locations)
(gdb) c
Continuing.

Thread 1 hit Breakpoint 1, 0xffff800011130ee8 in start_kernel ()
=> 0xffff800011130ee8 <start_kernel+0>: 5f 24 03 d5 bti c
(gdb) bt
#0 0xffff800011130ee8 in start_kernel ()
#1 0xffff8000111303c8 in __primary_switched () at arch/arm64/kernel/head.S:467 Backtrace stopped: previous frame identical to this frame (corrupt stack?)

okay, now it works fine.

Signature · 2 lines
Cheers,
Changbin Du
#12 lore raw
In reply to Changbin Du
Quoted 4 lines · Changbin Du

To resolve the issue to debug switchable targets, this serias introduces basic infrastructure for gdbstub and enable support for ARM and RISC-V targets.

As I understand it, fixing this problem requires support from gdb, not merely changes to QEMU. You would need to be able to have QEMU tell gdb "the guest's endianness is now little/big" and have gdb cope with that change.

Quoted 4 lines

For example, now there is no problem to debug an big-enadian aarch64 target on x86 host.

  $ qemu-system-aarch64 -gdb tcp::1234,endianness=big ...

I don't feel like this is the right approach. QEMU already knows the endianness of the guest at any point.

thanks
-- PMM