[PATCH v2] Cygwin: Add AArch64 support for signal handling and ucontext
Chandru Kumaresan <[email protected]> Fri, 10 Jul 2026 11:55:10 +0000
| Newsgroups | gmane.os.cygwin.patches |
|---|---|
| Message-ID | <PN0P287MB029504FE0939EFA34AEC78E592FD2@PN0P287MB0295.INDP287.PROD.OUTLOOK.COM> |
--_004_PN0P287MB029504FE0939EFA34AEC78E592FD2PN0P287MB0295INDP_
Content-Type: text/plain; charset="iso-8859-1"
Content-Transfer-Encoding: quoted-printable
Hi Everyone,
I've added inline comments to the AArch64 assembly implementation.
Thanks and Regards,
Chandru
Inline Patch
---
winsup/cygwin/exceptions.cc | 318 +++++++++++++++++++++++++++++++-----
1 file changed, 276 insertions(+), 42 deletions(-)
diff --git a/winsup/cygwin/exceptions.cc b/winsup/cygwin/exceptions.cc
index 1e129b319..cb5f1dc1d 100644
--- a/winsup/cygwin/exceptions.cc
+++ b/winsup/cygwin/exceptions.cc
@@ -1892,7 +1892,7 @@ _cygtls::call_signal_handler ()
/* In assembler: Save regs on new stack, move to alternate stack,
call thisfunc, revert stack regs. */
-#ifdef __x86_64__
+#if defined(__x86_64__)
/* Clobbered regs: rcx, rdx, r8, r9, r10, r11, rbp, rsp */
__asm__ ("\n\
movq %[NEW_SP], %%rax # Load alt stack into rax \n\
@@ -1930,6 +1930,60 @@ _cygtls::call_signal_handler ()
[FUNC] "o" (thisfunc),
[WRAPPER] "o" (altstack_wrapper)
: "memory");
+#elif defined(__aarch64__)
+ __asm__ ("\n\
+ mov x9, %[NEW_SP] // Load alt stack into x9 \n\
+ sub x9, x9, #0x60 // Make room on alt stack \n\
+ // for clobbered regs \n\
+ str x0, [x9, #0x00] // Save clobbered regs \n\
+ str x1, [x9, #0x08] \n\
+ str x2, [x9, #0x10] \n\
+ str x3, [x9, #0x18] \n\
+ str x4, [x9, #0x20] \n\
+ str x5, [x9, #0x28] \n\
+ str x6, [x9, #0x30] \n\
+ str x7, [x9, #0x38] \n\
+ str fp, [x9, #0x40] \n\
+ mov x10, sp // Copy sp into x10 for saving \n\
+ str x10, [x9, #0x48] \n\
+ str x30, [x9, #0x50] // Save link register \n\
+ mov x0, %[SIG] // thissig to 1st arg reg \n\
+ mov x1, %[SI] // &thissi to 2nd arg reg \n\
+ mov x2, %[CTX] // thiscontext to 3rd arg reg \n\
+ mov x3, %[FUNC] // thisfunc to x3 \n\
+ mov x4, %[WRAPPER] // wrapper address to x4 \n\
+ mov sp, x9 // Move alt stack into sp \n\
+ blr x4 // Call wrapper \n\
+ mov x9, sp // Restore clobbered regs \n\
+ ldr x30, [x9, #0x50] // Restore link register \n\
+ ldr x10, [x9, #0x48] \n\
+ ldr fp, [x9, #0x40] \n\
+ ldr x7, [x9, #0x38] \n\
+ ldr x6, [x9, #0x30] \n\
+ ldr x5, [x9, #0x28] \n\
+ ldr x4, [x9, #0x20] \n\
+ ldr x3, [x9, #0x18] \n\
+ ldr x2, [x9, #0x10] \n\
+ ldr x1, [x9, #0x08] \n\
+ ldr x0, [x9, #0x00] \n\
+ mov sp, x10 // Restore stack pointer \n"
+ : : [NEW_SP] "r" (new_sp),
+ [SIG] "r" (thissig),
+ [SI] "r" (&thissi),
+ [CTX] "r" (thiscontext),
+ [FUNC] "r" (thisfunc),
+ [WRAPPER] "r" (altstack_wrapper)
+ /* altstack_wrapper is an ordinary C call, so every
+ caller-saved register may be clobbered. x18 (the Windows
+ TEB pointer) and v8-v15 (callee-saved on Windows) are
+ preserved and thus omitted. */
+ : "memory", "cc",
+ "x0", "x1", "x2", "x3", "x4", "x5", "x6", "x7",
+ "x8", "x9", "x10", "x11", "x12", "x13", "x14", "x15",
+ "x16", "x17", "x29", "x30",
+ "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
+ "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
+ "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31");
#else
#error unimplemented for this target
#endif
@@ -2009,10 +2063,78 @@ setcontext (const ucontext_t *ucp)
{
PCONTEXT ctx =3D (PCONTEXT) &ucp->uc_mcontext;
set_signal_mask (_my_tls.sigmask, ucp->uc_sigmask);
+#if defined(__aarch64__)
+ /* On ARM64 Windows, RtlRestoreContext may fail (STATUS_ILLEGAL_INSTRUCT=
ION)
+ when restoring a synthetic CONTEXT that was constructed by makecontex=
t
+ rather than captured by RtlCaptureContext / GetThreadContext. This i=
s
+ because RtlRestoreContext may perform validation or use internal
+ mechanisms (e.g. stack unwinding hints) that don't work with syntheti=
c
+ contexts pointing to arbitrary PC addresses and non-thread stacks.
+
+ Instead, we manually restore all registers and branch to the saved PC=
.
+ This mirrors what glibc/musl do in their setcontext implementations
+ for aarch64-linux. */
+ register PCONTEXT base __asm__ ("x16") =3D ctx;
+ __asm__ __volatile__ ("\n\
+ add x17, x16, #272 \n\
+ ldp q0, q1, [x17, #0] \n\
+ ldp q2, q3, [x17, #32] \n\
+ ldp q4, q5, [x17, #64] \n\
+ ldp q6, q7, [x17, #96] \n\
+ ldp q8, q9, [x17, #128] \n\
+ ldp q10, q11, [x17, #160] \n\
+ ldp q12, q13, [x17, #192] \n\
+ ldp q14, q15, [x17, #224] \n\
+ ldp q16, q17, [x17, #256] \n\
+ ldp q18, q19, [x17, #288] \n\
+ ldp q20, q21, [x17, #320] \n\
+ ldp q22, q23, [x17, #352] \n\
+ ldp q24, q25, [x17, #384] \n\
+ ldp q26, q27, [x17, #416] \n\
+ ldp q28, q29, [x17, #448] \n\
+ ldp q30, q31, [x17, #480] \n\
+ /* Restore FPCR and FPSR */ \n\
+ ldr w17, [x16, #784] \n\
+ msr fpcr, x17 \n\
+ ldr w17, [x16, #788] \n\
+ msr fpsr, x17 \n\
+ /* Load PC into x17 (branch target, offset 264) */ \n\
+ ldr x17, [x16, #264] \n\
+ /* Restore callee-saved GPRs x18..x28, fp, lr */ \n\
+ ldp x18, x19, [x16, #152] \n\
+ ldp x20, x21, [x16, #168] \n\
+ ldp x22, x23, [x16, #184] \n\
+ ldp x24, x25, [x16, #200] \n\
+ ldp x26, x27, [x16, #216] \n\
+ ldp x28, x29, [x16, #232] \n\
+ ldr x30, [x16, #248] \n\
+ /* Restore caller-saved GPRs x2..x15 */ \n\
+ ldp x2, x3, [x16, #24] \n\
+ ldp x4, x5, [x16, #40] \n\
+ ldp x6, x7, [x16, #56] \n\
+ ldp x8, x9, [x16, #72] \n\
+ ldp x10, x11, [x16, #88] \n\
+ ldp x12, x13, [x16, #104] \n\
+ ldp x14, x15, [x16, #120] \n\
+ /* Restore x0, x1 */ \n\
+ ldp x0, x1, [x16, #8] \n\
+ /* Set SP from context (last use of x16 as base) */ \n\
+ ldr x16, [x16, #256] \n\
+ mov sp, x16 \n\
+ /* Branch to saved PC */ \n\
+ br x17 \n\
+"
+ : /* no outputs (noreturn) */
+ : "r" (base)
+ : "memory"
+ );
+ __builtin_unreachable ();
+#else
RtlRestoreContext (ctx, NULL);
/* If we got here, something was wrong. */
set_errno (EINVAL);
return -1;
+#endif
}
extern "C" int
@@ -2049,7 +2171,7 @@ swapcontext (ucontext_t *oucp, const ucontext_t *ucp)
/* Trampoline function to set the context to uc_link. The pointer to the
address of uc_link is stored in a callee-saved register, referenced by
_MC_uclinkReg from the C code. If uc_link is NULL, call exit. */
-#ifdef __x86_64__
+#if defined(__x86_64__)
/* _MC_uclinkReg =3D=3D %rbx */
__asm__ (" \n\
.global __cont_link_context \n\
@@ -2070,7 +2192,26 @@ __cont_link_context: \n\
nop \n\
.seh_endproc \n\
");
-
+#elif defined(__aarch64__)
+/* _MC_uclinkReg =3D=3D x19. x19 holds the address of the uc_link slot =
but is
+ only 8-byte aligned, so read through it and mask into SP in one step
+ rather than moving the unaligned value into SP first. setcontext and
+ cygwin_exit are noreturn, so tail-call them with 'b': this leaves x30
+ untouched and keeps the frame leaf, matching the empty SEH prologue. */
+__asm__ (" \n\
+ .global __cont_link_context \n\
+ .seh_proc __cont_link_context \n\
+__cont_link_context: \n\
+ .seh_endprologue \n\
+ ldr x0, [x19] \n\
+ and sp, x19, #~0xf \n\
+ cbnz x0, 1f \n\
+ mov w0, #0xff \n\
+ b cygwin_exit \n\
+1: \n\
+ b setcontext \n\
+ .seh_endproc \n"
+ );
#else
#error unimplemented for this target
#endif
@@ -2078,11 +2219,19 @@ __cont_link_context: \n\
/* makecontext is modelled after GLibc's makecontext. The stack from uc_s=
tack
is prepared so that it starts with a pointer to the linked context uc_l=
ink,
followed by the arguments to func, and finally at the bottom the "retur=
n"
- address set to __cont_link_context. In the ucp context, rbx/ebx is set=
to
- point to the stack address where the pointer to uc_link is stored. The
- requirement to make this work is that rbx/ebx are callee-saved register=
s
- per the ABI. If any function is called which doesn't follow the ABI
- conventions, e.g. assembler code, this method will break. But that's o=
k. */
+ address set to __cont_link_context.
+
+ x86_64: In the ucp context, rbx is set to point to the stack address wh=
ere
+ the pointer to uc_link is stored. The requirement to make this work is=
that
+ rbx is a callee-saved register per the ABI.
+
+ ARM64: In the ucp context, x19 is set to point to the stack address whe=
re
+ the pointer to uc_link is stored. The requirement is that x19 is a
+ callee-saved register per the ARM64 ABI.
+
+ If any function is called which doesn't follow the ABI conventions, e.g=
.
+ assembler code, this method will break. But that's ok. */
+
extern "C" void
makecontext (ucontext_t *ucp, void (*func) (void), int argc, ...)
{
@@ -2090,65 +2239,150 @@ makecontext (ucontext_t *ucp, void (*func) (void),=
int argc, ...)
uintptr_t *sp;
va_list ap;
+#if defined(__x86_64__)
+ /* x86_64: Arguments beyond the first 4 go on the stack.
+ However, we allocate shadow space for all args including register arg=
s. */
+ int stack_args =3D argc;
+
+#elif defined(__aarch64__)
+ /* ARM64: Arguments beyond the first 8 go on the stack.
+ We only allocate stack space for args beyond registers. */
+ int stack_args =3D (argc > 8) ? (argc - 8) : 0;
+
+#else
+#error unimplemented for this target
+#endif
+
/* Initialize sp to the top of the stack. */
sp =3D (uintptr_t *) ((uintptr_t) ucp->uc_stack.ss_sp + ucp->uc_stack.ss=
_size);
- /* Subtract slots required for arguments and the pointer to uc_link. */
- sp -=3D (argc + 1);
- /* Align. */
- sp =3D (uintptr_t *) ((uintptr_t) sp & ~0xf);
- /* Subtract one slot for setting the return address. */
+
+#if defined(__x86_64__)
+ /* x86_64: Subtract slots for all arguments + uc_link pointer
+ and return address. */
+ sp -=3D (stack_args + 1); /* argc + 1 for uc_link */
+ /* Align to 16 bytes. */
+ sp =3D (uintptr_t *) ((uintptr_t) sp & ~0xfUL);
+ /* Subtract one more slot for the return address. */
--sp;
- /* Set return address to the trampolin function __cont_link_context. */
+ /* Set return address to the trampoline function __cont_link_context. */
sp[0] =3D (uintptr_t) __cont_link_context;
- /* Fetch arguments and store them on the stack.
- x86_64:
+#elif defined(__aarch64__)
+ /* ARM64: Subtract slots for stack arguments + uc_link pointer. */
+ sp -=3D (stack_args + 1); /* stack_args + 1 for uc_link */
+ /* ARM64 requires 16-byte alignment at public interfaces. */
+ sp =3D (uintptr_t *) ((uintptr_t) sp & ~0xfUL);
- - Store first four args in the AMD64 ABI arg registers.
+#endif
+ /* Fetch arguments and store them.
+ x86_64:
+ - Store first four args in the AMD64 ABI arg registers (rcx, rdx, r8,=
r9).
- Note that the stack is not short by these four register args. The
reason is the shadow space for these regs required by the AMD64 ABI=
.
-
- The definition of makecontext only allows for "int" sized arguments=
to
func, 32 bit, likely for historical reasons. However, the argument
slots on x86_64 are 64 bit anyway, so we can fetch and store the ar=
gs
as 64 bit values, and func can request 64 bit args without violatin=
g
the definition. This potentially allows porting 32 bit application=
s
- providing pointer values to func without additional porting effort.=
*/
+ providing pointer values to func without additional porting effort.
+
+ ARM64:
+ - Store first eight args in ARM64 ABI arg registers (x0-x7).
+ - Arguments beyond 8 go on the stack.
+ - Similar to x86_64, we store as uintptr_t for pointer compatibility.=
*/
+
va_start (ap, argc);
for (int i =3D 0; i < argc; ++i)
-#ifdef __x86_64__
- switch (i)
- {
- case 0:
- ucp->uc_mcontext.rcx =3D va_arg (ap, uintptr_t);
- break;
- case 1:
- ucp->uc_mcontext.rdx =3D va_arg (ap, uintptr_t);
- break;
- case 2:
- ucp->uc_mcontext.r8 =3D va_arg (ap, uintptr_t);
- break;
- case 3:
- ucp->uc_mcontext.r9 =3D va_arg (ap, uintptr_t);
- break;
- default:
- sp[i + 1] =3D va_arg (ap, uintptr_t);
- break;
- }
-#else
-#error unimplemented for this target
+ {
+#if defined(__x86_64__)
+ switch (i)
+ {
+ case 0:
+ ucp->uc_mcontext.rcx =3D va_arg (ap, uintptr_t);
+ break;
+ case 1:
+ ucp->uc_mcontext.rdx =3D va_arg (ap, uintptr_t);
+ break;
+ case 2:
+ ucp->uc_mcontext.r8 =3D va_arg (ap, uintptr_t);
+ break;
+ case 3:
+ ucp->uc_mcontext.r9 =3D va_arg (ap, uintptr_t);
+ break;
+ default:
+ /* Stack arguments start at sp[i + 1] because sp[0] is return ad=
dress */
+ sp[i + 1] =3D va_arg (ap, uintptr_t);
+ break;
+ }
+
+#elif defined(__aarch64__)
+ switch (i)
+ {
+ case 0:
+ ucp->uc_mcontext.x0 =3D va_arg (ap, uintptr_t);
+ break;
+ case 1:
+ ucp->uc_mcontext.x1 =3D va_arg (ap, uintptr_t);
+ break;
+ case 2:
+ ucp->uc_mcontext.x2 =3D va_arg (ap, uintptr_t);
+ break;
+ case 3:
+ ucp->uc_mcontext.x3 =3D va_arg (ap, uintptr_t);
+ break;
+ case 4:
+ ucp->uc_mcontext.x4 =3D va_arg (ap, uintptr_t);
+ break;
+ case 5:
+ ucp->uc_mcontext.x5 =3D va_arg (ap, uintptr_t);
+ break;
+ case 6:
+ ucp->uc_mcontext.x6 =3D va_arg (ap, uintptr_t);
+ break;
+ case 7:
+ ucp->uc_mcontext.x7 =3D va_arg (ap, uintptr_t);
+ break;
+ default:
+ /* Stack arguments beyond the first 8 registers. */
+ sp[i - 8] =3D va_arg (ap, uintptr_t);
+ break;
+ }
#endif
+ }
va_end (ap);
- /* Store pointer to uc_link at the top of the stack. */
+
+#if defined(__x86_64__)
+ /* Store pointer to uc_link at sp[argc + 1], after return address
+ and args. */
sp[argc + 1] =3D (uintptr_t) ucp->uc_link;
+
+#elif defined(__aarch64__)
+ /* Store pointer to uc_link at the top of our allocated area. */
+ sp[stack_args] =3D (uintptr_t) ucp->uc_link;
+
+#endif
+
/* Last but not least set the register in the context at ucp so that a
subsequent setcontext or swapcontext picks up the right values:
- Set instruction pointer to the target function.
- Set stack pointer to the just computed stack pointer value.
- Set Cygwin-specific uclink register to the address of the pointer
- to uc_link. */
+ to uc_link.
+
+ x86_64: uclink register is rbx (callee-saved)
+ ARM64: uclink register is x19 (callee-saved) */
+
ucp->uc_mcontext._MC_instPtr =3D (uint64_t) func;
ucp->uc_mcontext._MC_stackPtr =3D (uint64_t) sp;
+
+#if defined(__x86_64__)
ucp->uc_mcontext._MC_uclinkReg =3D (uint64_t) (sp + argc + 1);
+
+#elif defined(__aarch64__)
+ /* Set LR to __cont_link_context for ARM64 (used as return address). */
+ ucp->uc_mcontext.lr =3D (uint64_t) __cont_link_context;
+ ucp->uc_mcontext._MC_uclinkReg =3D (uint64_t) (sp + stack_args);
+
+#endif
}
--
2.49.0.windows.1
--_004_PN0P287MB029504FE0939EFA34AEC78E592FD2PN0P287MB0295INDP_
Content-Type: application/octet-stream;
name="Cygwin-exceptions-Add-AArch64-support-for-signal-han.patch"
Content-Description: Cygwin-exceptions-Add-AArch64-support-for-signal-han.patch
Content-Disposition: attachment;
filename="Cygwin-exceptions-Add-AArch64-support-for-signal-han.patch";
size=15890; creation-date="Fri, 10 Jul 2026 11:54:14 GMT";
modification-date="Fri, 10 Jul 2026 11:55:10 GMT"
Content-Transfer-Encoding: base64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--_004_PN0P287MB029504FE0939EFA34AEC78E592FD2PN0P287MB0295INDP_--