From 21551795ad356ce9434e710d827244f5166fa244 Mon Sep 17 00:00:00 2001 From: CJ van den Berg Date: Tue, 1 Jul 2025 17:34:41 +0200 Subject: [PATCH] feat: install signal crash handler to reset terminal before dumping stack traces This currently requires cloning std.debug to grant access to the standard trace dump handler. Hopefully in future this could be made public in the standard library. --- src/main.zig | 6 +- src/renderer/vaxis/renderer.zig | 28 + src/renderer/vaxis/std/debug.zig | 1732 ++++++++++++++++++++++++++++++ 3 files changed, 1764 insertions(+), 2 deletions(-) create mode 100644 src/renderer/vaxis/std/debug.zig diff --git a/src/main.zig b/src/main.zig index 4c2f74b..577572d 100644 --- a/src/main.zig +++ b/src/main.zig @@ -148,8 +148,10 @@ pub fn main() anyerror!void { return list_languages.list(a, stdout.writer(), tty_config); } - if (builtin.os.tag != .windows) - if (std.posix.getenv("JITDEBUG")) |_| thespian.install_debugger(); + if (std.posix.getenv("JITDEBUG")) |_| + thespian.install_debugger() + else if (@hasDecl(renderer, "install_crash_handler")) + renderer.install_crash_handler(); if (args.debug_wait) { std.debug.print("press return to start", .{}); diff --git a/src/renderer/vaxis/renderer.zig b/src/renderer/vaxis/renderer.zig index 016738b..8d3cd1f 100644 --- a/src/renderer/vaxis/renderer.zig +++ b/src/renderer/vaxis/renderer.zig @@ -118,6 +118,34 @@ pub fn panic_in_progress() bool { return in_panic.load(.acquire); } +pub fn install_crash_handler() void { + if (!std.debug.have_segfault_handling_support) { + @compileError("segfault handler not supported for this target"); + } + const act = std.posix.Sigaction{ + .handler = .{ .sigaction = handle_crash }, + .mask = std.posix.empty_sigset, + .flags = (std.posix.SA.SIGINFO | std.posix.SA.RESTART), + }; + + std.posix.sigaction(std.posix.SIG.BUS, &act, null); + std.posix.sigaction(std.posix.SIG.SEGV, &act, null); + std.posix.sigaction(std.posix.SIG.ABRT, &act, null); + std.posix.sigaction(std.posix.SIG.FPE, &act, null); + std.posix.sigaction(std.posix.SIG.ILL, &act, null); +} + +fn handle_crash(sig: i32, info: *const std.posix.siginfo_t, ctx_ptr: ?*anyopaque) callconv(.c) noreturn { + in_panic.store(true, .release); + const cleanup = panic_cleanup; + panic_cleanup = null; + if (cleanup) |self| { + self.vx.deinit(self.allocator, self.tty.anyWriter()); + self.tty.deinit(); + } + @import("std/debug.zig").handleSegfaultPosix(sig, info, ctx_ptr); +} + pub fn run(self: *Self) Error!void { self.vx.sgr = .legacy; self.vx.conpty_hacks = true; diff --git a/src/renderer/vaxis/std/debug.zig b/src/renderer/vaxis/std/debug.zig new file mode 100644 index 0000000..d155d5a --- /dev/null +++ b/src/renderer/vaxis/std/debug.zig @@ -0,0 +1,1732 @@ +const builtin = @import("builtin"); +const std = @import("std"); +const math = std.math; +const mem = std.mem; +const io = std.io; +const posix = std.posix; +const fs = std.fs; +const testing = std.testing; +const root = @import("root"); +const File = std.fs.File; +const windows = std.os.windows; +const native_arch = builtin.cpu.arch; +const native_os = builtin.os.tag; +const native_endian = native_arch.endian(); + +pub const MemoryAccessor = std.debug.MemoryAccessor; +pub const FixedBufferReader = std.debug.FixedBufferReader.zig; +pub const Dwarf = std.debug.Dwarf; +pub const Pdb = std.debug.Pdb; +pub const SelfInfo = std.debug.SelfInfo; +pub const Info = std.debug.Info; +pub const Coverage = std.debug.Coverage; + +pub const simple_panic = std.debug.simple_panic; +pub const no_panic = std.debug.no_panic; + +/// A fully-featured panic handler namespace which lowers all panics to calls to `panicFn`. +/// Safety panics will use formatted printing to provide a meaningful error message. +/// The signature of `panicFn` should match that of `defaultPanic`. +pub fn FullPanic(comptime panicFn: fn ([]const u8, ?usize) noreturn) type { + return struct { + pub const call = panicFn; + pub fn sentinelMismatch(expected: anytype, found: @TypeOf(expected)) noreturn { + @branchHint(.cold); + std.debug.panicExtra(@returnAddress(), "sentinel mismatch: expected {any}, found {any}", .{ + expected, found, + }); + } + pub fn unwrapError(err: anyerror) noreturn { + @branchHint(.cold); + std.debug.panicExtra(@returnAddress(), "attempt to unwrap error: {s}", .{@errorName(err)}); + } + pub fn outOfBounds(index: usize, len: usize) noreturn { + @branchHint(.cold); + std.debug.panicExtra(@returnAddress(), "index out of bounds: index {d}, len {d}", .{ index, len }); + } + pub fn startGreaterThanEnd(start: usize, end: usize) noreturn { + @branchHint(.cold); + std.debug.panicExtra(@returnAddress(), "start index {d} is larger than end index {d}", .{ start, end }); + } + pub fn inactiveUnionField(active: anytype, accessed: @TypeOf(active)) noreturn { + @branchHint(.cold); + std.debug.panicExtra(@returnAddress(), "access of union field '{s}' while field '{s}' is active", .{ + @tagName(accessed), @tagName(active), + }); + } + pub fn sliceCastLenRemainder(src_len: usize) noreturn { + @branchHint(.cold); + std.debug.panicExtra(@returnAddress(), "slice length '{d}' does not divide exactly into destination elements", .{src_len}); + } + pub fn reachedUnreachable() noreturn { + @branchHint(.cold); + call("reached unreachable code", @returnAddress()); + } + pub fn unwrapNull() noreturn { + @branchHint(.cold); + call("attempt to use null value", @returnAddress()); + } + pub fn castToNull() noreturn { + @branchHint(.cold); + call("cast causes pointer to be null", @returnAddress()); + } + pub fn incorrectAlignment() noreturn { + @branchHint(.cold); + call("incorrect alignment", @returnAddress()); + } + pub fn invalidErrorCode() noreturn { + @branchHint(.cold); + call("invalid error code", @returnAddress()); + } + pub fn castTruncatedData() noreturn { + @branchHint(.cold); + call("integer cast truncated bits", @returnAddress()); + } + pub fn negativeToUnsigned() noreturn { + @branchHint(.cold); + call("attempt to cast negative value to unsigned integer", @returnAddress()); + } + pub fn integerOverflow() noreturn { + @branchHint(.cold); + call("integer overflow", @returnAddress()); + } + pub fn shlOverflow() noreturn { + @branchHint(.cold); + call("left shift overflowed bits", @returnAddress()); + } + pub fn shrOverflow() noreturn { + @branchHint(.cold); + call("right shift overflowed bits", @returnAddress()); + } + pub fn divideByZero() noreturn { + @branchHint(.cold); + call("division by zero", @returnAddress()); + } + pub fn exactDivisionRemainder() noreturn { + @branchHint(.cold); + call("exact division produced remainder", @returnAddress()); + } + pub fn integerPartOutOfBounds() noreturn { + @branchHint(.cold); + call("integer part of floating point value out of bounds", @returnAddress()); + } + pub fn corruptSwitch() noreturn { + @branchHint(.cold); + call("switch on corrupt value", @returnAddress()); + } + pub fn shiftRhsTooBig() noreturn { + @branchHint(.cold); + call("shift amount is greater than the type size", @returnAddress()); + } + pub fn invalidEnumValue() noreturn { + @branchHint(.cold); + call("invalid enum value", @returnAddress()); + } + pub fn forLenMismatch() noreturn { + @branchHint(.cold); + call("for loop over objects with non-equal lengths", @returnAddress()); + } + pub fn memcpyLenMismatch() noreturn { + @branchHint(.cold); + call("@memcpy arguments have non-equal lengths", @returnAddress()); + } + pub fn memcpyAlias() noreturn { + @branchHint(.cold); + call("@memcpy arguments alias", @returnAddress()); + } + pub fn noreturnReturned() noreturn { + @branchHint(.cold); + call("'noreturn' function returned", @returnAddress()); + } + }; +} + +pub const SourceLocation = std.debug.SourceLocation; + +pub const Symbol = std.debug.Symbol; + +/// Deprecated because it returns the optimization mode of the standard +/// library, when the caller probably wants to use the optimization mode of +/// their own module. +pub const runtime_safety = switch (builtin.mode) { + .Debug, .ReleaseSafe => true, + .ReleaseFast, .ReleaseSmall => false, +}; + +pub const sys_can_stack_trace = switch (builtin.cpu.arch) { + // Observed to go into an infinite loop. + // TODO: Make this work. + .mips, + .mipsel, + .mips64, + .mips64el, + .s390x, + => false, + + // `@returnAddress()` in LLVM 10 gives + // "Non-Emscripten WebAssembly hasn't implemented __builtin_return_address". + .wasm32, + .wasm64, + => native_os == .emscripten, + + // `@returnAddress()` is unsupported in LLVM 13. + .bpfel, + .bpfeb, + => false, + + else => true, +}; + +/// Allows the caller to freely write to stderr until `unlockStdErr` is called. +/// +/// During the lock, any `std.Progress` information is cleared from the terminal. +pub fn lockStdErr() void { + std.Progress.lockStdErr(); +} + +pub fn unlockStdErr() void { + std.Progress.unlockStdErr(); +} + +/// Print to stderr, unbuffered, and silently returning on failure. Intended +/// for use in "printf debugging." Use `std.log` functions for proper logging. +pub fn print(comptime fmt: []const u8, args: anytype) void { + lockStdErr(); + defer unlockStdErr(); + const stderr = io.getStdErr().writer(); + nosuspend stderr.print(fmt, args) catch return; +} + +pub fn getStderrMutex() *std.Thread.Mutex { + @compileError("deprecated. call std.debug.lockStdErr() and std.debug.unlockStdErr() instead which will integrate properly with std.Progress"); +} + +/// TODO multithreaded awareness +var self_debug_info: ?SelfInfo = null; + +pub fn getSelfDebugInfo() !*SelfInfo { + if (self_debug_info) |*info| { + return info; + } else { + self_debug_info = try SelfInfo.open(getDebugInfoAllocator()); + return &self_debug_info.?; + } +} + +/// Tries to print a hexadecimal view of the bytes, unbuffered, and ignores any error returned. +/// Obtains the stderr mutex while dumping. +pub fn dumpHex(bytes: []const u8) void { + lockStdErr(); + defer unlockStdErr(); + dumpHexFallible(bytes) catch {}; +} + +/// Prints a hexadecimal view of the bytes, unbuffered, returning any error that occurs. +pub fn dumpHexFallible(bytes: []const u8) !void { + const stderr = std.io.getStdErr(); + const ttyconf = std.io.tty.detectConfig(stderr); + const writer = stderr.writer(); + try dumpHexInternal(bytes, ttyconf, writer); +} + +fn dumpHexInternal(bytes: []const u8, ttyconf: std.io.tty.Config, writer: anytype) !void { + var chunks = mem.window(u8, bytes, 16, 16); + while (chunks.next()) |window| { + // 1. Print the address. + const address = (@intFromPtr(bytes.ptr) + 0x10 * (std.math.divCeil(usize, chunks.index orelse bytes.len, 16) catch unreachable)) - 0x10; + try ttyconf.setColor(writer, .dim); + // We print the address in lowercase and the bytes in uppercase hexadecimal to distinguish them more. + // Also, make sure all lines are aligned by padding the address. + try writer.print("{x:0>[1]} ", .{ address, @sizeOf(usize) * 2 }); + try ttyconf.setColor(writer, .reset); + + // 2. Print the bytes. + for (window, 0..) |byte, index| { + try writer.print("{X:0>2} ", .{byte}); + if (index == 7) try writer.writeByte(' '); + } + try writer.writeByte(' '); + if (window.len < 16) { + var missing_columns = (16 - window.len) * 3; + if (window.len < 8) missing_columns += 1; + try writer.writeByteNTimes(' ', missing_columns); + } + + // 3. Print the characters. + for (window) |byte| { + if (std.ascii.isPrint(byte)) { + try writer.writeByte(byte); + } else { + // Related: https://github.com/ziglang/zig/issues/7600 + if (ttyconf == .windows_api) { + try writer.writeByte('.'); + continue; + } + + // Let's print some common control codes as graphical Unicode symbols. + // We don't want to do this for all control codes because most control codes apart from + // the ones that Zig has escape sequences for are likely not very useful to print as symbols. + switch (byte) { + '\n' => try writer.writeAll("␊"), + '\r' => try writer.writeAll("␍"), + '\t' => try writer.writeAll("␉"), + else => try writer.writeByte('.'), + } + } + } + try writer.writeByte('\n'); + } +} + +test dumpHexInternal { + const bytes: []const u8 = &.{ 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff, 0x01, 0x12, 0x13 }; + var output = std.ArrayList(u8).init(std.testing.allocator); + defer output.deinit(); + try dumpHexInternal(bytes, .no_color, output.writer()); + const expected = try std.fmt.allocPrint(std.testing.allocator, + \\{x:0>[2]} 00 11 22 33 44 55 66 77 88 99 AA BB CC DD EE FF .."3DUfw........ + \\{x:0>[2]} 01 12 13 ... + \\ + , .{ + @intFromPtr(bytes.ptr), + @intFromPtr(bytes.ptr) + 16, + @sizeOf(usize) * 2, + }); + defer std.testing.allocator.free(expected); + try std.testing.expectEqualStrings(expected, output.items); +} + +/// Tries to print the current stack trace to stderr, unbuffered, and ignores any error returned. +/// TODO multithreaded awareness +pub fn dumpCurrentStackTrace(start_addr: ?usize) void { + nosuspend { + if (builtin.target.cpu.arch.isWasm()) { + if (native_os == .wasi) { + const stderr = io.getStdErr().writer(); + stderr.print("Unable to dump stack trace: not implemented for Wasm\n", .{}) catch return; + } + return; + } + const stderr = io.getStdErr().writer(); + if (builtin.strip_debug_info) { + stderr.print("Unable to dump stack trace: debug info stripped\n", .{}) catch return; + return; + } + const debug_info = getSelfDebugInfo() catch |err| { + stderr.print("Unable to dump stack trace: Unable to open debug info: {s}\n", .{@errorName(err)}) catch return; + return; + }; + writeCurrentStackTrace(stderr, debug_info, io.tty.detectConfig(io.getStdErr()), start_addr) catch |err| { + stderr.print("Unable to dump stack trace: {s}\n", .{@errorName(err)}) catch return; + return; + }; + } +} + +pub const have_ucontext = posix.ucontext_t != void; + +/// Platform-specific thread state. This contains register state, and on some platforms +/// information about the stack. This is not safe to trivially copy, because some platforms +/// use internal pointers within this structure. To make a copy, use `copyContext`. +pub const ThreadContext = blk: { + if (native_os == .windows) { + break :blk windows.CONTEXT; + } else if (have_ucontext) { + break :blk posix.ucontext_t; + } else { + break :blk void; + } +}; + +/// Copies one context to another, updating any internal pointers +pub fn copyContext(source: *const ThreadContext, dest: *ThreadContext) void { + if (!have_ucontext) return {}; + dest.* = source.*; + relocateContext(dest); +} + +/// Updates any internal pointers in the context to reflect its current location +pub fn relocateContext(context: *ThreadContext) void { + return switch (native_os) { + .macos => { + context.mcontext = &context.__mcontext_data; + }, + else => {}, + }; +} + +pub const have_getcontext = @TypeOf(posix.system.getcontext) != void; + +/// Capture the current context. The register values in the context will reflect the +/// state after the platform `getcontext` function returns. +/// +/// It is valid to call this if the platform doesn't have context capturing support, +/// in that case false will be returned. +pub inline fn getContext(context: *ThreadContext) bool { + if (native_os == .windows) { + context.* = std.mem.zeroes(windows.CONTEXT); + windows.ntdll.RtlCaptureContext(context); + return true; + } + + const result = have_getcontext and posix.system.getcontext(context) == 0; + if (native_os == .macos) { + assert(context.mcsize == @sizeOf(std.c.mcontext_t)); + + // On aarch64-macos, the system getcontext doesn't write anything into the pc + // register slot, it only writes lr. This makes the context consistent with + // other aarch64 getcontext implementations which write the current lr + // (where getcontext will return to) into both the lr and pc slot of the context. + if (native_arch == .aarch64) context.mcontext.ss.pc = context.mcontext.ss.lr; + } + + return result; +} + +/// Tries to print the stack trace starting from the supplied base pointer to stderr, +/// unbuffered, and ignores any error returned. +/// TODO multithreaded awareness +pub fn dumpStackTraceFromBase(context: *ThreadContext) void { + nosuspend { + if (builtin.target.cpu.arch.isWasm()) { + if (native_os == .wasi) { + const stderr = io.getStdErr().writer(); + stderr.print("Unable to dump stack trace: not implemented for Wasm\n", .{}) catch return; + } + return; + } + const stderr = io.getStdErr().writer(); + if (builtin.strip_debug_info) { + stderr.print("Unable to dump stack trace: debug info stripped\n", .{}) catch return; + return; + } + const debug_info = getSelfDebugInfo() catch |err| { + stderr.print("Unable to dump stack trace: Unable to open debug info: {s}\n", .{@errorName(err)}) catch return; + return; + }; + const tty_config = io.tty.detectConfig(io.getStdErr()); + if (native_os == .windows) { + // On x86_64 and aarch64, the stack will be unwound using RtlVirtualUnwind using the context + // provided by the exception handler. On x86, RtlVirtualUnwind doesn't exist. Instead, a new backtrace + // will be captured and frames prior to the exception will be filtered. + // The caveat is that RtlCaptureStackBackTrace does not include the KiUserExceptionDispatcher frame, + // which is where the IP in `context` points to, so it can't be used as start_addr. + // Instead, start_addr is recovered from the stack. + const start_addr = if (builtin.cpu.arch == .x86) @as(*const usize, @ptrFromInt(context.getRegs().bp + 4)).* else null; + writeStackTraceWindows(stderr, debug_info, tty_config, context, start_addr) catch return; + return; + } + + var it = StackIterator.initWithContext(null, debug_info, context) catch return; + defer it.deinit(); + + // DWARF unwinding on aarch64-macos is not complete so we need to get pc address from mcontext + const pc_addr = if (builtin.target.os.tag.isDarwin() and native_arch == .aarch64) + context.mcontext.ss.pc + else + it.unwind_state.?.dwarf_context.pc; + printSourceAtAddress(debug_info, stderr, pc_addr, tty_config) catch return; + + while (it.next()) |return_address| { + printLastUnwindError(&it, debug_info, stderr, tty_config); + + // On arm64 macOS, the address of the last frame is 0x0 rather than 0x1 as on x86_64 macOS, + // therefore, we do a check for `return_address == 0` before subtracting 1 from it to avoid + // an overflow. We do not need to signal `StackIterator` as it will correctly detect this + // condition on the subsequent iteration and return `null` thus terminating the loop. + // same behaviour for x86-windows-msvc + const address = if (return_address == 0) return_address else return_address - 1; + printSourceAtAddress(debug_info, stderr, address, tty_config) catch return; + } else printLastUnwindError(&it, debug_info, stderr, tty_config); + } +} + +/// Returns a slice with the same pointer as addresses, with a potentially smaller len. +/// On Windows, when first_address is not null, we ask for at least 32 stack frames, +/// and then try to find the first address. If addresses.len is more than 32, we +/// capture that many stack frames exactly, and then look for the first address, +/// chopping off the irrelevant frames and shifting so that the returned addresses pointer +/// equals the passed in addresses pointer. +pub fn captureStackTrace(first_address: ?usize, stack_trace: *std.builtin.StackTrace) void { + if (native_os == .windows) { + const addrs = stack_trace.instruction_addresses; + const first_addr = first_address orelse { + stack_trace.index = walkStackWindows(addrs[0..], null); + return; + }; + var addr_buf_stack: [32]usize = undefined; + const addr_buf = if (addr_buf_stack.len > addrs.len) addr_buf_stack[0..] else addrs; + const n = walkStackWindows(addr_buf[0..], null); + const first_index = for (addr_buf[0..n], 0..) |addr, i| { + if (addr == first_addr) { + break i; + } + } else { + stack_trace.index = 0; + return; + }; + const end_index = @min(first_index + addrs.len, n); + const slice = addr_buf[first_index..end_index]; + // We use a for loop here because slice and addrs may alias. + for (slice, 0..) |addr, i| { + addrs[i] = addr; + } + stack_trace.index = slice.len; + } else { + // TODO: This should use the DWARF unwinder if .eh_frame_hdr is available (so that full debug info parsing isn't required). + // A new path for loading SelfInfo needs to be created which will only attempt to parse in-memory sections, because + // stopping to load other debug info (ie. source line info) from disk here is not required for unwinding. + var it = StackIterator.init(first_address, null); + defer it.deinit(); + for (stack_trace.instruction_addresses, 0..) |*addr, i| { + addr.* = it.next() orelse { + stack_trace.index = i; + return; + }; + } + stack_trace.index = stack_trace.instruction_addresses.len; + } +} + +/// Tries to print a stack trace to stderr, unbuffered, and ignores any error returned. +/// TODO multithreaded awareness +pub fn dumpStackTrace(stack_trace: std.builtin.StackTrace) void { + nosuspend { + if (builtin.target.cpu.arch.isWasm()) { + if (native_os == .wasi) { + const stderr = io.getStdErr().writer(); + stderr.print("Unable to dump stack trace: not implemented for Wasm\n", .{}) catch return; + } + return; + } + const stderr = io.getStdErr().writer(); + if (builtin.strip_debug_info) { + stderr.print("Unable to dump stack trace: debug info stripped\n", .{}) catch return; + return; + } + const debug_info = getSelfDebugInfo() catch |err| { + stderr.print("Unable to dump stack trace: Unable to open debug info: {s}\n", .{@errorName(err)}) catch return; + return; + }; + writeStackTrace(stack_trace, stderr, debug_info, io.tty.detectConfig(io.getStdErr())) catch |err| { + stderr.print("Unable to dump stack trace: {s}\n", .{@errorName(err)}) catch return; + return; + }; + } +} + +/// Invokes detectable illegal behavior when `ok` is `false`. +/// +/// In Debug and ReleaseSafe modes, calls to this function are always +/// generated, and the `unreachable` statement triggers a panic. +/// +/// In ReleaseFast and ReleaseSmall modes, calls to this function are optimized +/// away, and in fact the optimizer is able to use the assertion in its +/// heuristics. +/// +/// Inside a test block, it is best to use the `std.testing` module rather than +/// this function, because this function may not detect a test failure in +/// ReleaseFast and ReleaseSmall mode. Outside of a test block, this assert +/// function is the correct function to use. +pub fn assert(ok: bool) void { + if (!ok) unreachable; // assertion failure +} + +/// Invokes detectable illegal behavior when the provided slice is not mapped +/// or lacks read permissions. +pub fn assertReadable(slice: []const volatile u8) void { + if (!runtime_safety) return; + for (slice) |*byte| _ = byte.*; +} + +/// Equivalent to `@panic` but with a formatted message. +pub fn panic(comptime format: []const u8, args: anytype) noreturn { + @branchHint(.cold); + panicExtra(@returnAddress(), format, args); +} + +/// Equivalent to `@panic` but with a formatted message, and with an explicitly +/// provided return address. +pub fn panicExtra( + ret_addr: ?usize, + comptime format: []const u8, + args: anytype, +) noreturn { + @branchHint(.cold); + + const size = 0x1000; + const trunc_msg = "(msg truncated)"; + var buf: [size + trunc_msg.len]u8 = undefined; + // a minor annoyance with this is that it will result in the NoSpaceLeft + // error being part of the @panic stack trace (but that error should + // only happen rarely) + const msg = std.fmt.bufPrint(buf[0..size], format, args) catch |err| switch (err) { + error.NoSpaceLeft => blk: { + @memcpy(buf[size..], trunc_msg); + break :blk &buf; + }, + }; + std.builtin.panic.call(msg, ret_addr); +} + +/// Non-zero whenever the program triggered a panic. +/// The counter is incremented/decremented atomically. +var panicking = std.atomic.Value(u8).init(0); + +/// Counts how many times the panic handler is invoked by this thread. +/// This is used to catch and handle panics triggered by the panic handler. +threadlocal var panic_stage: usize = 0; + +/// Dumps a stack trace to standard error, then aborts. +pub fn defaultPanic( + msg: []const u8, + first_trace_addr: ?usize, +) noreturn { + @branchHint(.cold); + + // For backends that cannot handle the language features depended on by the + // default panic handler, we have a simpler panic handler: + if (builtin.zig_backend == .stage2_wasm or + builtin.zig_backend == .stage2_arm or + builtin.zig_backend == .stage2_aarch64 or + builtin.zig_backend == .stage2_x86 or + (builtin.zig_backend == .stage2_x86_64 and (builtin.target.ofmt != .elf and builtin.target.ofmt != .macho)) or + builtin.zig_backend == .stage2_sparc64 or + builtin.zig_backend == .stage2_spirv64) + { + @trap(); + } + + switch (builtin.os.tag) { + .freestanding, .other => { + @trap(); + }, + .uefi => { + const uefi = std.os.uefi; + + var utf16_buffer: [1000]u16 = undefined; + const len_minus_3 = std.unicode.utf8ToUtf16Le(&utf16_buffer, msg) catch 0; + utf16_buffer[len_minus_3..][0..3].* = .{ '\r', '\n', 0 }; + const len = len_minus_3 + 3; + const exit_msg = utf16_buffer[0 .. len - 1 :0]; + + // Output to both std_err and con_out, as std_err is easier + // to read in stuff like QEMU at times, but, unlike con_out, + // isn't visible on actual hardware if directly booted into + inline for ([_]?*uefi.protocol.SimpleTextOutput{ uefi.system_table.std_err, uefi.system_table.con_out }) |o| { + if (o) |out| { + _ = out.setAttribute(uefi.protocol.SimpleTextOutput.red); + _ = out.outputString(exit_msg); + _ = out.setAttribute(uefi.protocol.SimpleTextOutput.white); + } + } + + if (uefi.system_table.boot_services) |bs| { + // ExitData buffer must be allocated using boot_services.allocatePool (spec: page 220) + const exit_data: []u16 = uefi.raw_pool_allocator.alloc(u16, exit_msg.len + 1) catch @trap(); + @memcpy(exit_data, exit_msg[0..exit_data.len]); // Includes null terminator. + _ = bs.exit(uefi.handle, .aborted, exit_data.len, exit_data.ptr); + } + @trap(); + }, + .cuda, .amdhsa => std.posix.abort(), + .plan9 => { + var status: [std.os.plan9.ERRMAX]u8 = undefined; + const len = @min(msg.len, status.len - 1); + @memcpy(status[0..len], msg[0..len]); + status[len] = 0; + std.os.plan9.exits(status[0..len :0]); + }, + else => {}, + } + + if (enable_segfault_handler) { + // If a segfault happens while panicking, we want it to actually segfault, not trigger + // the handler. + resetSegfaultHandler(); + } + + // Note there is similar logic in handleSegfaultPosix and handleSegfaultWindowsExtra. + nosuspend switch (panic_stage) { + 0 => { + panic_stage = 1; + + _ = panicking.fetchAdd(1, .seq_cst); + + { + lockStdErr(); + defer unlockStdErr(); + + const stderr = io.getStdErr().writer(); + if (builtin.single_threaded) { + stderr.print("panic: ", .{}) catch posix.abort(); + } else { + const current_thread_id = std.Thread.getCurrentId(); + stderr.print("thread {} panic: ", .{current_thread_id}) catch posix.abort(); + } + stderr.print("{s}\n", .{msg}) catch posix.abort(); + + if (@errorReturnTrace()) |t| dumpStackTrace(t.*); + dumpCurrentStackTrace(first_trace_addr orelse @returnAddress()); + } + + waitForOtherThreadToFinishPanicking(); + }, + 1 => { + panic_stage = 2; + + // A panic happened while trying to print a previous panic message. + // We're still holding the mutex but that's fine as we're going to + // call abort(). + io.getStdErr().writeAll("aborting due to recursive panic\n") catch {}; + }, + else => {}, // Panicked while printing the recursive panic message. + }; + + posix.abort(); +} + +/// Must be called only after adding 1 to `panicking`. There are three callsites. +fn waitForOtherThreadToFinishPanicking() void { + if (panicking.fetchSub(1, .seq_cst) != 1) { + // Another thread is panicking, wait for the last one to finish + // and call abort() + if (builtin.single_threaded) unreachable; + + // Sleep forever without hammering the CPU + var futex = std.atomic.Value(u32).init(0); + while (true) std.Thread.Futex.wait(&futex, 0); + unreachable; + } +} + +pub fn writeStackTrace( + stack_trace: std.builtin.StackTrace, + out_stream: anytype, + debug_info: *SelfInfo, + tty_config: io.tty.Config, +) !void { + if (builtin.strip_debug_info) return error.MissingDebugInfo; + var frame_index: usize = 0; + var frames_left: usize = @min(stack_trace.index, stack_trace.instruction_addresses.len); + + while (frames_left != 0) : ({ + frames_left -= 1; + frame_index = (frame_index + 1) % stack_trace.instruction_addresses.len; + }) { + const return_address = stack_trace.instruction_addresses[frame_index]; + try printSourceAtAddress(debug_info, out_stream, return_address - 1, tty_config); + } + + if (stack_trace.index > stack_trace.instruction_addresses.len) { + const dropped_frames = stack_trace.index - stack_trace.instruction_addresses.len; + + tty_config.setColor(out_stream, .bold) catch {}; + try out_stream.print("({d} additional stack frames skipped...)\n", .{dropped_frames}); + tty_config.setColor(out_stream, .reset) catch {}; + } +} + +pub const UnwindError = if (have_ucontext) + @typeInfo(@typeInfo(@TypeOf(StackIterator.next_unwind)).@"fn".return_type.?).error_union.error_set +else + void; + +pub const StackIterator = struct { + // Skip every frame before this address is found. + first_address: ?usize, + // Last known value of the frame pointer register. + fp: usize, + ma: MemoryAccessor = MemoryAccessor.init, + + // When SelfInfo and a register context is available, this iterator can unwind + // stacks with frames that don't use a frame pointer (ie. -fomit-frame-pointer), + // using DWARF and MachO unwind info. + unwind_state: if (have_ucontext) ?struct { + debug_info: *SelfInfo, + dwarf_context: SelfInfo.UnwindContext, + last_error: ?UnwindError = null, + failed: bool = false, + } else void = if (have_ucontext) null else {}, + + pub fn init(first_address: ?usize, fp: ?usize) StackIterator { + if (native_arch.isSPARC()) { + // Flush all the register windows on stack. + asm volatile (if (std.Target.sparc.featureSetHas(builtin.cpu.features, .v9)) + "flushw" + else + "ta 3" // ST_FLUSH_WINDOWS + ::: "memory"); + } + + return StackIterator{ + .first_address = first_address, + // TODO: this is a workaround for #16876 + //.fp = fp orelse @frameAddress(), + .fp = fp orelse blk: { + const fa = @frameAddress(); + break :blk fa; + }, + }; + } + + pub fn initWithContext(first_address: ?usize, debug_info: *SelfInfo, context: *posix.ucontext_t) !StackIterator { + // The implementation of DWARF unwinding on aarch64-macos is not complete. However, Apple mandates that + // the frame pointer register is always used, so on this platform we can safely use the FP-based unwinder. + if (builtin.target.os.tag.isDarwin() and native_arch == .aarch64) + return init(first_address, @truncate(context.mcontext.ss.fp)); + + if (SelfInfo.supports_unwinding) { + var iterator = init(first_address, null); + iterator.unwind_state = .{ + .debug_info = debug_info, + .dwarf_context = try SelfInfo.UnwindContext.init(debug_info.allocator, context), + }; + return iterator; + } + + return init(first_address, null); + } + + pub fn deinit(it: *StackIterator) void { + it.ma.deinit(); + if (have_ucontext and it.unwind_state != null) it.unwind_state.?.dwarf_context.deinit(); + } + + pub fn getLastError(it: *StackIterator) ?struct { + err: UnwindError, + address: usize, + } { + if (!have_ucontext) return null; + if (it.unwind_state) |*unwind_state| { + if (unwind_state.last_error) |err| { + unwind_state.last_error = null; + return .{ + .err = err, + .address = unwind_state.dwarf_context.pc, + }; + } + } + + return null; + } + + // Offset of the saved BP wrt the frame pointer. + const fp_offset = if (native_arch.isRISCV()) + // On RISC-V the frame pointer points to the top of the saved register + // area, on pretty much every other architecture it points to the stack + // slot where the previous frame pointer is saved. + 2 * @sizeOf(usize) + else if (native_arch.isSPARC()) + // On SPARC the previous frame pointer is stored at 14 slots past %fp+BIAS. + 14 * @sizeOf(usize) + else + 0; + + const fp_bias = if (native_arch.isSPARC()) + // On SPARC frame pointers are biased by a constant. + 2047 + else + 0; + + // Positive offset of the saved PC wrt the frame pointer. + const pc_offset = if (native_arch == .powerpc64le) + 2 * @sizeOf(usize) + else + @sizeOf(usize); + + pub fn next(it: *StackIterator) ?usize { + var address = it.next_internal() orelse return null; + + if (it.first_address) |first_address| { + while (address != first_address) { + address = it.next_internal() orelse return null; + } + it.first_address = null; + } + + return address; + } + + fn next_unwind(it: *StackIterator) !usize { + const unwind_state = &it.unwind_state.?; + const module = try unwind_state.debug_info.getModuleForAddress(unwind_state.dwarf_context.pc); + switch (native_os) { + .macos, .ios, .watchos, .tvos, .visionos => { + // __unwind_info is a requirement for unwinding on Darwin. It may fall back to DWARF, but unwinding + // via DWARF before attempting to use the compact unwind info will produce incorrect results. + if (module.unwind_info) |unwind_info| { + if (SelfInfo.unwindFrameMachO( + unwind_state.debug_info.allocator, + module.base_address, + &unwind_state.dwarf_context, + &it.ma, + unwind_info, + module.eh_frame, + )) |return_address| { + return return_address; + } else |err| { + if (err != error.RequiresDWARFUnwind) return err; + } + } else return error.MissingUnwindInfo; + }, + else => {}, + } + + if (try module.getDwarfInfoForAddress(unwind_state.debug_info.allocator, unwind_state.dwarf_context.pc)) |di| { + return SelfInfo.unwindFrameDwarf( + unwind_state.debug_info.allocator, + di, + module.base_address, + &unwind_state.dwarf_context, + &it.ma, + null, + ); + } else return error.MissingDebugInfo; + } + + fn next_internal(it: *StackIterator) ?usize { + if (have_ucontext) { + if (it.unwind_state) |*unwind_state| { + if (!unwind_state.failed) { + if (unwind_state.dwarf_context.pc == 0) return null; + defer it.fp = unwind_state.dwarf_context.getFp() catch 0; + if (it.next_unwind()) |return_address| { + return return_address; + } else |err| { + unwind_state.last_error = err; + unwind_state.failed = true; + + // Fall back to fp-based unwinding on the first failure. + // We can't attempt it again for other modules higher in the + // stack because the full register state won't have been unwound. + } + } + } + } + + const fp = if (comptime native_arch.isSPARC()) + // On SPARC the offset is positive. (!) + math.add(usize, it.fp, fp_offset) catch return null + else + math.sub(usize, it.fp, fp_offset) catch return null; + + // Sanity check. + if (fp == 0 or !mem.isAligned(fp, @alignOf(usize))) return null; + const new_fp = math.add(usize, it.ma.load(usize, fp) orelse return null, fp_bias) catch + return null; + + // Sanity check: the stack grows down thus all the parent frames must be + // be at addresses that are greater (or equal) than the previous one. + // A zero frame pointer often signals this is the last frame, that case + // is gracefully handled by the next call to next_internal. + if (new_fp != 0 and new_fp < it.fp) return null; + const new_pc = it.ma.load(usize, math.add(usize, fp, pc_offset) catch return null) orelse + return null; + + it.fp = new_fp; + + return new_pc; + } +}; + +pub fn writeCurrentStackTrace( + out_stream: anytype, + debug_info: *SelfInfo, + tty_config: io.tty.Config, + start_addr: ?usize, +) !void { + if (native_os == .windows) { + var context: ThreadContext = undefined; + assert(getContext(&context)); + return writeStackTraceWindows(out_stream, debug_info, tty_config, &context, start_addr); + } + var context: ThreadContext = undefined; + const has_context = getContext(&context); + + var it = (if (has_context) blk: { + break :blk StackIterator.initWithContext(start_addr, debug_info, &context) catch null; + } else null) orelse StackIterator.init(start_addr, null); + defer it.deinit(); + + while (it.next()) |return_address| { + printLastUnwindError(&it, debug_info, out_stream, tty_config); + + // On arm64 macOS, the address of the last frame is 0x0 rather than 0x1 as on x86_64 macOS, + // therefore, we do a check for `return_address == 0` before subtracting 1 from it to avoid + // an overflow. We do not need to signal `StackIterator` as it will correctly detect this + // condition on the subsequent iteration and return `null` thus terminating the loop. + // same behaviour for x86-windows-msvc + const address = return_address -| 1; + try printSourceAtAddress(debug_info, out_stream, address, tty_config); + } else printLastUnwindError(&it, debug_info, out_stream, tty_config); +} + +pub noinline fn walkStackWindows(addresses: []usize, existing_context: ?*const windows.CONTEXT) usize { + if (builtin.cpu.arch == .x86) { + // RtlVirtualUnwind doesn't exist on x86 + return windows.ntdll.RtlCaptureStackBackTrace(0, addresses.len, @as(**anyopaque, @ptrCast(addresses.ptr)), null); + } + + const tib = &windows.teb().NtTib; + + var context: windows.CONTEXT = undefined; + if (existing_context) |context_ptr| { + context = context_ptr.*; + } else { + context = std.mem.zeroes(windows.CONTEXT); + windows.ntdll.RtlCaptureContext(&context); + } + + var i: usize = 0; + var image_base: windows.DWORD64 = undefined; + var history_table: windows.UNWIND_HISTORY_TABLE = std.mem.zeroes(windows.UNWIND_HISTORY_TABLE); + + while (i < addresses.len) : (i += 1) { + const current_regs = context.getRegs(); + if (windows.ntdll.RtlLookupFunctionEntry(current_regs.ip, &image_base, &history_table)) |runtime_function| { + var handler_data: ?*anyopaque = null; + var establisher_frame: u64 = undefined; + _ = windows.ntdll.RtlVirtualUnwind( + windows.UNW_FLAG_NHANDLER, + image_base, + current_regs.ip, + runtime_function, + &context, + &handler_data, + &establisher_frame, + null, + ); + } else { + // leaf function + context.setIp(@as(*usize, @ptrFromInt(current_regs.sp)).*); + context.setSp(current_regs.sp + @sizeOf(usize)); + } + + const next_regs = context.getRegs(); + if (next_regs.sp < @intFromPtr(tib.StackLimit) or next_regs.sp > @intFromPtr(tib.StackBase)) { + break; + } + + if (next_regs.ip == 0) { + break; + } + + addresses[i] = next_regs.ip; + } + + return i; +} + +pub fn writeStackTraceWindows( + out_stream: anytype, + debug_info: *SelfInfo, + tty_config: io.tty.Config, + context: *const windows.CONTEXT, + start_addr: ?usize, +) !void { + var addr_buf: [1024]usize = undefined; + const n = walkStackWindows(addr_buf[0..], context); + const addrs = addr_buf[0..n]; + const start_i: usize = if (start_addr) |saddr| blk: { + for (addrs, 0..) |addr, i| { + if (addr == saddr) break :blk i; + } + return; + } else 0; + for (addrs[start_i..]) |addr| { + try printSourceAtAddress(debug_info, out_stream, addr - 1, tty_config); + } +} + +fn printUnknownSource(debug_info: *SelfInfo, out_stream: anytype, address: usize, tty_config: io.tty.Config) !void { + const module_name = debug_info.getModuleNameForAddress(address); + return printLineInfo( + out_stream, + null, + address, + "???", + module_name orelse "???", + tty_config, + printLineFromFileAnyOs, + ); +} + +fn printLastUnwindError(it: *StackIterator, debug_info: *SelfInfo, out_stream: anytype, tty_config: io.tty.Config) void { + if (!have_ucontext) return; + if (it.getLastError()) |unwind_error| { + printUnwindError(debug_info, out_stream, unwind_error.address, unwind_error.err, tty_config) catch {}; + } +} + +fn printUnwindError(debug_info: *SelfInfo, out_stream: anytype, address: usize, err: UnwindError, tty_config: io.tty.Config) !void { + const module_name = debug_info.getModuleNameForAddress(address) orelse "???"; + try tty_config.setColor(out_stream, .dim); + if (err == error.MissingDebugInfo) { + try out_stream.print("Unwind information for `{s}:0x{x}` was not available, trace may be incomplete\n\n", .{ module_name, address }); + } else { + try out_stream.print("Unwind error at address `{s}:0x{x}` ({}), trace may be incomplete\n\n", .{ module_name, address, err }); + } + try tty_config.setColor(out_stream, .reset); +} + +pub fn printSourceAtAddress(debug_info: *SelfInfo, out_stream: anytype, address: usize, tty_config: io.tty.Config) !void { + const module = debug_info.getModuleForAddress(address) catch |err| switch (err) { + error.MissingDebugInfo, error.InvalidDebugInfo => return printUnknownSource(debug_info, out_stream, address, tty_config), + else => return err, + }; + + const symbol_info = module.getSymbolAtAddress(debug_info.allocator, address) catch |err| switch (err) { + error.MissingDebugInfo, error.InvalidDebugInfo => return printUnknownSource(debug_info, out_stream, address, tty_config), + else => return err, + }; + defer if (symbol_info.source_location) |sl| debug_info.allocator.free(sl.file_name); + + return printLineInfo( + out_stream, + symbol_info.source_location, + address, + symbol_info.name, + symbol_info.compile_unit_name, + tty_config, + printLineFromFileAnyOs, + ); +} + +fn printLineInfo( + out_stream: anytype, + source_location: ?SourceLocation, + address: usize, + symbol_name: []const u8, + compile_unit_name: []const u8, + tty_config: io.tty.Config, + comptime printLineFromFile: anytype, +) !void { + nosuspend { + try tty_config.setColor(out_stream, .bold); + + if (source_location) |*sl| { + try out_stream.print("{s}:{d}:{d}", .{ sl.file_name, sl.line, sl.column }); + } else { + try out_stream.writeAll("???:?:?"); + } + + try tty_config.setColor(out_stream, .reset); + try out_stream.writeAll(": "); + try tty_config.setColor(out_stream, .dim); + try out_stream.print("0x{x} in {s} ({s})", .{ address, symbol_name, compile_unit_name }); + try tty_config.setColor(out_stream, .reset); + try out_stream.writeAll("\n"); + + // Show the matching source code line if possible + if (source_location) |sl| { + if (printLineFromFile(out_stream, sl)) { + if (sl.column > 0) { + // The caret already takes one char + const space_needed = @as(usize, @intCast(sl.column - 1)); + + try out_stream.writeByteNTimes(' ', space_needed); + try tty_config.setColor(out_stream, .green); + try out_stream.writeAll("^"); + try tty_config.setColor(out_stream, .reset); + } + try out_stream.writeAll("\n"); + } else |err| switch (err) { + error.EndOfFile, error.FileNotFound => {}, + error.BadPathName => {}, + error.AccessDenied => {}, + else => return err, + } + } + } +} + +fn printLineFromFileAnyOs(out_stream: anytype, source_location: SourceLocation) !void { + // Need this to always block even in async I/O mode, because this could potentially + // be called from e.g. the event loop code crashing. + var f = try fs.cwd().openFile(source_location.file_name, .{}); + defer f.close(); + // TODO fstat and make sure that the file has the correct size + + var buf: [4096]u8 = undefined; + var amt_read = try f.read(buf[0..]); + const line_start = seek: { + var current_line_start: usize = 0; + var next_line: usize = 1; + while (next_line != source_location.line) { + const slice = buf[current_line_start..amt_read]; + if (mem.indexOfScalar(u8, slice, '\n')) |pos| { + next_line += 1; + if (pos == slice.len - 1) { + amt_read = try f.read(buf[0..]); + current_line_start = 0; + } else current_line_start += pos + 1; + } else if (amt_read < buf.len) { + return error.EndOfFile; + } else { + amt_read = try f.read(buf[0..]); + current_line_start = 0; + } + } + break :seek current_line_start; + }; + const slice = buf[line_start..amt_read]; + if (mem.indexOfScalar(u8, slice, '\n')) |pos| { + const line = slice[0 .. pos + 1]; + mem.replaceScalar(u8, line, '\t', ' '); + return out_stream.writeAll(line); + } else { // Line is the last inside the buffer, and requires another read to find delimiter. Alternatively the file ends. + mem.replaceScalar(u8, slice, '\t', ' '); + try out_stream.writeAll(slice); + while (amt_read == buf.len) { + amt_read = try f.read(buf[0..]); + if (mem.indexOfScalar(u8, buf[0..amt_read], '\n')) |pos| { + const line = buf[0 .. pos + 1]; + mem.replaceScalar(u8, line, '\t', ' '); + return out_stream.writeAll(line); + } else { + const line = buf[0..amt_read]; + mem.replaceScalar(u8, line, '\t', ' '); + try out_stream.writeAll(line); + } + } + // Make sure printing last line of file inserts extra newline + try out_stream.writeByte('\n'); + } +} + +test printLineFromFileAnyOs { + var output = std.ArrayList(u8).init(std.testing.allocator); + defer output.deinit(); + const output_stream = output.writer(); + + const allocator = std.testing.allocator; + const join = std.fs.path.join; + const expectError = std.testing.expectError; + const expectEqualStrings = std.testing.expectEqualStrings; + + var test_dir = std.testing.tmpDir(.{}); + defer test_dir.cleanup(); + // Relies on testing.tmpDir internals which is not ideal, but SourceLocation requires paths. + const test_dir_path = try join(allocator, &.{ ".zig-cache", "tmp", test_dir.sub_path[0..] }); + defer allocator.free(test_dir_path); + + // Cases + { + const path = try join(allocator, &.{ test_dir_path, "one_line.zig" }); + defer allocator.free(path); + try test_dir.dir.writeFile(.{ .sub_path = "one_line.zig", .data = "no new lines in this file, but one is printed anyway" }); + + try expectError(error.EndOfFile, printLineFromFileAnyOs(output_stream, .{ .file_name = path, .line = 2, .column = 0 })); + + try printLineFromFileAnyOs(output_stream, .{ .file_name = path, .line = 1, .column = 0 }); + try expectEqualStrings("no new lines in this file, but one is printed anyway\n", output.items); + output.clearRetainingCapacity(); + } + { + const path = try fs.path.join(allocator, &.{ test_dir_path, "three_lines.zig" }); + defer allocator.free(path); + try test_dir.dir.writeFile(.{ + .sub_path = "three_lines.zig", + .data = + \\1 + \\2 + \\3 + , + }); + + try printLineFromFileAnyOs(output_stream, .{ .file_name = path, .line = 1, .column = 0 }); + try expectEqualStrings("1\n", output.items); + output.clearRetainingCapacity(); + + try printLineFromFileAnyOs(output_stream, .{ .file_name = path, .line = 3, .column = 0 }); + try expectEqualStrings("3\n", output.items); + output.clearRetainingCapacity(); + } + { + const file = try test_dir.dir.createFile("line_overlaps_page_boundary.zig", .{}); + defer file.close(); + const path = try fs.path.join(allocator, &.{ test_dir_path, "line_overlaps_page_boundary.zig" }); + defer allocator.free(path); + + const overlap = 10; + var writer = file.writer(); + try writer.writeByteNTimes('a', std.heap.page_size_min - overlap); + try writer.writeByte('\n'); + try writer.writeByteNTimes('a', overlap); + + try printLineFromFileAnyOs(output_stream, .{ .file_name = path, .line = 2, .column = 0 }); + try expectEqualStrings(("a" ** overlap) ++ "\n", output.items); + output.clearRetainingCapacity(); + } + { + const file = try test_dir.dir.createFile("file_ends_on_page_boundary.zig", .{}); + defer file.close(); + const path = try fs.path.join(allocator, &.{ test_dir_path, "file_ends_on_page_boundary.zig" }); + defer allocator.free(path); + + var writer = file.writer(); + try writer.writeByteNTimes('a', std.heap.page_size_max); + + try printLineFromFileAnyOs(output_stream, .{ .file_name = path, .line = 1, .column = 0 }); + try expectEqualStrings(("a" ** std.heap.page_size_max) ++ "\n", output.items); + output.clearRetainingCapacity(); + } + { + const file = try test_dir.dir.createFile("very_long_first_line_spanning_multiple_pages.zig", .{}); + defer file.close(); + const path = try fs.path.join(allocator, &.{ test_dir_path, "very_long_first_line_spanning_multiple_pages.zig" }); + defer allocator.free(path); + + var writer = file.writer(); + try writer.writeByteNTimes('a', 3 * std.heap.page_size_max); + + try expectError(error.EndOfFile, printLineFromFileAnyOs(output_stream, .{ .file_name = path, .line = 2, .column = 0 })); + + try printLineFromFileAnyOs(output_stream, .{ .file_name = path, .line = 1, .column = 0 }); + try expectEqualStrings(("a" ** (3 * std.heap.page_size_max)) ++ "\n", output.items); + output.clearRetainingCapacity(); + + try writer.writeAll("a\na"); + + try printLineFromFileAnyOs(output_stream, .{ .file_name = path, .line = 1, .column = 0 }); + try expectEqualStrings(("a" ** (3 * std.heap.page_size_max)) ++ "a\n", output.items); + output.clearRetainingCapacity(); + + try printLineFromFileAnyOs(output_stream, .{ .file_name = path, .line = 2, .column = 0 }); + try expectEqualStrings("a\n", output.items); + output.clearRetainingCapacity(); + } + { + const file = try test_dir.dir.createFile("file_of_newlines.zig", .{}); + defer file.close(); + const path = try fs.path.join(allocator, &.{ test_dir_path, "file_of_newlines.zig" }); + defer allocator.free(path); + + var writer = file.writer(); + const real_file_start = 3 * std.heap.page_size_min; + try writer.writeByteNTimes('\n', real_file_start); + try writer.writeAll("abc\ndef"); + + try printLineFromFileAnyOs(output_stream, .{ .file_name = path, .line = real_file_start + 1, .column = 0 }); + try expectEqualStrings("abc\n", output.items); + output.clearRetainingCapacity(); + + try printLineFromFileAnyOs(output_stream, .{ .file_name = path, .line = real_file_start + 2, .column = 0 }); + try expectEqualStrings("def\n", output.items); + output.clearRetainingCapacity(); + } +} + +/// TODO multithreaded awareness +var debug_info_allocator: ?mem.Allocator = null; +var debug_info_arena_allocator: std.heap.ArenaAllocator = undefined; +fn getDebugInfoAllocator() mem.Allocator { + if (debug_info_allocator) |a| return a; + + debug_info_arena_allocator = std.heap.ArenaAllocator.init(std.heap.page_allocator); + const allocator = debug_info_arena_allocator.allocator(); + debug_info_allocator = allocator; + return allocator; +} + +/// Whether or not the current target can print useful debug information when a segfault occurs. +pub const have_segfault_handling_support = switch (native_os) { + .linux, + .macos, + .netbsd, + .solaris, + .illumos, + .windows, + => true, + + .freebsd, .openbsd => have_ucontext, + else => false, +}; + +const enable_segfault_handler = std.options.enable_segfault_handler; +pub const default_enable_segfault_handler = runtime_safety and have_segfault_handling_support; + +pub fn maybeEnableSegfaultHandler() void { + if (enable_segfault_handler) { + attachSegfaultHandler(); + } +} + +var windows_segfault_handle: ?windows.HANDLE = null; + +pub fn updateSegfaultHandler(act: ?*const posix.Sigaction) void { + posix.sigaction(posix.SIG.SEGV, act, null); + posix.sigaction(posix.SIG.ILL, act, null); + posix.sigaction(posix.SIG.BUS, act, null); + posix.sigaction(posix.SIG.FPE, act, null); +} + +/// Attaches a global SIGSEGV handler which calls `@panic("segmentation fault");` +pub fn attachSegfaultHandler() void { + if (!have_segfault_handling_support) { + @compileError("segfault handler not supported for this target"); + } + if (native_os == .windows) { + windows_segfault_handle = windows.kernel32.AddVectoredExceptionHandler(0, handleSegfaultWindows); + return; + } + var act = posix.Sigaction{ + .handler = .{ .sigaction = handleSegfaultPosix }, + .mask = posix.empty_sigset, + .flags = (posix.SA.SIGINFO | posix.SA.RESTART | posix.SA.RESETHAND), + }; + + updateSegfaultHandler(&act); +} + +fn resetSegfaultHandler() void { + if (native_os == .windows) { + if (windows_segfault_handle) |handle| { + assert(windows.kernel32.RemoveVectoredExceptionHandler(handle) != 0); + windows_segfault_handle = null; + } + return; + } + var act = posix.Sigaction{ + .handler = .{ .handler = posix.SIG.DFL }, + .mask = posix.empty_sigset, + .flags = 0, + }; + updateSegfaultHandler(&act); +} + +pub fn handleSegfaultPosix(sig: i32, info: *const posix.siginfo_t, ctx_ptr: ?*anyopaque) callconv(.c) noreturn { + // Reset to the default handler so that if a segfault happens in this handler it will crash + // the process. Also when this handler returns, the original instruction will be repeated + // and the resulting segfault will crash the process rather than continually dump stack traces. + resetSegfaultHandler(); + + const addr = switch (native_os) { + .linux => @intFromPtr(info.fields.sigfault.addr), + .freebsd, .macos => @intFromPtr(info.addr), + .netbsd => @intFromPtr(info.info.reason.fault.addr), + .openbsd => @intFromPtr(info.data.fault.addr), + .solaris, .illumos => @intFromPtr(info.reason.fault.addr), + else => unreachable, + }; + + const code = if (native_os == .netbsd) info.info.code else info.code; + nosuspend switch (panic_stage) { + 0 => { + panic_stage = 1; + _ = panicking.fetchAdd(1, .seq_cst); + + { + lockStdErr(); + defer unlockStdErr(); + + dumpSegfaultInfoPosix(sig, code, addr, ctx_ptr); + } + + waitForOtherThreadToFinishPanicking(); + }, + else => { + // panic mutex already locked + dumpSegfaultInfoPosix(sig, code, addr, ctx_ptr); + }, + }; + + // We cannot allow the signal handler to return because when it runs the original instruction + // again, the memory may be mapped and undefined behavior would occur rather than repeating + // the segfault. So we simply abort here. + posix.abort(); +} + +fn dumpSegfaultInfoPosix(sig: i32, code: i32, addr: usize, ctx_ptr: ?*anyopaque) void { + const stderr = io.getStdErr().writer(); + _ = switch (sig) { + posix.SIG.SEGV => if (native_arch == .x86_64 and native_os == .linux and code == 128) // SI_KERNEL + // x86_64 doesn't have a full 64-bit virtual address space. + // Addresses outside of that address space are non-canonical + // and the CPU won't provide the faulting address to us. + // This happens when accessing memory addresses such as 0xaaaaaaaaaaaaaaaa + // but can also happen when no addressable memory is involved; + // for example when reading/writing model-specific registers + // by executing `rdmsr` or `wrmsr` in user-space (unprivileged mode). + stderr.print("General protection exception (no address available)\n", .{}) + else + stderr.print("Segmentation fault at address 0x{x}\n", .{addr}), + posix.SIG.ILL => stderr.print("Illegal instruction at address 0x{x}\n", .{addr}), + posix.SIG.BUS => stderr.print("Bus error at address 0x{x}\n", .{addr}), + posix.SIG.FPE => stderr.print("Arithmetic exception at address 0x{x}\n", .{addr}), + else => unreachable, + } catch posix.abort(); + + switch (native_arch) { + .x86, + .x86_64, + .arm, + .armeb, + .thumb, + .thumbeb, + .aarch64, + .aarch64_be, + => { + // Some kernels don't align `ctx_ptr` properly. Handle this defensively. + const ctx: *align(1) posix.ucontext_t = @ptrCast(ctx_ptr); + var new_ctx: posix.ucontext_t = ctx.*; + if (builtin.os.tag.isDarwin() and builtin.cpu.arch == .aarch64) { + // The kernel incorrectly writes the contents of `__mcontext_data` right after `mcontext`, + // rather than after the 8 bytes of padding that are supposed to sit between the two. Copy the + // contents to the right place so that the `mcontext` pointer will be correct after the + // `relocateContext` call below. + new_ctx.__mcontext_data = @as(*align(1) extern struct { + onstack: c_int, + sigmask: std.c.sigset_t, + stack: std.c.stack_t, + link: ?*std.c.ucontext_t, + mcsize: u64, + mcontext: *std.c.mcontext_t, + __mcontext_data: std.c.mcontext_t align(@sizeOf(usize)), // Disable padding after `mcontext`. + }, @ptrCast(ctx)).__mcontext_data; + } + relocateContext(&new_ctx); + dumpStackTraceFromBase(&new_ctx); + }, + else => {}, + } +} + +fn handleSegfaultWindows(info: *windows.EXCEPTION_POINTERS) callconv(.winapi) c_long { + switch (info.ExceptionRecord.ExceptionCode) { + windows.EXCEPTION_DATATYPE_MISALIGNMENT => handleSegfaultWindowsExtra(info, 0, "Unaligned Memory Access"), + windows.EXCEPTION_ACCESS_VIOLATION => handleSegfaultWindowsExtra(info, 1, null), + windows.EXCEPTION_ILLEGAL_INSTRUCTION => handleSegfaultWindowsExtra(info, 2, null), + windows.EXCEPTION_STACK_OVERFLOW => handleSegfaultWindowsExtra(info, 0, "Stack Overflow"), + else => return windows.EXCEPTION_CONTINUE_SEARCH, + } +} + +fn handleSegfaultWindowsExtra(info: *windows.EXCEPTION_POINTERS, msg: u8, label: ?[]const u8) noreturn { + comptime assert(windows.CONTEXT != void); + nosuspend switch (panic_stage) { + 0 => { + panic_stage = 1; + _ = panicking.fetchAdd(1, .seq_cst); + + { + lockStdErr(); + defer unlockStdErr(); + + dumpSegfaultInfoWindows(info, msg, label); + } + + waitForOtherThreadToFinishPanicking(); + }, + 1 => { + panic_stage = 2; + io.getStdErr().writeAll("aborting due to recursive panic\n") catch {}; + }, + else => {}, + }; + posix.abort(); +} + +fn dumpSegfaultInfoWindows(info: *windows.EXCEPTION_POINTERS, msg: u8, label: ?[]const u8) void { + const stderr = io.getStdErr().writer(); + _ = switch (msg) { + 0 => stderr.print("{s}\n", .{label.?}), + 1 => stderr.print("Segmentation fault at address 0x{x}\n", .{info.ExceptionRecord.ExceptionInformation[1]}), + 2 => stderr.print("Illegal instruction at address 0x{x}\n", .{info.ContextRecord.getRegs().ip}), + else => unreachable, + } catch posix.abort(); + + dumpStackTraceFromBase(info.ContextRecord); +} + +pub fn dumpStackPointerAddr(prefix: []const u8) void { + const sp = asm ("" + : [argc] "={rsp}" (-> usize), + ); + print("{s} sp = 0x{x}\n", .{ prefix, sp }); +} + +test "manage resources correctly" { + if (builtin.strip_debug_info) return error.SkipZigTest; + + if (native_os == .wasi) return error.SkipZigTest; + + if (native_os == .windows) { + // https://github.com/ziglang/zig/issues/13963 + return error.SkipZigTest; + } + + // self-hosted debug info is still too buggy + if (builtin.zig_backend != .stage2_llvm) return error.SkipZigTest; + + const writer = std.io.null_writer; + var di = try SelfInfo.open(testing.allocator); + defer di.deinit(); + try printSourceAtAddress(&di, writer, showMyTrace(), io.tty.detectConfig(std.io.getStdErr())); +} + +noinline fn showMyTrace() usize { + return @returnAddress(); +} + +/// This API helps you track where a value originated and where it was mutated, +/// or any other points of interest. +/// In debug mode, it adds a small size penalty (104 bytes on 64-bit architectures) +/// to the aggregate that you add it to. +/// In release mode, it is size 0 and all methods are no-ops. +/// This is a pre-made type with default settings. +/// For more advanced usage, see `ConfigurableTrace`. +pub const Trace = ConfigurableTrace(2, 4, builtin.mode == .Debug); + +pub fn ConfigurableTrace(comptime size: usize, comptime stack_frame_count: usize, comptime is_enabled: bool) type { + return struct { + addrs: [actual_size][stack_frame_count]usize, + notes: [actual_size][]const u8, + index: Index, + + const actual_size = if (enabled) size else 0; + const Index = if (enabled) usize else u0; + + pub const init: @This() = .{ + .addrs = undefined, + .notes = undefined, + .index = 0, + }; + + pub const enabled = is_enabled; + + pub const add = if (enabled) addNoInline else addNoOp; + + pub noinline fn addNoInline(t: *@This(), note: []const u8) void { + comptime assert(enabled); + return addAddr(t, @returnAddress(), note); + } + + pub inline fn addNoOp(t: *@This(), note: []const u8) void { + _ = t; + _ = note; + comptime assert(!enabled); + } + + pub fn addAddr(t: *@This(), addr: usize, note: []const u8) void { + if (!enabled) return; + + if (t.index < size) { + t.notes[t.index] = note; + t.addrs[t.index] = [1]usize{0} ** stack_frame_count; + var stack_trace: std.builtin.StackTrace = .{ + .index = 0, + .instruction_addresses = &t.addrs[t.index], + }; + captureStackTrace(addr, &stack_trace); + } + // Keep counting even if the end is reached so that the + // user can find out how much more size they need. + t.index += 1; + } + + pub fn dump(t: @This()) void { + if (!enabled) return; + + const tty_config = io.tty.detectConfig(std.io.getStdErr()); + const stderr = io.getStdErr().writer(); + const end = @min(t.index, size); + const debug_info = getSelfDebugInfo() catch |err| { + stderr.print( + "Unable to dump stack trace: Unable to open debug info: {s}\n", + .{@errorName(err)}, + ) catch return; + return; + }; + for (t.addrs[0..end], 0..) |frames_array, i| { + stderr.print("{s}:\n", .{t.notes[i]}) catch return; + var frames_array_mutable = frames_array; + const frames = mem.sliceTo(frames_array_mutable[0..], 0); + const stack_trace: std.builtin.StackTrace = .{ + .index = frames.len, + .instruction_addresses = frames, + }; + writeStackTrace(stack_trace, stderr, debug_info, tty_config) catch continue; + } + if (t.index > end) { + stderr.print("{d} more traces not shown; consider increasing trace size\n", .{ + t.index - end, + }) catch return; + } + } + + pub fn format( + t: @This(), + comptime fmt: []const u8, + options: std.fmt.FormatOptions, + writer: anytype, + ) !void { + if (fmt.len != 0) std.fmt.invalidFmtError(fmt, t); + _ = options; + if (enabled) { + try writer.writeAll("\n"); + t.dump(); + try writer.writeAll("\n"); + } else { + return writer.writeAll("(value tracing disabled)"); + } + } + }; +} + +pub const SafetyLock = struct { + state: State = if (runtime_safety) .unlocked else .unknown, + + pub const State = if (runtime_safety) enum { unlocked, locked } else enum { unknown }; + + pub fn lock(l: *SafetyLock) void { + if (!runtime_safety) return; + assert(l.state == .unlocked); + l.state = .locked; + } + + pub fn unlock(l: *SafetyLock) void { + if (!runtime_safety) return; + assert(l.state == .locked); + l.state = .unlocked; + } + + pub fn assertUnlocked(l: SafetyLock) void { + if (!runtime_safety) return; + assert(l.state == .unlocked); + } + + pub fn assertLocked(l: SafetyLock) void { + if (!runtime_safety) return; + assert(l.state == .locked); + } +}; + +test SafetyLock { + var safety_lock: SafetyLock = .{}; + safety_lock.assertUnlocked(); + safety_lock.lock(); + safety_lock.assertLocked(); + safety_lock.unlock(); + safety_lock.assertUnlocked(); +} + +/// Detect whether the program is being executed in the Valgrind virtual machine. +/// +/// When Valgrind integrations are disabled, this returns comptime-known false. +/// Otherwise, the result is runtime-known. +pub inline fn inValgrind() bool { + if (@inComptime()) return false; + if (!builtin.valgrind_support) return false; + return std.valgrind.runningOnValgrind() > 0; +} + +test { + _ = &Dwarf; + _ = &MemoryAccessor; + _ = &FixedBufferReader; + _ = &Pdb; + _ = &SelfInfo; + _ = &dumpHex; +}