* [PATCH 1/2] linux-user/hexagon: Fix sigcontext
@ 2025-10-08 1:47 Brian Cain
2025-10-08 1:47 ` [PATCH 2/2] tests/tcg/hexagon: Add cs{0,1} coverage Brian Cain
` (2 more replies)
0 siblings, 3 replies; 8+ messages in thread
From: Brian Cain @ 2025-10-08 1:47 UTC (permalink / raw)
To: qemu-devel
Cc: brian.cain, richard.henderson, philmd, matheus.bernardino, ale,
anjo, marco.liebel, ltaylorsimpson, alex.bennee, quic_mburton,
sid.manning, Alex Rønne Petersen, Laurent Vivier
In order to correspond with the kernel, we've now (1) moved the
preds[] to the right offset and combined the representation as a single
ulong "p3_0", (2), added the cs{0,1} registers, (3) added a pad for 48
words, (4) added the user regs structure to an 8-byte aligned
target_sigcontext structure.
Co-authored-by: Alex Rønne Petersen <alex@alexrp.com>
Signed-off-by: Brian Cain <brian.cain@oss.qualcomm.com>
---
linux-user/hexagon/signal.c | 199 ++++++++++++++++++++----------------
1 file changed, 111 insertions(+), 88 deletions(-)
diff --git a/linux-user/hexagon/signal.c b/linux-user/hexagon/signal.c
index 492b51f155..6c3dbf91fa 100644
--- a/linux-user/hexagon/signal.c
+++ b/linux-user/hexagon/signal.c
@@ -23,7 +23,7 @@
#include "signal-common.h"
#include "linux-user/trace.h"
-struct target_sigcontext {
+struct target_user_regs_struct {
target_ulong r0, r1, r2, r3;
target_ulong r4, r5, r6, r7;
target_ulong r8, r9, r10, r11;
@@ -39,14 +39,21 @@ struct target_sigcontext {
target_ulong m0;
target_ulong m1;
target_ulong usr;
+ target_ulong p3_0;
target_ulong gp;
target_ulong ugp;
target_ulong pc;
target_ulong cause;
target_ulong badva;
- target_ulong pred[NUM_PREGS];
+ target_ulong cs0;
+ target_ulong cs1;
+ target_ulong pad1;
};
+struct target_sigcontext {
+ struct target_user_regs_struct sc_regs;
+} __attribute__((aligned(8)));
+
struct target_ucontext {
unsigned long uc_flags;
target_ulong uc_link; /* target pointer */
@@ -76,53 +83,63 @@ static abi_ulong get_sigframe(struct target_sigaction *ka,
static void setup_sigcontext(struct target_sigcontext *sc, CPUHexagonState *env)
{
- __put_user(env->gpr[HEX_REG_R00], &sc->r0);
- __put_user(env->gpr[HEX_REG_R01], &sc->r1);
- __put_user(env->gpr[HEX_REG_R02], &sc->r2);
- __put_user(env->gpr[HEX_REG_R03], &sc->r3);
- __put_user(env->gpr[HEX_REG_R04], &sc->r4);
- __put_user(env->gpr[HEX_REG_R05], &sc->r5);
- __put_user(env->gpr[HEX_REG_R06], &sc->r6);
- __put_user(env->gpr[HEX_REG_R07], &sc->r7);
- __put_user(env->gpr[HEX_REG_R08], &sc->r8);
- __put_user(env->gpr[HEX_REG_R09], &sc->r9);
- __put_user(env->gpr[HEX_REG_R10], &sc->r10);
- __put_user(env->gpr[HEX_REG_R11], &sc->r11);
- __put_user(env->gpr[HEX_REG_R12], &sc->r12);
- __put_user(env->gpr[HEX_REG_R13], &sc->r13);
- __put_user(env->gpr[HEX_REG_R14], &sc->r14);
- __put_user(env->gpr[HEX_REG_R15], &sc->r15);
- __put_user(env->gpr[HEX_REG_R16], &sc->r16);
- __put_user(env->gpr[HEX_REG_R17], &sc->r17);
- __put_user(env->gpr[HEX_REG_R18], &sc->r18);
- __put_user(env->gpr[HEX_REG_R19], &sc->r19);
- __put_user(env->gpr[HEX_REG_R20], &sc->r20);
- __put_user(env->gpr[HEX_REG_R21], &sc->r21);
- __put_user(env->gpr[HEX_REG_R22], &sc->r22);
- __put_user(env->gpr[HEX_REG_R23], &sc->r23);
- __put_user(env->gpr[HEX_REG_R24], &sc->r24);
- __put_user(env->gpr[HEX_REG_R25], &sc->r25);
- __put_user(env->gpr[HEX_REG_R26], &sc->r26);
- __put_user(env->gpr[HEX_REG_R27], &sc->r27);
- __put_user(env->gpr[HEX_REG_R28], &sc->r28);
- __put_user(env->gpr[HEX_REG_R29], &sc->r29);
- __put_user(env->gpr[HEX_REG_R30], &sc->r30);
- __put_user(env->gpr[HEX_REG_R31], &sc->r31);
- __put_user(env->gpr[HEX_REG_SA0], &sc->sa0);
- __put_user(env->gpr[HEX_REG_LC0], &sc->lc0);
- __put_user(env->gpr[HEX_REG_SA1], &sc->sa1);
- __put_user(env->gpr[HEX_REG_LC1], &sc->lc1);
- __put_user(env->gpr[HEX_REG_M0], &sc->m0);
- __put_user(env->gpr[HEX_REG_M1], &sc->m1);
- __put_user(env->gpr[HEX_REG_USR], &sc->usr);
- __put_user(env->gpr[HEX_REG_GP], &sc->gp);
- __put_user(env->gpr[HEX_REG_UGP], &sc->ugp);
- __put_user(env->gpr[HEX_REG_PC], &sc->pc);
+ __put_user(env->gpr[HEX_REG_R00], &sc->sc_regs.r0);
+ __put_user(env->gpr[HEX_REG_R01], &sc->sc_regs.r1);
+ __put_user(env->gpr[HEX_REG_R02], &sc->sc_regs.r2);
+ __put_user(env->gpr[HEX_REG_R03], &sc->sc_regs.r3);
+ __put_user(env->gpr[HEX_REG_R04], &sc->sc_regs.r4);
+ __put_user(env->gpr[HEX_REG_R05], &sc->sc_regs.r5);
+ __put_user(env->gpr[HEX_REG_R06], &sc->sc_regs.r6);
+ __put_user(env->gpr[HEX_REG_R07], &sc->sc_regs.r7);
+ __put_user(env->gpr[HEX_REG_R08], &sc->sc_regs.r8);
+ __put_user(env->gpr[HEX_REG_R09], &sc->sc_regs.r9);
+ __put_user(env->gpr[HEX_REG_R10], &sc->sc_regs.r10);
+ __put_user(env->gpr[HEX_REG_R11], &sc->sc_regs.r11);
+ __put_user(env->gpr[HEX_REG_R12], &sc->sc_regs.r12);
+ __put_user(env->gpr[HEX_REG_R13], &sc->sc_regs.r13);
+ __put_user(env->gpr[HEX_REG_R14], &sc->sc_regs.r14);
+ __put_user(env->gpr[HEX_REG_R15], &sc->sc_regs.r15);
+ __put_user(env->gpr[HEX_REG_R16], &sc->sc_regs.r16);
+ __put_user(env->gpr[HEX_REG_R17], &sc->sc_regs.r17);
+ __put_user(env->gpr[HEX_REG_R18], &sc->sc_regs.r18);
+ __put_user(env->gpr[HEX_REG_R19], &sc->sc_regs.r19);
+ __put_user(env->gpr[HEX_REG_R20], &sc->sc_regs.r20);
+ __put_user(env->gpr[HEX_REG_R21], &sc->sc_regs.r21);
+ __put_user(env->gpr[HEX_REG_R22], &sc->sc_regs.r22);
+ __put_user(env->gpr[HEX_REG_R23], &sc->sc_regs.r23);
+ __put_user(env->gpr[HEX_REG_R24], &sc->sc_regs.r24);
+ __put_user(env->gpr[HEX_REG_R25], &sc->sc_regs.r25);
+ __put_user(env->gpr[HEX_REG_R26], &sc->sc_regs.r26);
+ __put_user(env->gpr[HEX_REG_R27], &sc->sc_regs.r27);
+ __put_user(env->gpr[HEX_REG_R28], &sc->sc_regs.r28);
+ __put_user(env->gpr[HEX_REG_R29], &sc->sc_regs.r29);
+ __put_user(env->gpr[HEX_REG_R30], &sc->sc_regs.r30);
+ __put_user(env->gpr[HEX_REG_R31], &sc->sc_regs.r31);
+ __put_user(env->gpr[HEX_REG_SA0], &sc->sc_regs.sa0);
+ __put_user(env->gpr[HEX_REG_LC0], &sc->sc_regs.lc0);
+ __put_user(env->gpr[HEX_REG_SA1], &sc->sc_regs.sa1);
+ __put_user(env->gpr[HEX_REG_LC1], &sc->sc_regs.lc1);
+ __put_user(env->gpr[HEX_REG_M0], &sc->sc_regs.m0);
+ __put_user(env->gpr[HEX_REG_M1], &sc->sc_regs.m1);
+ __put_user(env->gpr[HEX_REG_USR], &sc->sc_regs.usr);
+ __put_user(env->gpr[HEX_REG_GP], &sc->sc_regs.gp);
+ __put_user(env->gpr[HEX_REG_UGP], &sc->sc_regs.ugp);
+ __put_user(env->gpr[HEX_REG_PC], &sc->sc_regs.pc);
+ /* Consolidate predicates into p3_0 */
+ target_ulong preds = 0;
int i;
for (i = 0; i < NUM_PREGS; i++) {
- __put_user(env->pred[i], &(sc->pred[i]));
+ preds |= (env->pred[i] & 0xff) << (i * 8);
}
+ __put_user(preds, &sc->sc_regs.p3_0);
+
+ /* Set cause and badva to 0 - these are set by kernel on exceptions */
+ __put_user(0, &sc->sc_regs.cause);
+ __put_user(0, &sc->sc_regs.badva);
+
+ __put_user(env->gpr[HEX_REG_CS0], &sc->sc_regs.cs0);
+ __put_user(env->gpr[HEX_REG_CS1], &sc->sc_regs.cs1);
}
static void setup_ucontext(struct target_ucontext *uc,
@@ -192,53 +209,59 @@ badframe:
static void restore_sigcontext(CPUHexagonState *env,
struct target_sigcontext *sc)
{
- __get_user(env->gpr[HEX_REG_R00], &sc->r0);
- __get_user(env->gpr[HEX_REG_R01], &sc->r1);
- __get_user(env->gpr[HEX_REG_R02], &sc->r2);
- __get_user(env->gpr[HEX_REG_R03], &sc->r3);
- __get_user(env->gpr[HEX_REG_R04], &sc->r4);
- __get_user(env->gpr[HEX_REG_R05], &sc->r5);
- __get_user(env->gpr[HEX_REG_R06], &sc->r6);
- __get_user(env->gpr[HEX_REG_R07], &sc->r7);
- __get_user(env->gpr[HEX_REG_R08], &sc->r8);
- __get_user(env->gpr[HEX_REG_R09], &sc->r9);
- __get_user(env->gpr[HEX_REG_R10], &sc->r10);
- __get_user(env->gpr[HEX_REG_R11], &sc->r11);
- __get_user(env->gpr[HEX_REG_R12], &sc->r12);
- __get_user(env->gpr[HEX_REG_R13], &sc->r13);
- __get_user(env->gpr[HEX_REG_R14], &sc->r14);
- __get_user(env->gpr[HEX_REG_R15], &sc->r15);
- __get_user(env->gpr[HEX_REG_R16], &sc->r16);
- __get_user(env->gpr[HEX_REG_R17], &sc->r17);
- __get_user(env->gpr[HEX_REG_R18], &sc->r18);
- __get_user(env->gpr[HEX_REG_R19], &sc->r19);
- __get_user(env->gpr[HEX_REG_R20], &sc->r20);
- __get_user(env->gpr[HEX_REG_R21], &sc->r21);
- __get_user(env->gpr[HEX_REG_R22], &sc->r22);
- __get_user(env->gpr[HEX_REG_R23], &sc->r23);
- __get_user(env->gpr[HEX_REG_R24], &sc->r24);
- __get_user(env->gpr[HEX_REG_R25], &sc->r25);
- __get_user(env->gpr[HEX_REG_R26], &sc->r26);
- __get_user(env->gpr[HEX_REG_R27], &sc->r27);
- __get_user(env->gpr[HEX_REG_R28], &sc->r28);
- __get_user(env->gpr[HEX_REG_R29], &sc->r29);
- __get_user(env->gpr[HEX_REG_R30], &sc->r30);
- __get_user(env->gpr[HEX_REG_R31], &sc->r31);
- __get_user(env->gpr[HEX_REG_SA0], &sc->sa0);
- __get_user(env->gpr[HEX_REG_LC0], &sc->lc0);
- __get_user(env->gpr[HEX_REG_SA1], &sc->sa1);
- __get_user(env->gpr[HEX_REG_LC1], &sc->lc1);
- __get_user(env->gpr[HEX_REG_M0], &sc->m0);
- __get_user(env->gpr[HEX_REG_M1], &sc->m1);
- __get_user(env->gpr[HEX_REG_USR], &sc->usr);
- __get_user(env->gpr[HEX_REG_GP], &sc->gp);
- __get_user(env->gpr[HEX_REG_UGP], &sc->ugp);
- __get_user(env->gpr[HEX_REG_PC], &sc->pc);
+ __get_user(env->gpr[HEX_REG_R00], &sc->sc_regs.r0);
+ __get_user(env->gpr[HEX_REG_R01], &sc->sc_regs.r1);
+ __get_user(env->gpr[HEX_REG_R02], &sc->sc_regs.r2);
+ __get_user(env->gpr[HEX_REG_R03], &sc->sc_regs.r3);
+ __get_user(env->gpr[HEX_REG_R04], &sc->sc_regs.r4);
+ __get_user(env->gpr[HEX_REG_R05], &sc->sc_regs.r5);
+ __get_user(env->gpr[HEX_REG_R06], &sc->sc_regs.r6);
+ __get_user(env->gpr[HEX_REG_R07], &sc->sc_regs.r7);
+ __get_user(env->gpr[HEX_REG_R08], &sc->sc_regs.r8);
+ __get_user(env->gpr[HEX_REG_R09], &sc->sc_regs.r9);
+ __get_user(env->gpr[HEX_REG_R10], &sc->sc_regs.r10);
+ __get_user(env->gpr[HEX_REG_R11], &sc->sc_regs.r11);
+ __get_user(env->gpr[HEX_REG_R12], &sc->sc_regs.r12);
+ __get_user(env->gpr[HEX_REG_R13], &sc->sc_regs.r13);
+ __get_user(env->gpr[HEX_REG_R14], &sc->sc_regs.r14);
+ __get_user(env->gpr[HEX_REG_R15], &sc->sc_regs.r15);
+ __get_user(env->gpr[HEX_REG_R16], &sc->sc_regs.r16);
+ __get_user(env->gpr[HEX_REG_R17], &sc->sc_regs.r17);
+ __get_user(env->gpr[HEX_REG_R18], &sc->sc_regs.r18);
+ __get_user(env->gpr[HEX_REG_R19], &sc->sc_regs.r19);
+ __get_user(env->gpr[HEX_REG_R20], &sc->sc_regs.r20);
+ __get_user(env->gpr[HEX_REG_R21], &sc->sc_regs.r21);
+ __get_user(env->gpr[HEX_REG_R22], &sc->sc_regs.r22);
+ __get_user(env->gpr[HEX_REG_R23], &sc->sc_regs.r23);
+ __get_user(env->gpr[HEX_REG_R24], &sc->sc_regs.r24);
+ __get_user(env->gpr[HEX_REG_R25], &sc->sc_regs.r25);
+ __get_user(env->gpr[HEX_REG_R26], &sc->sc_regs.r26);
+ __get_user(env->gpr[HEX_REG_R27], &sc->sc_regs.r27);
+ __get_user(env->gpr[HEX_REG_R28], &sc->sc_regs.r28);
+ __get_user(env->gpr[HEX_REG_R29], &sc->sc_regs.r29);
+ __get_user(env->gpr[HEX_REG_R30], &sc->sc_regs.r30);
+ __get_user(env->gpr[HEX_REG_R31], &sc->sc_regs.r31);
+ __get_user(env->gpr[HEX_REG_SA0], &sc->sc_regs.sa0);
+ __get_user(env->gpr[HEX_REG_LC0], &sc->sc_regs.lc0);
+ __get_user(env->gpr[HEX_REG_SA1], &sc->sc_regs.sa1);
+ __get_user(env->gpr[HEX_REG_LC1], &sc->sc_regs.lc1);
+ __get_user(env->gpr[HEX_REG_M0], &sc->sc_regs.m0);
+ __get_user(env->gpr[HEX_REG_M1], &sc->sc_regs.m1);
+ __get_user(env->gpr[HEX_REG_USR], &sc->sc_regs.usr);
+ __get_user(env->gpr[HEX_REG_GP], &sc->sc_regs.gp);
+ __get_user(env->gpr[HEX_REG_UGP], &sc->sc_regs.ugp);
+ __get_user(env->gpr[HEX_REG_PC], &sc->sc_regs.pc);
+ /* Restore predicates from p3_0 */
+ target_ulong preds;
+ __get_user(preds, &sc->sc_regs.p3_0);
int i;
for (i = 0; i < NUM_PREGS; i++) {
- __get_user(env->pred[i], &(sc->pred[i]));
+ env->pred[i] = (preds >> (i * 8)) & 0xff;
}
+
+ __get_user(env->gpr[HEX_REG_CS0], &sc->sc_regs.cs0);
+ __get_user(env->gpr[HEX_REG_CS1], &sc->sc_regs.cs1);
}
static void restore_ucontext(CPUHexagonState *env, struct target_ucontext *uc)
--
2.34.1
^ permalink raw reply related [flat|nested] 8+ messages in thread
* [PATCH 2/2] tests/tcg/hexagon: Add cs{0,1} coverage
2025-10-08 1:47 [PATCH 1/2] linux-user/hexagon: Fix sigcontext Brian Cain
@ 2025-10-08 1:47 ` Brian Cain
2025-10-08 15:03 ` Anton Johansson via
2025-10-08 21:51 ` ltaylorsimpson
2025-10-08 15:27 ` [PATCH 1/2] linux-user/hexagon: Fix sigcontext Anton Johansson via
2025-10-08 21:46 ` ltaylorsimpson
2 siblings, 2 replies; 8+ messages in thread
From: Brian Cain @ 2025-10-08 1:47 UTC (permalink / raw)
To: qemu-devel
Cc: brian.cain, richard.henderson, philmd, matheus.bernardino, ale,
anjo, marco.liebel, ltaylorsimpson, alex.bennee, quic_mburton,
sid.manning
Cover cs0,1 register corruption in the signal_context test case.
Signed-off-by: Brian Cain <brian.cain@oss.qualcomm.com>
---
tests/tcg/hexagon/signal_context.c | 22 +++++++++++++++++++---
1 file changed, 19 insertions(+), 3 deletions(-)
diff --git a/tests/tcg/hexagon/signal_context.c b/tests/tcg/hexagon/signal_context.c
index 7202fa64b6..00bbb3efc7 100644
--- a/tests/tcg/hexagon/signal_context.c
+++ b/tests/tcg/hexagon/signal_context.c
@@ -26,7 +26,11 @@ void sig_user(int sig, siginfo_t *info, void *puc)
"p1 = r7\n\t"
"p2 = r7\n\t"
"p3 = r7\n\t"
- : : : "r7", "p0", "p1", "p2", "p3");
+ "r6 = #0x12345678\n\t"
+ "cs0 = r6\n\t"
+ "r6 = #0x87654321\n\t"
+ "cs1 = r6\n\t"
+ : : : "r6", "r7", "p0", "p1", "p2", "p3");
}
int main()
@@ -52,7 +56,11 @@ int main()
it.it_value.tv_nsec = 100000;
timer_settime(tid, 0, &it, NULL);
- asm("loop0(1f, %1)\n\t"
+ asm("r9 = #0xdeadbeef\n\t"
+ " cs0 = r9\n\t"
+ " r9 = #0xbadc0fee\n\t"
+ " cs1 = r9\n\t"
+ " loop0(1f, %1)\n\t"
"1: r8 = #0xff\n\t"
" p0 = r8\n\t"
" p1 = r8\n\t"
@@ -74,10 +82,18 @@ int main()
" r8 = p3\n\t"
" p0 = cmp.eq(r8, #0xff)\n\t"
" if (!p0) jump 2b\n\t"
+ " r8 = cs0\n\t"
+ " r9 = #0xdeadbeef\n\t"
+ " p0 = cmp.eq(r8, r9)\n\t"
+ " if (!p0) jump 2b\n\t"
+ " r8 = cs1\n\t"
+ " r9 = #0xbadc0fee\n\t"
+ " p0 = cmp.eq(r8, r9)\n\t"
+ " if (!p0) jump 2b\n\t"
"4: {}: endloop0\n\t"
:
: "r"(&err), "r"(i)
- : "memory", "r8", "p0", "p1", "p2", "p3");
+ : "memory", "r8", "r9", "p0", "p1", "p2", "p3");
puts(err ? "FAIL" : "PASS");
return err;
--
2.34.1
^ permalink raw reply related [flat|nested] 8+ messages in thread
* Re: [PATCH 2/2] tests/tcg/hexagon: Add cs{0,1} coverage
2025-10-08 1:47 ` [PATCH 2/2] tests/tcg/hexagon: Add cs{0,1} coverage Brian Cain
@ 2025-10-08 15:03 ` Anton Johansson via
2025-10-08 21:51 ` ltaylorsimpson
1 sibling, 0 replies; 8+ messages in thread
From: Anton Johansson via @ 2025-10-08 15:03 UTC (permalink / raw)
To: Brian Cain
Cc: qemu-devel, richard.henderson, philmd, matheus.bernardino, ale,
marco.liebel, ltaylorsimpson, alex.bennee, quic_mburton,
sid.manning
On 08/10/25, Brian Cain wrote:
> Cover cs0,1 register corruption in the signal_context test case.
>
> Signed-off-by: Brian Cain <brian.cain@oss.qualcomm.com>
> ---
> tests/tcg/hexagon/signal_context.c | 22 +++++++++++++++++++---
> 1 file changed, 19 insertions(+), 3 deletions(-)
Reviewed-by: Anton Johansson <anjo@rev.ng>
^ permalink raw reply [flat|nested] 8+ messages in thread
* Re: [PATCH 1/2] linux-user/hexagon: Fix sigcontext
2025-10-08 1:47 [PATCH 1/2] linux-user/hexagon: Fix sigcontext Brian Cain
2025-10-08 1:47 ` [PATCH 2/2] tests/tcg/hexagon: Add cs{0,1} coverage Brian Cain
@ 2025-10-08 15:27 ` Anton Johansson via
2025-10-08 16:02 ` Richard Henderson
2025-10-08 21:46 ` ltaylorsimpson
2 siblings, 1 reply; 8+ messages in thread
From: Anton Johansson via @ 2025-10-08 15:27 UTC (permalink / raw)
To: Brian Cain
Cc: qemu-devel, richard.henderson, philmd, matheus.bernardino, ale,
marco.liebel, ltaylorsimpson, alex.bennee, quic_mburton,
sid.manning, Alex Rønne Petersen, Laurent Vivier
On 08/10/25, Brian Cain wrote:
> In order to correspond with the kernel, we've now (1) moved the
> preds[] to the right offset and combined the representation as a single
> ulong "p3_0", (2), added the cs{0,1} registers, (3) added a pad for 48
> words, (4) added the user regs structure to an 8-byte aligned
> target_sigcontext structure.
>
> Co-authored-by: Alex Rønne Petersen <alex@alexrp.com>
> Signed-off-by: Brian Cain <brian.cain@oss.qualcomm.com>
> ---
> linux-user/hexagon/signal.c | 199 ++++++++++++++++++++----------------
> 1 file changed, 111 insertions(+), 88 deletions(-)
>
> diff --git a/linux-user/hexagon/signal.c b/linux-user/hexagon/signal.c
> index 492b51f155..6c3dbf91fa 100644
> --- a/linux-user/hexagon/signal.c
> +++ b/linux-user/hexagon/signal.c
> @@ -23,7 +23,7 @@
> #include "signal-common.h"
> #include "linux-user/trace.h"
>
> -struct target_sigcontext {
> +struct target_user_regs_struct {
> target_ulong r0, r1, r2, r3;
> target_ulong r4, r5, r6, r7;
> target_ulong r8, r9, r10, r11;
> @@ -39,14 +39,21 @@ struct target_sigcontext {
> target_ulong m0;
> target_ulong m1;
> target_ulong usr;
> + target_ulong p3_0;
> target_ulong gp;
> target_ulong ugp;
> target_ulong pc;
> target_ulong cause;
> target_ulong badva;
> - target_ulong pred[NUM_PREGS];
> + target_ulong cs0;
> + target_ulong cs1;
> + target_ulong pad1;
> };
struct layout looks good assuming it must correspond to
`arch/hexagon/include/uapi/asm/user.h`. Add a `/* pad to 48 words */`
comment to pad1, and static assert following the struct definition
QEMU_BUILD_BUG_ON(sizeof(struct target_user_regs_struct) != 48*4);
>
> +struct target_sigcontext {
> + struct target_user_regs_struct sc_regs;
> +} __attribute__((aligned(8)));
Use QEMU_ALIGNED(8)
> +
> struct target_ucontext {
> unsigned long uc_flags;
> target_ulong uc_link; /* target pointer */
> @@ -76,53 +83,63 @@ static abi_ulong get_sigframe(struct target_sigaction *ka,
>
> static void setup_sigcontext(struct target_sigcontext *sc, CPUHexagonState *env)
> {
> - __put_user(env->gpr[HEX_REG_R00], &sc->r0);
[...]
> + __put_user(env->gpr[HEX_REG_PC], &sc->sc_regs.pc);
>
> + /* Consolidate predicates into p3_0 */
> + target_ulong preds = 0;
Declare `preds` at the top of the function.
> int i;
> for (i = 0; i < NUM_PREGS; i++) {
int i = 0 inside the for loop is fine
> - __put_user(env->pred[i], &(sc->pred[i]));
> + preds |= (env->pred[i] & 0xff) << (i * 8);
> }
> + __put_user(preds, &sc->sc_regs.p3_0);
> +
> + /* Set cause and badva to 0 - these are set by kernel on exceptions */
> + __put_user(0, &sc->sc_regs.cause);
> + __put_user(0, &sc->sc_regs.badva);
> +
> + __put_user(env->gpr[HEX_REG_CS0], &sc->sc_regs.cs0);
> + __put_user(env->gpr[HEX_REG_CS1], &sc->sc_regs.cs1);
> }
>
> static void setup_ucontext(struct target_ucontext *uc,
> @@ -192,53 +209,59 @@ badframe:
> static void restore_sigcontext(CPUHexagonState *env,
> struct target_sigcontext *sc)
> {
[...]
>
> + /* Restore predicates from p3_0 */
> + target_ulong preds;
> + __get_user(preds, &sc->sc_regs.p3_0);
> int i;
> for (i = 0; i < NUM_PREGS; i++) {
> - __get_user(env->pred[i], &(sc->pred[i]));
> + env->pred[i] = (preds >> (i * 8)) & 0xff;
> }
Same here with preds at the top of the function and i declared in the
for statement.
> +
> + __get_user(env->gpr[HEX_REG_CS0], &sc->sc_regs.cs0);
> + __get_user(env->gpr[HEX_REG_CS1], &sc->sc_regs.cs1);
> }
>
> static void restore_ucontext(CPUHexagonState *env, struct target_ucontext *uc)
> --
> 2.34.1
>
Other than that
Reviewed-by: Anton Johansson <anjo@rev.ng>
^ permalink raw reply [flat|nested] 8+ messages in thread
* Re: [PATCH 1/2] linux-user/hexagon: Fix sigcontext
2025-10-08 15:27 ` [PATCH 1/2] linux-user/hexagon: Fix sigcontext Anton Johansson via
@ 2025-10-08 16:02 ` Richard Henderson
0 siblings, 0 replies; 8+ messages in thread
From: Richard Henderson @ 2025-10-08 16:02 UTC (permalink / raw)
To: Anton Johansson, Brian Cain
Cc: qemu-devel, philmd, matheus.bernardino, ale, marco.liebel,
ltaylorsimpson, alex.bennee, quic_mburton, sid.manning,
Alex Rønne Petersen, Laurent Vivier
On 10/8/25 08:27, Anton Johansson wrote:
> On 08/10/25, Brian Cain wrote:
>> In order to correspond with the kernel, we've now (1) moved the
>> preds[] to the right offset and combined the representation as a single
>> ulong "p3_0", (2), added the cs{0,1} registers, (3) added a pad for 48
>> words, (4) added the user regs structure to an 8-byte aligned
>> target_sigcontext structure.
>>
>> Co-authored-by: Alex Rønne Petersen <alex@alexrp.com>
>> Signed-off-by: Brian Cain <brian.cain@oss.qualcomm.com>
>> ---
>> linux-user/hexagon/signal.c | 199 ++++++++++++++++++++----------------
>> 1 file changed, 111 insertions(+), 88 deletions(-)
>>
>> diff --git a/linux-user/hexagon/signal.c b/linux-user/hexagon/signal.c
>> index 492b51f155..6c3dbf91fa 100644
>> --- a/linux-user/hexagon/signal.c
>> +++ b/linux-user/hexagon/signal.c
>> @@ -23,7 +23,7 @@
>> #include "signal-common.h"
>> #include "linux-user/trace.h"
>>
>> -struct target_sigcontext {
>> +struct target_user_regs_struct {
>> target_ulong r0, r1, r2, r3;
>> target_ulong r4, r5, r6, r7;
>> target_ulong r8, r9, r10, r11;
>> @@ -39,14 +39,21 @@ struct target_sigcontext {
>> target_ulong m0;
>> target_ulong m1;
>> target_ulong usr;
>> + target_ulong p3_0;
>> target_ulong gp;
>> target_ulong ugp;
>> target_ulong pc;
>> target_ulong cause;
>> target_ulong badva;
>> - target_ulong pred[NUM_PREGS];
>> + target_ulong cs0;
>> + target_ulong cs1;
>> + target_ulong pad1;
>> };
>
> struct layout looks good assuming it must correspond to
> `arch/hexagon/include/uapi/asm/user.h`. Add a `/* pad to 48 words */`
> comment to pad1, and static assert following the struct definition
>
> QEMU_BUILD_BUG_ON(sizeof(struct target_user_regs_struct) != 48*4);
As long as you're fixing things, all of these target_ulong should be abi_ulong, because
user_regs_struct uses 'unsigned long'.
r~
^ permalink raw reply [flat|nested] 8+ messages in thread
* RE: [PATCH 1/2] linux-user/hexagon: Fix sigcontext
2025-10-08 1:47 [PATCH 1/2] linux-user/hexagon: Fix sigcontext Brian Cain
2025-10-08 1:47 ` [PATCH 2/2] tests/tcg/hexagon: Add cs{0,1} coverage Brian Cain
2025-10-08 15:27 ` [PATCH 1/2] linux-user/hexagon: Fix sigcontext Anton Johansson via
@ 2025-10-08 21:46 ` ltaylorsimpson
2 siblings, 0 replies; 8+ messages in thread
From: ltaylorsimpson @ 2025-10-08 21:46 UTC (permalink / raw)
To: 'Brian Cain', qemu-devel
Cc: richard.henderson, philmd, matheus.bernardino, ale, anjo,
marco.liebel, alex.bennee, quic_mburton, sid.manning,
'Alex Rønne Petersen', 'Laurent Vivier'
> -----Original Message-----
> From: Brian Cain <brian.cain@oss.qualcomm.com>
> Sent: Tuesday, October 7, 2025 7:48 PM
> To: qemu-devel@nongnu.org
> Cc: brian.cain@oss.qualcomm.com; richard.henderson@linaro.org;
> philmd@linaro.org; matheus.bernardino@oss.qualcomm.com; ale@rev.ng;
> anjo@rev.ng; marco.liebel@oss.qualcomm.com; ltaylorsimpson@gmail.com;
> alex.bennee@linaro.org; quic_mburton@quicinc.com;
> sid.manning@oss.qualcomm.com; Alex Rønne Petersen <alex@alexrp.com>;
> Laurent Vivier <laurent@vivier.eu>
> Subject: [PATCH 1/2] linux-user/hexagon: Fix sigcontext
>
> In order to correspond with the kernel, we've now (1) moved the preds[] to
> the right offset and combined the representation as a single ulong "p3_0", (2),
> added the cs{0,1} registers, (3) added a pad for 48 words, (4) added the user
> regs structure to an 8-byte aligned target_sigcontext structure.
Should you include the other control registers also (e.g., framekey)? Perhaps this is a bug in the kernel as well?
>
> Co-authored-by: Alex Rønne Petersen <alex@alexrp.com>
> Signed-off-by: Brian Cain <brian.cain@oss.qualcomm.com>
> ---
> linux-user/hexagon/signal.c | 199 ++++++++++++++++++++----------------
> 1 file changed, 111 insertions(+), 88 deletions(-)
>
> diff --git a/linux-user/hexagon/signal.c b/linux-user/hexagon/signal.c index
> 492b51f155..6c3dbf91fa 100644
> --- a/linux-user/hexagon/signal.c
> +++ b/linux-user/hexagon/signal.c
> @@ -23,7 +23,7 @@
> #include "signal-common.h"
> #include "linux-user/trace.h"
>
> -struct target_sigcontext {
> +struct target_user_regs_struct {
> target_ulong r0, r1, r2, r3;
> target_ulong r4, r5, r6, r7;
> target_ulong r8, r9, r10, r11;
Consider creating an array for these, then use a for loop below.
> @@ -39,14 +39,21 @@ struct target_sigcontext {
> target_ulong m0;
> target_ulong m1;
> target_ulong usr;
> + target_ulong p3_0;
> target_ulong gp;
> target_ulong ugp;
> target_ulong pc;
> target_ulong cause;
> target_ulong badva;
> - target_ulong pred[NUM_PREGS];
> + target_ulong cs0;
> + target_ulong cs1;
> + target_ulong pad1;
> };
>
> +struct target_sigcontext {
> + struct target_user_regs_struct sc_regs; }
> +__attribute__((aligned(8)));
> +
> struct target_ucontext {
> unsigned long uc_flags;
> target_ulong uc_link; /* target pointer */ @@ -76,53 +83,63 @@ static
> abi_ulong get_sigframe(struct target_sigaction *ka,
>
> static void setup_sigcontext(struct target_sigcontext *sc, CPUHexagonState
> *env) {
> - __put_user(env->gpr[HEX_REG_R00], &sc->r0);
> - __put_user(env->gpr[HEX_REG_R01], &sc->r1);
> - __put_user(env->gpr[HEX_REG_R02], &sc->r2);
> - __put_user(env->gpr[HEX_REG_R03], &sc->r3);
> - __put_user(env->gpr[HEX_REG_R04], &sc->r4);
> - __put_user(env->gpr[HEX_REG_R05], &sc->r5);
> - __put_user(env->gpr[HEX_REG_R06], &sc->r6);
> - __put_user(env->gpr[HEX_REG_R07], &sc->r7);
> - __put_user(env->gpr[HEX_REG_R08], &sc->r8);
> - __put_user(env->gpr[HEX_REG_R09], &sc->r9);
> - __put_user(env->gpr[HEX_REG_R10], &sc->r10);
> - __put_user(env->gpr[HEX_REG_R11], &sc->r11);
> - __put_user(env->gpr[HEX_REG_R12], &sc->r12);
> - __put_user(env->gpr[HEX_REG_R13], &sc->r13);
> - __put_user(env->gpr[HEX_REG_R14], &sc->r14);
> - __put_user(env->gpr[HEX_REG_R15], &sc->r15);
> - __put_user(env->gpr[HEX_REG_R16], &sc->r16);
> - __put_user(env->gpr[HEX_REG_R17], &sc->r17);
> - __put_user(env->gpr[HEX_REG_R18], &sc->r18);
> - __put_user(env->gpr[HEX_REG_R19], &sc->r19);
> - __put_user(env->gpr[HEX_REG_R20], &sc->r20);
> - __put_user(env->gpr[HEX_REG_R21], &sc->r21);
> - __put_user(env->gpr[HEX_REG_R22], &sc->r22);
> - __put_user(env->gpr[HEX_REG_R23], &sc->r23);
> - __put_user(env->gpr[HEX_REG_R24], &sc->r24);
> - __put_user(env->gpr[HEX_REG_R25], &sc->r25);
> - __put_user(env->gpr[HEX_REG_R26], &sc->r26);
> - __put_user(env->gpr[HEX_REG_R27], &sc->r27);
> - __put_user(env->gpr[HEX_REG_R28], &sc->r28);
> - __put_user(env->gpr[HEX_REG_R29], &sc->r29);
> - __put_user(env->gpr[HEX_REG_R30], &sc->r30);
> - __put_user(env->gpr[HEX_REG_R31], &sc->r31);
> - __put_user(env->gpr[HEX_REG_SA0], &sc->sa0);
> - __put_user(env->gpr[HEX_REG_LC0], &sc->lc0);
> - __put_user(env->gpr[HEX_REG_SA1], &sc->sa1);
> - __put_user(env->gpr[HEX_REG_LC1], &sc->lc1);
> - __put_user(env->gpr[HEX_REG_M0], &sc->m0);
> - __put_user(env->gpr[HEX_REG_M1], &sc->m1);
> - __put_user(env->gpr[HEX_REG_USR], &sc->usr);
> - __put_user(env->gpr[HEX_REG_GP], &sc->gp);
> - __put_user(env->gpr[HEX_REG_UGP], &sc->ugp);
> - __put_user(env->gpr[HEX_REG_PC], &sc->pc);
> + __put_user(env->gpr[HEX_REG_R00], &sc->sc_regs.r0);
> + __put_user(env->gpr[HEX_REG_R01], &sc->sc_regs.r1);
> + __put_user(env->gpr[HEX_REG_R02], &sc->sc_regs.r2);
> + __put_user(env->gpr[HEX_REG_R03], &sc->sc_regs.r3);
> + __put_user(env->gpr[HEX_REG_R04], &sc->sc_regs.r4);
> + __put_user(env->gpr[HEX_REG_R05], &sc->sc_regs.r5);
> + __put_user(env->gpr[HEX_REG_R06], &sc->sc_regs.r6);
> + __put_user(env->gpr[HEX_REG_R07], &sc->sc_regs.r7);
> + __put_user(env->gpr[HEX_REG_R08], &sc->sc_regs.r8);
> + __put_user(env->gpr[HEX_REG_R09], &sc->sc_regs.r9);
> + __put_user(env->gpr[HEX_REG_R10], &sc->sc_regs.r10);
> + __put_user(env->gpr[HEX_REG_R11], &sc->sc_regs.r11);
> + __put_user(env->gpr[HEX_REG_R12], &sc->sc_regs.r12);
> + __put_user(env->gpr[HEX_REG_R13], &sc->sc_regs.r13);
> + __put_user(env->gpr[HEX_REG_R14], &sc->sc_regs.r14);
> + __put_user(env->gpr[HEX_REG_R15], &sc->sc_regs.r15);
> + __put_user(env->gpr[HEX_REG_R16], &sc->sc_regs.r16);
> + __put_user(env->gpr[HEX_REG_R17], &sc->sc_regs.r17);
> + __put_user(env->gpr[HEX_REG_R18], &sc->sc_regs.r18);
> + __put_user(env->gpr[HEX_REG_R19], &sc->sc_regs.r19);
> + __put_user(env->gpr[HEX_REG_R20], &sc->sc_regs.r20);
> + __put_user(env->gpr[HEX_REG_R21], &sc->sc_regs.r21);
> + __put_user(env->gpr[HEX_REG_R22], &sc->sc_regs.r22);
> + __put_user(env->gpr[HEX_REG_R23], &sc->sc_regs.r23);
> + __put_user(env->gpr[HEX_REG_R24], &sc->sc_regs.r24);
> + __put_user(env->gpr[HEX_REG_R25], &sc->sc_regs.r25);
> + __put_user(env->gpr[HEX_REG_R26], &sc->sc_regs.r26);
> + __put_user(env->gpr[HEX_REG_R27], &sc->sc_regs.r27);
> + __put_user(env->gpr[HEX_REG_R28], &sc->sc_regs.r28);
> + __put_user(env->gpr[HEX_REG_R29], &sc->sc_regs.r29);
> + __put_user(env->gpr[HEX_REG_R30], &sc->sc_regs.r30);
> + __put_user(env->gpr[HEX_REG_R31], &sc->sc_regs.r31);
Replace the above with a for loop when the GPRs are declared as an array.
> + __put_user(env->gpr[HEX_REG_SA0], &sc->sc_regs.sa0);
> + __put_user(env->gpr[HEX_REG_LC0], &sc->sc_regs.lc0);
> + __put_user(env->gpr[HEX_REG_SA1], &sc->sc_regs.sa1);
> + __put_user(env->gpr[HEX_REG_LC1], &sc->sc_regs.lc1);
> + __put_user(env->gpr[HEX_REG_M0], &sc->sc_regs.m0);
> + __put_user(env->gpr[HEX_REG_M1], &sc->sc_regs.m1);
> + __put_user(env->gpr[HEX_REG_USR], &sc->sc_regs.usr);
> + __put_user(env->gpr[HEX_REG_GP], &sc->sc_regs.gp);
> + __put_user(env->gpr[HEX_REG_UGP], &sc->sc_regs.ugp);
> + __put_user(env->gpr[HEX_REG_PC], &sc->sc_regs.pc);
>
> + /* Consolidate predicates into p3_0 */
> + target_ulong preds = 0;
> int i;
> for (i = 0; i < NUM_PREGS; i++) {
> - __put_user(env->pred[i], &(sc->pred[i]));
> + preds |= (env->pred[i] & 0xff) << (i * 8);
> }
> + __put_user(preds, &sc->sc_regs.p3_0);
> +
> + /* Set cause and badva to 0 - these are set by kernel on exceptions */
> + __put_user(0, &sc->sc_regs.cause);
> + __put_user(0, &sc->sc_regs.badva);
Strange that we have this if they are ignored. Perhaps it's to match the kernel behavior.
> +
> + __put_user(env->gpr[HEX_REG_CS0], &sc->sc_regs.cs0);
> + __put_user(env->gpr[HEX_REG_CS1], &sc->sc_regs.cs1);
> }
>
> static void setup_ucontext(struct target_ucontext *uc, @@ -192,53 +209,59
> @@ badframe:
> static void restore_sigcontext(CPUHexagonState *env,
> struct target_sigcontext *sc) {
> - __get_user(env->gpr[HEX_REG_R00], &sc->r0);
> - __get_user(env->gpr[HEX_REG_R01], &sc->r1);
> - __get_user(env->gpr[HEX_REG_R02], &sc->r2);
> - __get_user(env->gpr[HEX_REG_R03], &sc->r3);
> - __get_user(env->gpr[HEX_REG_R04], &sc->r4);
> - __get_user(env->gpr[HEX_REG_R05], &sc->r5);
> - __get_user(env->gpr[HEX_REG_R06], &sc->r6);
> - __get_user(env->gpr[HEX_REG_R07], &sc->r7);
> - __get_user(env->gpr[HEX_REG_R08], &sc->r8);
> - __get_user(env->gpr[HEX_REG_R09], &sc->r9);
> - __get_user(env->gpr[HEX_REG_R10], &sc->r10);
> - __get_user(env->gpr[HEX_REG_R11], &sc->r11);
> - __get_user(env->gpr[HEX_REG_R12], &sc->r12);
> - __get_user(env->gpr[HEX_REG_R13], &sc->r13);
> - __get_user(env->gpr[HEX_REG_R14], &sc->r14);
> - __get_user(env->gpr[HEX_REG_R15], &sc->r15);
> - __get_user(env->gpr[HEX_REG_R16], &sc->r16);
> - __get_user(env->gpr[HEX_REG_R17], &sc->r17);
> - __get_user(env->gpr[HEX_REG_R18], &sc->r18);
> - __get_user(env->gpr[HEX_REG_R19], &sc->r19);
> - __get_user(env->gpr[HEX_REG_R20], &sc->r20);
> - __get_user(env->gpr[HEX_REG_R21], &sc->r21);
> - __get_user(env->gpr[HEX_REG_R22], &sc->r22);
> - __get_user(env->gpr[HEX_REG_R23], &sc->r23);
> - __get_user(env->gpr[HEX_REG_R24], &sc->r24);
> - __get_user(env->gpr[HEX_REG_R25], &sc->r25);
> - __get_user(env->gpr[HEX_REG_R26], &sc->r26);
> - __get_user(env->gpr[HEX_REG_R27], &sc->r27);
> - __get_user(env->gpr[HEX_REG_R28], &sc->r28);
> - __get_user(env->gpr[HEX_REG_R29], &sc->r29);
> - __get_user(env->gpr[HEX_REG_R30], &sc->r30);
> - __get_user(env->gpr[HEX_REG_R31], &sc->r31);
> - __get_user(env->gpr[HEX_REG_SA0], &sc->sa0);
> - __get_user(env->gpr[HEX_REG_LC0], &sc->lc0);
> - __get_user(env->gpr[HEX_REG_SA1], &sc->sa1);
> - __get_user(env->gpr[HEX_REG_LC1], &sc->lc1);
> - __get_user(env->gpr[HEX_REG_M0], &sc->m0);
> - __get_user(env->gpr[HEX_REG_M1], &sc->m1);
> - __get_user(env->gpr[HEX_REG_USR], &sc->usr);
> - __get_user(env->gpr[HEX_REG_GP], &sc->gp);
> - __get_user(env->gpr[HEX_REG_UGP], &sc->ugp);
> - __get_user(env->gpr[HEX_REG_PC], &sc->pc);
> + __get_user(env->gpr[HEX_REG_R00], &sc->sc_regs.r0);
> + __get_user(env->gpr[HEX_REG_R01], &sc->sc_regs.r1);
> + __get_user(env->gpr[HEX_REG_R02], &sc->sc_regs.r2);
> + __get_user(env->gpr[HEX_REG_R03], &sc->sc_regs.r3);
> + __get_user(env->gpr[HEX_REG_R04], &sc->sc_regs.r4);
> + __get_user(env->gpr[HEX_REG_R05], &sc->sc_regs.r5);
> + __get_user(env->gpr[HEX_REG_R06], &sc->sc_regs.r6);
> + __get_user(env->gpr[HEX_REG_R07], &sc->sc_regs.r7);
> + __get_user(env->gpr[HEX_REG_R08], &sc->sc_regs.r8);
> + __get_user(env->gpr[HEX_REG_R09], &sc->sc_regs.r9);
> + __get_user(env->gpr[HEX_REG_R10], &sc->sc_regs.r10);
> + __get_user(env->gpr[HEX_REG_R11], &sc->sc_regs.r11);
> + __get_user(env->gpr[HEX_REG_R12], &sc->sc_regs.r12);
> + __get_user(env->gpr[HEX_REG_R13], &sc->sc_regs.r13);
> + __get_user(env->gpr[HEX_REG_R14], &sc->sc_regs.r14);
> + __get_user(env->gpr[HEX_REG_R15], &sc->sc_regs.r15);
> + __get_user(env->gpr[HEX_REG_R16], &sc->sc_regs.r16);
> + __get_user(env->gpr[HEX_REG_R17], &sc->sc_regs.r17);
> + __get_user(env->gpr[HEX_REG_R18], &sc->sc_regs.r18);
> + __get_user(env->gpr[HEX_REG_R19], &sc->sc_regs.r19);
> + __get_user(env->gpr[HEX_REG_R20], &sc->sc_regs.r20);
> + __get_user(env->gpr[HEX_REG_R21], &sc->sc_regs.r21);
> + __get_user(env->gpr[HEX_REG_R22], &sc->sc_regs.r22);
> + __get_user(env->gpr[HEX_REG_R23], &sc->sc_regs.r23);
> + __get_user(env->gpr[HEX_REG_R24], &sc->sc_regs.r24);
> + __get_user(env->gpr[HEX_REG_R25], &sc->sc_regs.r25);
> + __get_user(env->gpr[HEX_REG_R26], &sc->sc_regs.r26);
> + __get_user(env->gpr[HEX_REG_R27], &sc->sc_regs.r27);
> + __get_user(env->gpr[HEX_REG_R28], &sc->sc_regs.r28);
> + __get_user(env->gpr[HEX_REG_R29], &sc->sc_regs.r29);
> + __get_user(env->gpr[HEX_REG_R30], &sc->sc_regs.r30);
> + __get_user(env->gpr[HEX_REG_R31], &sc->sc_regs.r31);
Replace the above with a for loop when the GPRs are declared as an array.
> + __get_user(env->gpr[HEX_REG_SA0], &sc->sc_regs.sa0);
> + __get_user(env->gpr[HEX_REG_LC0], &sc->sc_regs.lc0);
> + __get_user(env->gpr[HEX_REG_SA1], &sc->sc_regs.sa1);
> + __get_user(env->gpr[HEX_REG_LC1], &sc->sc_regs.lc1);
> + __get_user(env->gpr[HEX_REG_M0], &sc->sc_regs.m0);
> + __get_user(env->gpr[HEX_REG_M1], &sc->sc_regs.m1);
> + __get_user(env->gpr[HEX_REG_USR], &sc->sc_regs.usr);
> + __get_user(env->gpr[HEX_REG_GP], &sc->sc_regs.gp);
> + __get_user(env->gpr[HEX_REG_UGP], &sc->sc_regs.ugp);
> + __get_user(env->gpr[HEX_REG_PC], &sc->sc_regs.pc);
>
> + /* Restore predicates from p3_0 */
> + target_ulong preds;
> + __get_user(preds, &sc->sc_regs.p3_0);
> int i;
> for (i = 0; i < NUM_PREGS; i++) {
> - __get_user(env->pred[i], &(sc->pred[i]));
> + env->pred[i] = (preds >> (i * 8)) & 0xff;
> }
> +
> + __get_user(env->gpr[HEX_REG_CS0], &sc->sc_regs.cs0);
> + __get_user(env->gpr[HEX_REG_CS1], &sc->sc_regs.cs1);
> }
>
> static void restore_ucontext(CPUHexagonState *env, struct target_ucontext
> *uc)
> --
> 2.34.1
^ permalink raw reply [flat|nested] 8+ messages in thread
* RE: [PATCH 2/2] tests/tcg/hexagon: Add cs{0,1} coverage
2025-10-08 1:47 ` [PATCH 2/2] tests/tcg/hexagon: Add cs{0,1} coverage Brian Cain
2025-10-08 15:03 ` Anton Johansson via
@ 2025-10-08 21:51 ` ltaylorsimpson
2025-10-10 18:40 ` Brian Cain
1 sibling, 1 reply; 8+ messages in thread
From: ltaylorsimpson @ 2025-10-08 21:51 UTC (permalink / raw)
To: 'Brian Cain', qemu-devel
Cc: richard.henderson, philmd, matheus.bernardino, ale, anjo,
marco.liebel, alex.bennee, quic_mburton, sid.manning
> -----Original Message-----
> From: Brian Cain <brian.cain@oss.qualcomm.com>
> Sent: Tuesday, October 7, 2025 7:48 PM
> To: qemu-devel@nongnu.org
> Cc: brian.cain@oss.qualcomm.com; richard.henderson@linaro.org;
> philmd@linaro.org; matheus.bernardino@oss.qualcomm.com; ale@rev.ng;
> anjo@rev.ng; marco.liebel@oss.qualcomm.com; ltaylorsimpson@gmail.com;
> alex.bennee@linaro.org; quic_mburton@quicinc.com;
> sid.manning@oss.qualcomm.com
> Subject: [PATCH 2/2] tests/tcg/hexagon: Add cs{0,1} coverage
>
> Cover cs0,1 register corruption in the signal_context test case.
>
> Signed-off-by: Brian Cain <brian.cain@oss.qualcomm.com>
> ---
> tests/tcg/hexagon/signal_context.c | 22 +++++++++++++++++++---
> 1 file changed, 19 insertions(+), 3 deletions(-)
>
> diff --git a/tests/tcg/hexagon/signal_context.c
> b/tests/tcg/hexagon/signal_context.c
> index 7202fa64b6..00bbb3efc7 100644
> --- a/tests/tcg/hexagon/signal_context.c
> +++ b/tests/tcg/hexagon/signal_context.c
> @@ -26,7 +26,11 @@ void sig_user(int sig, siginfo_t *info, void *puc)
> "p1 = r7\n\t"
> "p2 = r7\n\t"
> "p3 = r7\n\t"
> - : : : "r7", "p0", "p1", "p2", "p3");
> + "r6 = #0x12345678\n\t"
> + "cs0 = r6\n\t"
> + "r6 = #0x87654321\n\t"
> + "cs1 = r6\n\t"
> + : : : "r6", "r7", "p0", "p1", "p2", "p3");
Add cs0, cs1 to the clobber list.
> }
>
> int main()
> @@ -52,7 +56,11 @@ int main()
> it.it_value.tv_nsec = 100000;
> timer_settime(tid, 0, &it, NULL);
>
> - asm("loop0(1f, %1)\n\t"
> + asm("r9 = #0xdeadbeef\n\t"
> + " cs0 = r9\n\t"
> + " r9 = #0xbadc0fee\n\t"
> + " cs1 = r9\n\t"
Should these be inside the loop?
> + " loop0(1f, %1)\n\t"
> "1: r8 = #0xff\n\t"
> " p0 = r8\n\t"
> " p1 = r8\n\t"
> @@ -74,10 +82,18 @@ int main()
> " r8 = p3\n\t"
> " p0 = cmp.eq(r8, #0xff)\n\t"
> " if (!p0) jump 2b\n\t"
> + " r8 = cs0\n\t"
> + " r9 = #0xdeadbeef\n\t"
> + " p0 = cmp.eq(r8, r9)\n\t"
> + " if (!p0) jump 2b\n\t"
> + " r8 = cs1\n\t"
> + " r9 = #0xbadc0fee\n\t"
> + " p0 = cmp.eq(r8, r9)\n\t"
> + " if (!p0) jump 2b\n\t"
> "4: {}: endloop0\n\t"
> :
> : "r"(&err), "r"(i)
> - : "memory", "r8", "p0", "p1", "p2", "p3");
> + : "memory", "r8", "r9", "p0", "p1", "p2", "p3");
Add cs0, cs1 to the clobber list. Also, add sa0, lc0 due to the loop0 instruction.
>
> puts(err ? "FAIL" : "PASS");
> return err;
> --
> 2.34.1
^ permalink raw reply [flat|nested] 8+ messages in thread
* Re: [PATCH 2/2] tests/tcg/hexagon: Add cs{0,1} coverage
2025-10-08 21:51 ` ltaylorsimpson
@ 2025-10-10 18:40 ` Brian Cain
0 siblings, 0 replies; 8+ messages in thread
From: Brian Cain @ 2025-10-10 18:40 UTC (permalink / raw)
To: ltaylorsimpson, qemu-devel
Cc: richard.henderson, philmd, matheus.bernardino, ale, anjo,
marco.liebel, alex.bennee, quic_mburton, sid.manning
On 10/8/2025 4:51 PM, ltaylorsimpson@gmail.com wrote:
>
>> -----Original Message-----
>> From: Brian Cain <brian.cain@oss.qualcomm.com>
>> Sent: Tuesday, October 7, 2025 7:48 PM
>> To: qemu-devel@nongnu.org
>> Cc: brian.cain@oss.qualcomm.com; richard.henderson@linaro.org;
>> philmd@linaro.org; matheus.bernardino@oss.qualcomm.com; ale@rev.ng;
>> anjo@rev.ng; marco.liebel@oss.qualcomm.com; ltaylorsimpson@gmail.com;
>> alex.bennee@linaro.org; quic_mburton@quicinc.com;
>> sid.manning@oss.qualcomm.com
>> Subject: [PATCH 2/2] tests/tcg/hexagon: Add cs{0,1} coverage
>>
>> Cover cs0,1 register corruption in the signal_context test case.
>>
>> Signed-off-by: Brian Cain <brian.cain@oss.qualcomm.com>
>> ---
>> tests/tcg/hexagon/signal_context.c | 22 +++++++++++++++++++---
>> 1 file changed, 19 insertions(+), 3 deletions(-)
>>
>> diff --git a/tests/tcg/hexagon/signal_context.c
>> b/tests/tcg/hexagon/signal_context.c
>> index 7202fa64b6..00bbb3efc7 100644
>> --- a/tests/tcg/hexagon/signal_context.c
>> +++ b/tests/tcg/hexagon/signal_context.c
>> @@ -26,7 +26,11 @@ void sig_user(int sig, siginfo_t *info, void *puc)
>> "p1 = r7\n\t"
>> "p2 = r7\n\t"
>> "p3 = r7\n\t"
>> - : : : "r7", "p0", "p1", "p2", "p3");
>> + "r6 = #0x12345678\n\t"
>> + "cs0 = r6\n\t"
>> + "r6 = #0x87654321\n\t"
>> + "cs1 = r6\n\t"
>> + : : : "r6", "r7", "p0", "p1", "p2", "p3");
> Add cs0, cs1 to the clobber list.
I will fix it.
>> }
>>
>> int main()
>> @@ -52,7 +56,11 @@ int main()
>> it.it_value.tv_nsec = 100000;
>> timer_settime(tid, 0, &it, NULL);
>>
>> - asm("loop0(1f, %1)\n\t"
>> + asm("r9 = #0xdeadbeef\n\t"
>> + " cs0 = r9\n\t"
>> + " r9 = #0xbadc0fee\n\t"
>> + " cs1 = r9\n\t"
> Should these be inside the loop?
I think I might've misunderstood the design of the test case. So yes I
think so. I will look into this.
>
>> + " loop0(1f, %1)\n\t"
>> "1: r8 = #0xff\n\t"
>> " p0 = r8\n\t"
>> " p1 = r8\n\t"
>> @@ -74,10 +82,18 @@ int main()
>> " r8 = p3\n\t"
>> " p0 = cmp.eq(r8, #0xff)\n\t"
>> " if (!p0) jump 2b\n\t"
>> + " r8 = cs0\n\t"
>> + " r9 = #0xdeadbeef\n\t"
>> + " p0 = cmp.eq(r8, r9)\n\t"
>> + " if (!p0) jump 2b\n\t"
>> + " r8 = cs1\n\t"
>> + " r9 = #0xbadc0fee\n\t"
>> + " p0 = cmp.eq(r8, r9)\n\t"
>> + " if (!p0) jump 2b\n\t"
>> "4: {}: endloop0\n\t"
>> :
>> : "r"(&err), "r"(i)
>> - : "memory", "r8", "p0", "p1", "p2", "p3");
>> + : "memory", "r8", "r9", "p0", "p1", "p2", "p3");
> Add cs0, cs1 to the clobber list. Also, add sa0, lc0 due to the loop0 instruction.
>
I will fix it, thanks!
>> puts(err ? "FAIL" : "PASS");
>> return err;
>> --
>> 2.34.1
>
^ permalink raw reply [flat|nested] 8+ messages in thread
end of thread, other threads:[~2025-10-10 18:41 UTC | newest]
Thread overview: 8+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2025-10-08 1:47 [PATCH 1/2] linux-user/hexagon: Fix sigcontext Brian Cain
2025-10-08 1:47 ` [PATCH 2/2] tests/tcg/hexagon: Add cs{0,1} coverage Brian Cain
2025-10-08 15:03 ` Anton Johansson via
2025-10-08 21:51 ` ltaylorsimpson
2025-10-10 18:40 ` Brian Cain
2025-10-08 15:27 ` [PATCH 1/2] linux-user/hexagon: Fix sigcontext Anton Johansson via
2025-10-08 16:02 ` Richard Henderson
2025-10-08 21:46 ` ltaylorsimpson
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).