mirror/zig
1
0
Fork 0
mirror of https://github.com/ziglang/zig.git synced 2025-12-06 06:13:07 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #22035 from alexrp/unwind-fixes

Browse Source 
Better unwind table support + unwind protection in `_start()` and `clone()`
This commit is contained in:
Alex Rønne Petersen 2024-12-13 03:09:24 +01:00 committed by GitHub
commit 130f7c2ed8
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
45 changed files with 361 additions and 138 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
lib/libc/musl/src/thread/aarch64/clone.s vendored
View File

@ -24,7 +24,8 @@ __clone:
// parent
ret
// child
1: ldp x1,x0,[sp],#16
1: mov fp, 0
ldp x1,x0,[sp],#16
blr x1
mov x8,#93 // SYS_exit
svc #0

3
lib/libc/musl/src/thread/arm/clone.s vendored
View File

@ -19,7 +19,8 @@ __clone:
ldmfd sp!,{r4,r5,r6,r7}
bx lr
1: mov r0,r6
1: mov fp,#0
mov r0,r6
bl 3f
2: mov r7,#1
svc 0

17
lib/libc/musl/src/thread/i386/clone.s vendored
View File

@ -30,9 +30,15 @@ __clone:
mov 8(%ebp),%ebp
int $128
test %eax,%eax
jnz 1f
jz 1f
add $16,%esp
pop %edi
pop %esi
pop %ebx
pop %ebp
ret
mov %ebp,%eax
1: mov %ebp,%eax
xor %ebp,%ebp
call *%eax
mov %eax,%ebx
@ -40,10 +46,3 @@ __clone:
inc %eax
int $128
hlt
1: add $16,%esp
pop %edi
pop %esi
pop %ebx
pop %ebp
ret

1
lib/libc/musl/src/thread/loongarch64/clone.s vendored
View File

@ -22,6 +22,7 @@ __clone:
beqz $a0, 1f # whether child process
jirl $zero, $ra, 0 # parent process return
1:
move $fp, $zero
ld.d $t8, $sp, 0 # function pointer
ld.d $a0, $sp, 8 # argument pointer
jirl $ra, $t8, 0 # call the user's function

3
lib/libc/musl/src/thread/m68k/clone.s vendored
View File

@ -18,7 +18,8 @@ __clone:
beq 1f
movem.l (%sp)+,%d2-%d5
rts
1: move.l %a1,-(%sp)
1: suba.l %%fp,%%fp
move.l %a1,-(%sp)
jsr (%a0)
move.l #1,%d0
trap #0

3
lib/libc/musl/src/thread/microblaze/clone.s vendored
View File

@ -22,7 +22,8 @@ __clone:
rtsd r15, 8
nop
1: lwi r3, r1, 0
1: add r19, r0, r0
lwi r3, r1, 0
lwi r5, r1, 4
brald r15, r3
nop

3
lib/libc/musl/src/thread/mips/clone.s vendored
View File

@ -27,7 +27,8 @@ __clone:
addu $sp, $sp, 16
jr $ra
nop
1: lw $25, 0($sp)
1: move $fp, $0
lw $25, 0($sp)
lw $4, 4($sp)
jalr $25
nop

3
lib/libc/musl/src/thread/mips64/clone.s vendored
View File

@ -25,7 +25,8 @@ __clone:
nop
jr $ra
nop
1: ld $25, 0($sp) # function pointer
1: move $fp, $0
ld $25, 0($sp) # function pointer
ld $4, 8($sp) # argument pointer
jalr $25 # call the user's function
nop

3
lib/libc/musl/src/thread/mipsn32/clone.s vendored
View File

@ -25,7 +25,8 @@ __clone:
nop
jr $ra
nop
1: lw $25, 0($sp) # function pointer
1: move $fp, $0
lw $25, 0($sp) # function pointer
lw $4, 4($sp) # argument pointer
jalr $25 # call the user's function
nop

3
lib/libc/musl/src/thread/or1k/clone.s vendored
View File

@ -23,7 +23,8 @@ __clone:
l.jr r9
l.nop
1: l.lwz r11, 0(r1)
1: l.ori r2, r0, 0
l.lwz r11, 0(r1)
l.jalr r11
l.lwz r3, 4(r1)

21
lib/libc/musl/src/thread/powerpc/clone.s vendored
View File

@ -48,9 +48,16 @@ neg 3, 3 #negate the result (errno)
# compare sc result with 0
cmpwi cr7, 3, 0
# if not 0, jump to end
bne cr7, 2f
# if not 0, restore stack and return
beq cr7, 2f
lwz 30, 0(1)
lwz 31, 4(1)
addi 1, 1, 16
blr
2:
#else: we're the child
#call funcptr: move arg (d) into r3
mr 3, 31
@ -61,13 +68,3 @@ bctrl
# mov SYS_exit into r0 (the exit param is already in r3)
li 0, 1
sc
2:
# restore stack
lwz 30, 0(1)
lwz 31, 4(1)
addi 1, 1, 16
blr

6
lib/libc/musl/src/thread/x32/clone.s vendored
View File

@ -15,12 +15,12 @@ __clone:
mov %rcx,(%rsi)
syscall
test %eax,%eax
jnz 1f
xor %ebp,%ebp
jz 1f
ret
1: xor %ebp,%ebp
pop %rdi
call *%r9
mov %eax,%edi
movl $0x4000003c,%eax /* SYS_exit */
syscall
hlt
1: ret

6
lib/libc/musl/src/thread/x86_64/clone.s vendored
View File

@ -16,8 +16,9 @@ __clone:
mov %rcx,(%rsi)
syscall
test %eax,%eax
jnz 1f
xor %ebp,%ebp
jz 1f
ret
1: xor %ebp,%ebp
pop %rdi
call *%r9
mov %eax,%edi
@ -25,4 +26,3 @@ __clone:
mov $60,%al
syscall
hlt
1: ret

10
lib/std/Build.zig
View File

@ -706,7 +706,7 @@ pub const ExecutableOptions = struct {
single_threaded: ?bool = null,
pic: ?bool = null,
strip: ?bool = null,
unwind_tables: ?bool = null,
unwind_tables: ?std.builtin.UnwindTables = null,
omit_frame_pointer: ?bool = null,
sanitize_thread: ?bool = null,
error_tracing: ?bool = null,
@ -762,7 +762,7 @@ pub const ObjectOptions = struct {
single_threaded: ?bool = null,
pic: ?bool = null,
strip: ?bool = null,
unwind_tables: ?bool = null,
unwind_tables: ?std.builtin.UnwindTables = null,
omit_frame_pointer: ?bool = null,
sanitize_thread: ?bool = null,
error_tracing: ?bool = null,
@ -810,7 +810,7 @@ pub const SharedLibraryOptions = struct {
single_threaded: ?bool = null,
pic: ?bool = null,
strip: ?bool = null,
unwind_tables: ?bool = null,
unwind_tables: ?std.builtin.UnwindTables = null,
omit_frame_pointer: ?bool = null,
sanitize_thread: ?bool = null,
error_tracing: ?bool = null,
@ -867,7 +867,7 @@ pub const StaticLibraryOptions = struct {
single_threaded: ?bool = null,
pic: ?bool = null,
strip: ?bool = null,
unwind_tables: ?bool = null,
unwind_tables: ?std.builtin.UnwindTables = null,
omit_frame_pointer: ?bool = null,
sanitize_thread: ?bool = null,
error_tracing: ?bool = null,
@ -919,7 +919,7 @@ pub const TestOptions = struct {
single_threaded: ?bool = null,
pic: ?bool = null,
strip: ?bool = null,
unwind_tables: ?bool = null,
unwind_tables: ?std.builtin.UnwindTables = null,
omit_frame_pointer: ?bool = null,
sanitize_thread: ?bool = null,
error_tracing: ?bool = null,

13
lib/std/Build/Module.zig
View File

@ -22,7 +22,7 @@ frameworks: std.StringArrayHashMapUnmanaged(LinkFrameworkOptions),
link_objects: std.ArrayListUnmanaged(LinkObject),
strip: ?bool,
unwind_tables: ?bool,
unwind_tables: ?std.builtin.UnwindTables,
single_threaded: ?bool,
stack_protector: ?bool,
stack_check: ?bool,
@ -218,7 +218,7 @@ pub const CreateOptions = struct {
link_libcpp: ?bool = null,
single_threaded: ?bool = null,
strip: ?bool = null,
unwind_tables: ?bool = null,
unwind_tables: ?std.builtin.UnwindTables = null,
dwarf_format: ?std.dwarf.Format = null,
code_model: std.builtin.CodeModel = .default,
stack_protector: ?bool = null,
@ -675,7 +675,6 @@ pub fn appendZigProcessFlags(
const b = m.owner;
try addFlag(zig_args, m.strip, "-fstrip", "-fno-strip");
try addFlag(zig_args, m.unwind_tables, "-funwind-tables", "-fno-unwind-tables");
try addFlag(zig_args, m.single_threaded, "-fsingle-threaded", "-fno-single-threaded");
try addFlag(zig_args, m.stack_check, "-fstack-check", "-fno-stack-check");
try addFlag(zig_args, m.stack_protector, "-fstack-protector", "-fno-stack-protector");
@ -695,6 +694,14 @@ pub fn appendZigProcessFlags(
});
}
if (m.unwind_tables) |unwind_tables| {
try zig_args.append(switch (unwind_tables) {
.none => "-fno-unwind-tables",
.sync => "-funwind-tables",
.@"async" => "-fasync-unwind-tables",
});
}
try zig_args.ensureUnusedCapacity(1);
if (m.optimize) |optimize| switch (optimize) {
.Debug => zig_args.appendAssumeCapacity("-ODebug"),

8
lib/std/builtin.zig
View File

@ -804,6 +804,14 @@ pub const LinkMode = enum {
dynamic,
};
/// This data structure is used by the Zig language code generation and
/// therefore must be kept in sync with the compiler implementation.
pub const UnwindTables = enum {
none,
sync,
@"async",
};
/// This data structure is used by the Zig language code generation and
/// therefore must be kept in sync with the compiler implementation.
pub const WasiExecModel = enum {

7
lib/std/os/linux/aarch64.zig
View File

@ -120,8 +120,13 @@ pub fn clone() callconv(.Naked) usize {
\\ cbz x0,1f
\\ // parent
\\ ret
\\
\\ // child
\\1: ldp x1,x0,[sp],#16
\\1: .cfi_undefined lr
\\ mov fp, 0
\\ mov lr, 0
\\
\\ ldp x1,x0,[sp],#16
\\ blr x1
\\ mov x8,#93 // SYS_exit
\\ svc #0

11
lib/std/os/linux/arm.zig
View File

@ -120,11 +120,16 @@ pub fn clone() callconv(.Naked) usize {
\\ ldmfd sp!,{r4,r5,r6,r7}
\\ bx lr
\\
\\1: mov r0,r6
\\ // https://github.com/llvm/llvm-project/issues/115891
\\1: mov r7, #0
\\ mov r11, #0
\\ mov lr, #0
\\
\\ mov r0,r6
\\ bl 3f
\\2: mov r7,#1 // SYS_exit
\\ mov r7,#1 // SYS_exit
\\ svc 0
\\ b 2b
\\
\\3: bx r5
);
}

4
lib/std/os/linux/hexagon.zig
View File

@ -118,6 +118,10 @@ pub fn clone() callconv(.Naked) usize {
\\ p0 = cmp.eq(r0, #0)
\\ if (!p0) dealloc_return
\\
\\ .cfi_undefined r31
\\ r30 = #0
\\ r31 = #0
\\
\\ r0 = r10
\\ callr r11
\\

4
lib/std/os/linux/loongarch64.zig
View File

@ -121,6 +121,10 @@ pub fn clone() callconv(.Naked) usize {
\\ beqz $a0, 1f # whether child process
\\ jirl $zero, $ra, 0 # parent process return
\\1:
\\ .cfi_undefined 1
\\ move $fp, $zero
\\ move $ra, $zero
\\
\\ ld.d $t8, $sp, 0 # function pointer
\\ ld.d $a0, $sp, 8 # argument pointer
\\ jirl $ra, $t8, 0 # call the user's function

4
lib/std/os/linux/mips.zig
View File

@ -231,6 +231,10 @@ pub fn clone() callconv(.Naked) usize {
\\ jr $ra
\\ nop
\\1:
\\ .cfi_undefined $ra
\\ move $fp, $zero
\\ move $ra, $zero
\\
\\ lw $25, 0($sp)
\\ lw $4, 4($sp)
\\ jalr $25

4
lib/std/os/linux/mips64.zig
View File

@ -210,6 +210,10 @@ pub fn clone() callconv(.Naked) usize {
\\ jr $ra
\\ nop
\\1:
\\ .cfi_undefined $ra
\\ move $fp, $zero
\\ move $ra, $zero
\\
\\ ld $25, 0($sp)
\\ ld $4, 8($sp)
\\ jalr $25

40
lib/std/os/linux/powerpc.zig
View File

@ -133,14 +133,14 @@ pub fn clone() callconv(.Naked) usize {
// syscall(SYS_clone, flags, stack, ptid, tls, ctid)
// 0 3, 4, 5, 6, 7
asm volatile (
\\ # store non-volatile regs r30, r31 on stack in order to put our
\\ # store non-volatile regs r29, r30 on stack in order to put our
\\ # start func and its arg there
\\ stwu 30, -16(1)
\\ stw 31, 4(1)
\\ stwu 29, -16(1)
\\ stw 30, 4(1)
\\
\\ # save r3 (func) into r30, and r6(arg) into r31
\\ mr 30, 3
\\ mr 31, 6
\\ # save r3 (func) into r29, and r6(arg) into r30
\\ mr 29, 3
\\ mr 30, 6
\\
\\ # create initial stack frame for new thread
\\ clrrwi 4, 4, 4
@ -167,28 +167,28 @@ pub fn clone() callconv(.Naked) usize {
\\ # compare sc result with 0
\\ cmpwi cr7, 3, 0
\\
\\ # if not 0, jump to end
\\ bne cr7, 2f
\\ # if not 0, restore stack and return
\\ beq cr7, 2f
\\ lwz 29, 0(1)
\\ lwz 30, 4(1)
\\ addi 1, 1, 16
\\ blr
\\
\\ #else: we're the child
\\ 2:
\\ .cfi_undefined lr
\\ li 31, 0
\\ mtlr 0
\\
\\ #call funcptr: move arg (d) into r3
\\ mr 3, 31
\\ #move r30 (funcptr) into CTR reg
\\ mtctr 30
\\ mr 3, 30
\\ #move r29 (funcptr) into CTR reg
\\ mtctr 29
\\ # call CTR reg
\\ bctrl
\\ # mov SYS_exit into r0 (the exit param is already in r3)
\\ li 0, 1
\\ sc
\\
\\ 2:
\\
\\ # restore stack
\\ lwz 30, 0(1)
\\ lwz 31, 4(1)
\\ addi 1, 1, 16
\\
\\ blr
);
}

7
lib/std/os/linux/powerpc64.zig
View File

@ -160,7 +160,12 @@ pub fn clone() callconv(.Naked) usize {
\\ cmpwi cr7, 3, 0
\\ bnelr cr7
\\
\\ # we're the child. call fn(arg)
\\ # we're the child
\\ .cfi_undefined lr
\\ li 31, 0
\\ mtlr 0
\\
\\ # call fn(arg)
\\ ld 3, 16(1)
\\ ld 12, 8(1)
\\ mtctr 12

6
lib/std/os/linux/riscv32.zig
View File

@ -120,7 +120,11 @@ pub fn clone() callconv(.Naked) usize {
\\ ret
\\
\\ # Child
\\1: lw a1, 0(sp)
\\1: .cfi_undefined ra
\\ mv fp, zero
\\ mv ra, zero
\\
\\ lw a1, 0(sp)
\\ lw a0, 4(sp)
\\ jalr a1
\\

6
lib/std/os/linux/riscv64.zig
View File

@ -120,7 +120,11 @@ pub fn clone() callconv(.Naked) usize {
\\ ret
\\
\\ # Child
\\1: ld a1, 0(sp)
\\1: .cfi_undefined ra
\\ mv fp, zero
\\ mv ra, zero
\\
\\ ld a1, 0(sp)
\\ ld a0, 8(sp)
\\ jalr a1
\\

7
lib/std/os/linux/s390x.zig
View File

@ -133,7 +133,12 @@ pub fn clone() callconv(.Naked) usize {
\\ltgr %%r2, %%r2
\\bnzr %%r14
\\
\\# we're the child. call fn(arg)
\\# we're the child
\\.cfi_undefined %%r14
\\lghi %%r11, 0
\\lghi %%r14, 0
\\
\\# call fn(arg)
\\lg %%r1, 8(%%r15)
\\lg %%r2, 16(%%r15)
\\basr %%r14, %%r1

21
lib/std/os/linux/sparc64.zig
View File

@ -198,29 +198,34 @@ pub fn clone() callconv(.Naked) usize {
\\ mov %%i5, %%o3
\\ ldx [%%fp + 0x8af], %%o4
\\ t 0x6d
\\ bcs,pn %%xcc, 2f
\\ bcs,pn %%xcc, 1f
\\ nop
\\ # The child pid is returned in o0 while o1 tells if this
\\ # process is # the child (=1) or the parent (=0).
\\ brnz %%o1, 1f
\\ brnz %%o1, 2f
\\ nop
\\ # Parent process, return the child pid
\\ mov %%o0, %%i0
\\ ret
\\ restore
\\1:
\\ # Child process, call func(arg)
\\ # The syscall failed
\\ sub %%g0, %%o0, %%i0
\\ ret
\\ restore
\\2:
\\ # Child process
\\ .cfi_undefined %%i7
\\ mov %%g0, %%fp
\\ mov %%g0, %%i7
\\
\\ # call func(arg)
\\ mov %%g0, %%fp
\\ call %%g2
\\ mov %%g3, %%o0
\\ # Exit
\\ mov 1, %%g1 // SYS_exit
\\ t 0x6d
\\2:
\\ # The syscall failed
\\ sub %%g0, %%o0, %%i0
\\ ret
\\ restore
);
}

19
lib/std/os/linux/x86.zig
View File

@ -148,19 +148,22 @@ pub fn clone() callconv(.Naked) usize {
\\ movl $120,%%eax // SYS_clone
\\ int $128
\\ testl %%eax,%%eax
\\ jnz 1f
\\ popl %%eax
\\ xorl %%ebp,%%ebp
\\ calll *%%eax
\\ movl %%eax,%%ebx
\\ movl $1,%%eax // SYS_exit
\\ int $128
\\1:
\\ jz 1f
\\ popl %%edi
\\ popl %%esi
\\ popl %%ebx
\\ popl %%ebp
\\ retl
\\
\\1:
\\ .cfi_undefined %%eip
\\ xorl %%ebp,%%ebp
\\
\\ popl %%eax
\\ calll *%%eax
\\ movl %%eax,%%ebx
\\ movl $1,%%eax // SYS_exit
\\ int $128
);
}

2
lib/std/os/linux/x86_64.zig
View File

@ -116,8 +116,10 @@ pub fn clone() callconv(.Naked) usize {
\\ testq %%rax,%%rax
\\ jz 1f
\\ retq
\\
\\1: .cfi_undefined %%rip
\\ xorl %%ebp,%%ebp
\\
\\ popq %%rdi
\\ callq *%%r9
\\ movl %%eax,%%edi

51
lib/std/start.zig
View File

@ -230,6 +230,29 @@ fn _start() callconv(.naked) noreturn {
);
}
// This is the first userspace frame. Prevent DWARF-based unwinders from unwinding further. We
// prevent FP-based unwinders from unwinding further by zeroing the register further below.
asm volatile (switch (native_arch) {
.arc => ".cfi_undefined blink",
.arm, .armeb, .thumb, .thumbeb => "", // https://github.com/llvm/llvm-project/issues/115891
.aarch64, .aarch64_be => ".cfi_undefined lr",
.csky => ".cfi_undefined lr",
.hexagon => ".cfi_undefined r31",
.loongarch32, .loongarch64 => ".cfi_undefined 1",
.m68k => ".cfi_undefined pc",
.mips, .mipsel, .mips64, .mips64el => ".cfi_undefined $ra",
.powerpc, .powerpcle, .powerpc64, .powerpc64le => ".cfi_undefined lr",
.riscv32, .riscv64 => if (builtin.zig_backend == .stage2_riscv64)
""
else
".cfi_undefined ra",
.s390x => ".cfi_undefined %%r14",
.sparc, .sparc64 => ".cfi_undefined %%i7",
.x86 => ".cfi_undefined %%eip",
.x86_64 => ".cfi_undefined %%rip",
else => @compileError("unsupported arch"),
});
// Move this to the riscv prong below when this is resolved: https://github.com/ziglang/zig/issues/20918
if (builtin.cpu.arch.isRISCV() and builtin.zig_backend != .stage2_riscv64) asm volatile (
\\ .weak __global_pointer$
@ -247,7 +270,6 @@ fn _start() callconv(.naked) noreturn {
// linker explicitly.
asm volatile (switch (native_arch) {
.x86_64 =>
\\ .cfi_undefined %%rip
\\ xorl %%ebp, %%ebp
\\ movq %%rsp, %%rdi
\\ andq $-16, %%rsp
@ -279,8 +301,10 @@ fn _start() callconv(.naked) noreturn {
,
.arm, .armeb, .thumb, .thumbeb =>
// Note that this code must work for Thumb-1.
// r7 = FP (local), r11 = FP (unwind)
\\ movs v1, #0
\\ mov fp, v1
\\ mov r7, v1
\\ mov r11, v1
\\ mov lr, v1
\\ mov a1, sp
\\ subs v1, #16
@ -290,20 +314,23 @@ fn _start() callconv(.naked) noreturn {
,
.csky =>
// The CSKY ABI assumes that `gb` is set to the address of the GOT in order for
// position-independent code to work. We depend on this in `std.os.linux.start_pie`
// to locate `_DYNAMIC` as well.
// position-independent code to work. We depend on this in `std.os.linux.pie` to locate
// `_DYNAMIC` as well.
// r8 = FP
\\ grs t0, 1f
\\ 1:
\\ lrw gb, 1b@GOTPC
\\ addu gb, t0
\\ movi r8, 0
\\ movi lr, 0
\\ mov a0, sp
\\ andi sp, sp, -8
\\ jmpi %[posixCallMainAndExit]
,
.hexagon =>
// r29 = SP, r30 = FP
// r29 = SP, r30 = FP, r31 = LR
\\ r30 = #0
\\ r31 = #0
\\ r0 = r29
\\ r29 = and(r29, #-16)
\\ memw(r29 + #-8) = r29
@ -312,12 +339,13 @@ fn _start() callconv(.naked) noreturn {
,
.loongarch32, .loongarch64 =>
\\ move $fp, $zero
\\ move $ra, $zero
\\ move $a0, $sp
\\ bstrins.d $sp, $zero, 3, 0
\\ b %[posixCallMainAndExit]
,
.riscv32, .riscv64 =>
\\ li s0, 0
\\ li fp, 0
\\ li ra, 0
\\ mv a0, sp
\\ andi sp, sp, -16
@ -371,28 +399,35 @@ fn _start() callconv(.naked) noreturn {
,
.powerpc, .powerpcle =>
// Set up the initial stack frame, and clear the back chain pointer.
// r1 = SP, r31 = FP
\\ mr 3, 1
\\ clrrwi 1, 1, 4
\\ li 0, 0
\\ stwu 1, -16(1)
\\ stw 0, 0(1)
\\ li 31, 0
\\ mtlr 0
\\ b %[posixCallMainAndExit]
,
.powerpc64, .powerpc64le =>
// Set up the ToC and initial stack frame, and clear the back chain pointer.
// r1 = SP, r2 = ToC, r31 = FP
\\ addis 2, 12, .TOC. - %[_start]@ha
\\ addi 2, 2, .TOC. - %[_start]@l
\\ mr 3, 1
\\ clrrdi 1, 1, 4
\\ li 0, 0
\\ stdu 0, -32(1)
\\ li 31, 0
\\ mtlr 0
\\ b %[posixCallMainAndExit]
\\ nop
,
.s390x =>
// Set up the stack frame (register save area and cleared back-chain slot).
// r11 = FP, r14 = LR, r15 = SP
\\ lghi %%r11, 0
\\ lghi %%r14, 0
\\ lgr %%r2, %%r15
\\ lghi %%r0, -16
\\ ngr %%r15, %%r0
@ -403,7 +438,9 @@ fn _start() callconv(.naked) noreturn {
,
.sparc =>
// argc is stored after a register window (16 registers * 4 bytes).
// i7 = LR
\\ mov %%g0, %%fp
\\ mov %%g0, %%i7
\\ add %%sp, 64, %%o0
\\ and %%sp, -8, %%sp
\\ ba,a %[posixCallMainAndExit]
@ -411,7 +448,9 @@ fn _start() callconv(.naked) noreturn {
.sparc64 =>
// argc is stored after a register window (16 registers * 8 bytes) plus the stack bias
// (2047 bytes).
// i7 = LR
\\ mov %%g0, %%fp
\\ mov %%g0, %%i7
\\ add %%sp, 2175, %%o0
\\ add %%sp, 2047, %%sp
\\ and %%sp, -16, %%sp

3
src/Builtin.zig
View File

@ -2,6 +2,7 @@ target: std.Target,
zig_backend: std.builtin.CompilerBackend,
output_mode: std.builtin.OutputMode,
link_mode: std.builtin.LinkMode,
unwind_tables: std.builtin.UnwindTables,
is_test: bool,
single_threaded: bool,
link_libc: bool,
@ -40,6 +41,7 @@ pub fn append(opts: @This(), buffer: *std.ArrayList(u8)) Allocator.Error!void {
\\
\\pub const output_mode: std.builtin.OutputMode = .{p_};
\\pub const link_mode: std.builtin.LinkMode = .{p_};
\\pub const unwind_tables: std.builtin.UnwindTables = .{p_};
\\pub const is_test = {};
\\pub const single_threaded = {};
\\pub const abi: std.Target.Abi = .{p_};
@ -53,6 +55,7 @@ pub fn append(opts: @This(), buffer: *std.ArrayList(u8)) Allocator.Error!void {
std.zig.fmtId(@tagName(zig_backend)),
std.zig.fmtId(@tagName(opts.output_mode)),
std.zig.fmtId(@tagName(opts.link_mode)),
std.zig.fmtId(@tagName(opts.unwind_tables)),
opts.is_test,
opts.single_threaded,
std.zig.fmtId(@tagName(target.abi)),

27
src/Compilation.zig
View File

@ -1261,12 +1261,15 @@ pub fn create(gpa: Allocator, arena: Allocator, options: CreateOptions) !*Compil
// The "any" values provided by resolved config only account for
// explicitly-provided settings. We now make them additionally account
// for default setting resolution.
const any_unwind_tables = options.config.any_unwind_tables or options.root_mod.unwind_tables;
const any_unwind_tables = switch (options.config.any_unwind_tables) {
.none => options.root_mod.unwind_tables,
.sync, .@"async" => |uwt| uwt,
};
const any_non_single_threaded = options.config.any_non_single_threaded or !options.root_mod.single_threaded;
const any_sanitize_thread = options.config.any_sanitize_thread or options.root_mod.sanitize_thread;
const any_fuzz = options.config.any_fuzz or options.root_mod.fuzz;
const link_eh_frame_hdr = options.link_eh_frame_hdr or any_unwind_tables;
const link_eh_frame_hdr = options.link_eh_frame_hdr or any_unwind_tables != .none;
const build_id = options.build_id orelse .none;
const link_libc = options.config.link_libc;
@ -1354,6 +1357,7 @@ pub fn create(gpa: Allocator, arena: Allocator, options: CreateOptions) !*Compil
cache.hash.add(options.config.pie);
cache.hash.add(options.config.lto);
cache.hash.add(options.config.link_mode);
cache.hash.add(options.config.any_unwind_tables);
cache.hash.add(options.function_sections);
cache.hash.add(options.data_sections);
cache.hash.add(link_libc);
@ -5553,10 +5557,17 @@ pub fn addCCArgs(
try argv.append("-Werror=date-time");
}
if (mod.unwind_tables) {
try argv.append("-funwind-tables");
} else {
try argv.append("-fno-unwind-tables");
switch (mod.unwind_tables) {
.none => {
try argv.append("-fno-unwind-tables");
try argv.append("-fno-asynchronous-unwind-tables");
},
.sync => {
// Need to override Clang's convoluted default logic.
try argv.append("-fno-asynchronous-unwind-tables");
try argv.append("-funwind-tables");
},
.@"async" => try argv.append("-fasynchronous-unwind-tables"),
}
},
.shared_library, .ll, .bc, .unknown, .static_library, .object, .def, .zig, .res, .manifest => {},
@ -6288,6 +6299,7 @@ pub const CrtFileOptions = struct {
function_sections: ?bool = null,
data_sections: ?bool = null,
omit_frame_pointer: ?bool = null,
unwind_tables: ?std.builtin.UnwindTables = null,
pic: ?bool = null,
no_builtin: ?bool = null,
};
@ -6349,7 +6361,8 @@ pub fn build_crt_file(
// Some libcs (e.g. musl) are opinionated about -fomit-frame-pointer.
.omit_frame_pointer = options.omit_frame_pointer orelse comp.root_mod.omit_frame_pointer,
.valgrind = false,
.unwind_tables = false,
// Some libcs (e.g. MinGW) are opinionated about -funwind-tables.
.unwind_tables = options.unwind_tables orelse .none,
// Some CRT objects (e.g. musl's rcrt1.o and Scrt1.o) are opinionated about PIC.
.pic = options.pic orelse comp.root_mod.pic,
.optimize_mode = comp.compilerRtOptMode(),

24
src/Compilation/Config.zig
View File

@ -12,13 +12,14 @@ link_libunwind: bool,
/// True if and only if the c_source_files field will have nonzero length when
/// calling Compilation.create.
any_c_source_files: bool,
/// This is true if any Module has unwind_tables set explicitly to true. Until
/// Compilation.create is called, it is possible for this to be false while in
/// fact all Module instances have unwind_tables=true due to the default
/// being unwind_tables=true. After Compilation.create is called this will
/// also take into account the default setting, making this value true if and
/// only if any Module has unwind_tables set to true.
any_unwind_tables: bool,
/// This is not `.none` if any `Module` has `unwind_tables` set explicitly to a
/// value other than `.none`. Until `Compilation.create()` is called, it is
/// possible for this to be `.none` while in fact all `Module` instances have
/// `unwind_tables != .none` due to the default. After `Compilation.create()` is
/// called, this will also take into account the default setting, making this
/// value `.sync` or `.@"async"` if and only if any `Module` has
/// `unwind_tables != .none`.
any_unwind_tables: std.builtin.UnwindTables,
/// This is true if any Module has single_threaded set explicitly to false. Until
/// Compilation.create is called, it is possible for this to be false while in
/// fact all Module instances have single_threaded=false due to the default
@ -85,7 +86,7 @@ pub const Options = struct {
any_non_single_threaded: bool = false,
any_sanitize_thread: bool = false,
any_fuzz: bool = false,
any_unwind_tables: bool = false,
any_unwind_tables: std.builtin.UnwindTables = .none,
any_dyn_libs: bool = false,
any_c_source_files: bool = false,
any_non_stripped: bool = false,
@ -356,8 +357,11 @@ pub fn resolve(options: Options) ResolveError!Config {
break :b false;
};
const any_unwind_tables = options.any_unwind_tables or
link_libunwind or target_util.needUnwindTables(target);
const any_unwind_tables = b: {
if (options.any_unwind_tables != .none) break :b options.any_unwind_tables;
break :b target_util.needUnwindTables(target, link_libunwind, options.any_sanitize_thread);
};
const link_mode = b: {
const explicitly_exe_or_dyn_lib = switch (options.output_mode) {

7
src/Package/Module.zig
View File

@ -27,7 +27,7 @@ red_zone: bool,
sanitize_c: bool,
sanitize_thread: bool,
fuzz: bool,
unwind_tables: bool,
unwind_tables: std.builtin.UnwindTables,
cc_argv: []const []const u8,
/// (SPIR-V) whether to generate a structured control flow graph or not
structured_cfg: bool,
@ -91,7 +91,7 @@ pub const CreateOptions = struct {
/// other number means stack protection with that buffer size.
stack_protector: ?u32 = null,
red_zone: ?bool = null,
unwind_tables: ?bool = null,
unwind_tables: ?std.builtin.UnwindTables = null,
sanitize_c: ?bool = null,
sanitize_thread: ?bool = null,
fuzz: ?bool = null,
@ -112,7 +112,7 @@ pub fn create(arena: Allocator, options: CreateOptions) !*Package.Module {
if (options.inherited.sanitize_thread == true) assert(options.global.any_sanitize_thread);
if (options.inherited.fuzz == true) assert(options.global.any_fuzz);
if (options.inherited.single_threaded == false) assert(options.global.any_non_single_threaded);
if (options.inherited.unwind_tables == true) assert(options.global.any_unwind_tables);
if (options.inherited.unwind_tables) |uwt| if (uwt != .none) assert(options.global.any_unwind_tables != .none);
if (options.inherited.error_tracing == true) assert(options.global.any_error_tracing);
const resolved_target = options.inherited.resolved_target orelse options.parent.?.resolved_target;
@ -382,6 +382,7 @@ pub fn create(arena: Allocator, options: CreateOptions) !*Package.Module {
.zig_backend = zig_backend,
.output_mode = options.global.output_mode,
.link_mode = options.global.link_mode,
.unwind_tables = options.global.any_unwind_tables,
.is_test = options.global.is_test,
.single_threaded = single_threaded,
.link_libc = options.global.link_libc,

4
src/arch/riscv64/CodeGen.zig
View File

@ -8442,6 +8442,10 @@ fn failSymbol(func: *Func, comptime format: []const u8, args: anytype) InnerErro
}
fn parseRegName(name: []const u8) ?Register {
// The `fp` alias for `s0` is awkward to fit into the current `Register` scheme, so for now we
// special-case it here.
if (std.mem.eql(u8, name, "fp")) return .s0;
return std.meta.stringToEnum(Register, name);
}

18
src/clang_options_data.zig
View File

@ -2757,7 +2757,14 @@ flagpd1("fast"),
flagpd1("fastcp"),
flagpd1("fastf"),
flagpd1("fasync-exceptions"),
flagpd1("fasynchronous-unwind-tables"),
.{
.name = "fasynchronous-unwind-tables",
.syntax = .flag,
.zig_equivalent = .asynchronous_unwind_tables,
.pd1 = true,
.pd2 = false,
.psl = false,
},
flagpd1("fauto-import"),
flagpd1("fauto-profile"),
flagpd1("fauto-profile-accurate"),
@ -3247,7 +3254,14 @@ flagpd1("fno-assume-sane-operator-new"),
flagpd1("fno-assume-unique-vtables"),
flagpd1("fno-assumptions"),
flagpd1("fno-async-exceptions"),
flagpd1("fno-asynchronous-unwind-tables"),
.{
.name = "fno-asynchronous-unwind-tables",
.syntax = .flag,
.zig_equivalent = .no_asynchronous_unwind_tables,
.pd1 = true,
.pd2 = false,
.psl = false,
},
flagpd1("fno-auto-import"),
flagpd1("fno-auto-profile"),
flagpd1("fno-auto-profile-accurate"),

7
src/codegen/llvm.zig
View File

@ -3141,8 +3141,11 @@ pub const Object = struct {
} }, &o.builder);
}
try attributes.addFnAttr(.nounwind, &o.builder);
if (owner_mod.unwind_tables) {
try attributes.addFnAttr(.{ .uwtable = Builder.Attribute.UwTable.default }, &o.builder);
if (owner_mod.unwind_tables != .none) {
try attributes.addFnAttr(
.{ .uwtable = if (owner_mod.unwind_tables == .@"async") .@"async" else .sync },
&o.builder,
);
}
if (owner_mod.no_builtin) {
// The intent here is for compiler-rt and libc functions to not generate

9
src/libcxx.zig
View File

@ -397,7 +397,6 @@ pub fn buildLibCXXABI(comp: *Compilation, prog_node: std.Progress.Node) BuildErr
const optimize_mode = comp.compilerRtOptMode();
const strip = comp.compilerRtStrip();
const unwind_tables = true;
const config = Compilation.Config.resolve(.{
.output_mode = output_mode,
@ -409,7 +408,6 @@ pub fn buildLibCXXABI(comp: *Compilation, prog_node: std.Progress.Node) BuildErr
.root_optimize_mode = optimize_mode,
.root_strip = strip,
.link_libc = true,
.any_unwind_tables = unwind_tables,
.lto = comp.config.lto,
.any_sanitize_thread = comp.config.any_sanitize_thread,
}) catch |err| {
@ -440,7 +438,12 @@ pub fn buildLibCXXABI(comp: *Compilation, prog_node: std.Progress.Node) BuildErr
.valgrind = false,
.optimize_mode = optimize_mode,
.structured_cfg = comp.root_mod.structured_cfg,
.unwind_tables = unwind_tables,
// See the `-fno-exceptions` logic for WASI.
// The old 32-bit x86 variant of SEH doesn't use tables.
.unwind_tables = if (target.os.tag == .wasi or (target.cpu.arch == .x86 and target.os.tag == .windows))
.none
else
.@"async",
.pic = comp.root_mod.pic,
},
.global = config,

3
src/libunwind.zig
View File

@ -65,7 +65,8 @@ pub fn buildStaticLib(comp: *Compilation, prog_node: std.Progress.Node) BuildErr
.sanitize_c = false,
.sanitize_thread = false,
// necessary so that libunwind can unwind through its own stack frames
.unwind_tables = true,
// The old 32-bit x86 variant of SEH doesn't use tables.
.unwind_tables = if (target.cpu.arch == .x86 and target.os.tag == .windows) .none else .@"async",
.pic = if (target_util.supports_fpic(target)) true else null,
.optimize_mode = comp.compilerRtOptMode(),
},

54
src/main.zig
View File

@ -510,6 +510,7 @@ const usage_build_generic =
\\ -ffuzz Enable fuzz testing instrumentation
\\ -fno-fuzz Disable fuzz testing instrumentation
\\ -funwind-tables Always produce unwind table entries for all functions
\\ -fasync-unwind-tables Always produce asynchronous unwind table entries for all functions
\\ -fno-unwind-tables Never produce unwind table entries
\\ -ferror-tracing Enable error tracing in ReleaseFast mode
\\ -fno-error-tracing Disable error tracing in Debug and ReleaseSafe mode
@ -1385,9 +1386,11 @@ fn buildOutputType(
} else if (mem.eql(u8, arg, "-fno-lto")) {
create_module.opts.lto = false;
} else if (mem.eql(u8, arg, "-funwind-tables")) {
mod_opts.unwind_tables = true;
mod_opts.unwind_tables = .sync;
} else if (mem.eql(u8, arg, "-fasync-unwind-tables")) {
mod_opts.unwind_tables = .@"async";
} else if (mem.eql(u8, arg, "-fno-unwind-tables")) {
mod_opts.unwind_tables = false;
mod_opts.unwind_tables = .none;
} else if (mem.eql(u8, arg, "-fstack-check")) {
mod_opts.stack_check = true;
} else if (mem.eql(u8, arg, "-fno-stack-check")) {
@ -1973,8 +1976,27 @@ fn buildOutputType(
}
},
.no_stack_protector => mod_opts.stack_protector = 0,
.unwind_tables => mod_opts.unwind_tables = true,
.no_unwind_tables => mod_opts.unwind_tables = false,
// The way these unwind table options are processed in GCC and Clang is crazy
// convoluted, and we also don't know the target triple here, so this is all
// best-effort.
.unwind_tables => if (mod_opts.unwind_tables) |uwt| switch (uwt) {
.none => {
mod_opts.unwind_tables = .sync;
},
.sync, .@"async" => {},
} else {
mod_opts.unwind_tables = .sync;
},
.no_unwind_tables => mod_opts.unwind_tables = .none,
.asynchronous_unwind_tables => mod_opts.unwind_tables = .@"async",
.no_asynchronous_unwind_tables => if (mod_opts.unwind_tables) |uwt| switch (uwt) {
.none, .sync => {},
.@"async" => {
mod_opts.unwind_tables = .sync;
},
} else {
mod_opts.unwind_tables = .sync;
},
.nostdlib => {
create_module.opts.ensure_libc_on_non_freestanding = false;
create_module.opts.ensure_libcpp_on_non_freestanding = false;
@ -2788,8 +2810,15 @@ fn buildOutputType(
create_module.opts.any_sanitize_thread = true;
if (mod_opts.fuzz == true)
create_module.opts.any_fuzz = true;
if (mod_opts.unwind_tables == true)
create_module.opts.any_unwind_tables = true;
if (mod_opts.unwind_tables) |uwt| switch (uwt) {
.none => {},
.sync => if (create_module.opts.any_unwind_tables == .none) {
create_module.opts.any_unwind_tables = .sync;
},
.@"async" => {
create_module.opts.any_unwind_tables = .@"async";
},
};
if (mod_opts.strip == false)
create_module.opts.any_non_stripped = true;
if (mod_opts.error_tracing == true)
@ -5713,6 +5742,8 @@ pub const ClangArgIterator = struct {
no_lto,
unwind_tables,
no_unwind_tables,
asynchronous_unwind_tables,
no_asynchronous_unwind_tables,
nostdlib,
nostdlib_cpp,
shared,
@ -7435,8 +7466,15 @@ fn handleModArg(
create_module.opts.any_sanitize_thread = true;
if (mod_opts.fuzz == true)
create_module.opts.any_fuzz = true;
if (mod_opts.unwind_tables == true)
create_module.opts.any_unwind_tables = true;
if (mod_opts.unwind_tables) |uwt| switch (uwt) {
.none => {},
.sync => if (create_module.opts.any_unwind_tables == .none) {
create_module.opts.any_unwind_tables = .sync;
},
.@"async" => {
create_module.opts.any_unwind_tables = .@"async";
},
};
if (mod_opts.strip == false)
create_module.opts.any_non_stripped = true;
if (mod_opts.error_tracing == true)

17
src/mingw.zig
View File

@ -24,6 +24,10 @@ pub fn buildCrtFile(comp: *Compilation, crt_file: CrtFile, prog_node: std.Progre
var arena_allocator = std.heap.ArenaAllocator.init(comp.gpa);
defer arena_allocator.deinit();
const arena = arena_allocator.allocator();
const target = comp.getTarget();
// The old 32-bit x86 variant of SEH doesn't use tables.
const unwind_tables: std.builtin.UnwindTables = if (target.cpu.arch != .x86) .@"async" else .none;
switch (crt_file) {
.crt2_o => {
@ -41,7 +45,9 @@ pub fn buildCrtFile(comp: *Compilation, crt_file: CrtFile, prog_node: std.Progre
.owner = undefined,
},
};
return comp.build_crt_file("crt2", .Obj, .@"mingw-w64 crt2.o", prog_node, &files, .{});
return comp.build_crt_file("crt2", .Obj, .@"mingw-w64 crt2.o", prog_node, &files, .{
.unwind_tables = unwind_tables,
});
},
.dllcrt2_o => {
@ -56,7 +62,9 @@ pub fn buildCrtFile(comp: *Compilation, crt_file: CrtFile, prog_node: std.Progre
.owner = undefined,
},
};
return comp.build_crt_file("dllcrt2", .Obj, .@"mingw-w64 dllcrt2.o", prog_node, &files, .{});
return comp.build_crt_file("dllcrt2", .Obj, .@"mingw-w64 dllcrt2.o", prog_node, &files, .{
.unwind_tables = unwind_tables,
});
},
.mingw32_lib => {
@ -73,7 +81,6 @@ pub fn buildCrtFile(comp: *Compilation, crt_file: CrtFile, prog_node: std.Progre
.owner = undefined,
});
}
const target = comp.getTarget();
if (target.cpu.arch == .x86 or target.cpu.arch == .x86_64) {
for (mingw32_x86_src) |dep| {
try c_source_files.append(.{
@ -118,7 +125,9 @@ pub fn buildCrtFile(comp: *Compilation, crt_file: CrtFile, prog_node: std.Progre
} else {
@panic("unsupported arch");
}
return comp.build_crt_file("mingw32", .Lib, .@"mingw-w64 mingw32.lib", prog_node, c_source_files.items, .{});
return comp.build_crt_file("mingw32", .Lib, .@"mingw-w64 mingw32.lib", prog_node, c_source_files.items, .{
.unwind_tables = unwind_tables,
});
},
}
}

13
src/target.zig
View File

@ -4,6 +4,7 @@ const assert = std.debug.assert;
const Type = @import("Type.zig");
const AddressSpace = std.builtin.AddressSpace;
const Alignment = @import("InternPool.zig").Alignment;
const Compilation = @import("Compilation.zig");
const Feature = @import("Zcu.zig").Feature;
pub const default_stack_protector_buffer_size = 4;
@ -408,8 +409,16 @@ pub fn clangSupportsNoImplicitFloatArg(target: std.Target) bool {
};
}
pub fn needUnwindTables(target: std.Target) bool {
return target.os.tag == .windows or target.isDarwin() or std.debug.Dwarf.abi.supportsUnwinding(target);
pub fn needUnwindTables(target: std.Target, libunwind: bool, libtsan: bool) std.builtin.UnwindTables {
if (target.os.tag == .windows) {
// The old 32-bit x86 variant of SEH doesn't use tables.
return if (target.cpu.arch != .x86) .@"async" else .none;
}
if (target.os.tag.isDarwin()) return .@"async";
if (libunwind) return .@"async";
if (libtsan) return .@"async";
if (std.debug.Dwarf.abi.supportsUnwinding(target)) return .@"async";
return .none;
}
pub fn defaultAddressSpace(

6
test/standalone/stack_iterator/build.zig
View File

@ -23,7 +23,7 @@ pub fn build(b: *std.Build) void {
.root_source_file = b.path("unwind.zig"),
.target = target,
.optimize = optimize,
.unwind_tables = if (target.result.isDarwin()) true else null,
.unwind_tables = if (target.result.isDarwin()) .@"async" else null,
.omit_frame_pointer = false,
});
@ -46,7 +46,7 @@ pub fn build(b: *std.Build) void {
.root_source_file = b.path("unwind.zig"),
.target = target,
.optimize = optimize,
.unwind_tables = true,
.unwind_tables = .@"async",
.omit_frame_pointer = true,
});
@ -85,7 +85,7 @@ pub fn build(b: *std.Build) void {
.root_source_file = b.path("shared_lib_unwind.zig"),
.target = target,
.optimize = optimize,
.unwind_tables = if (target.result.isDarwin()) true else null,
.unwind_tables = if (target.result.isDarwin()) .@"async" else null,
.omit_frame_pointer = true,
});

8
tools/update_clang_options.zig
View File

@ -110,6 +110,14 @@ const known_options = [_]KnownOpt{
.name = "fno-unwind-tables",
.ident = "no_unwind_tables",
},
.{
.name = "fasynchronous-unwind-tables",
.ident = "asynchronous_unwind_tables",
},
.{
.name = "fno-asynchronous-unwind-tables",
.ident = "no_asynchronous_unwind_tables",
},
.{
.name = "nolibc",
.ident = "nostdlib",