Morph MORPH
SIGN IN SIGN UP
ziglang / zig UNCLAIMED

Moved to Codeberg

0 0 0 Zig
Normal View History Raw
migrate from `std.Target.current` to `@import("builtin").target` closes #9388 closes #9321
2021-10-04 23:47:27 -07:00
const builtin = @import("builtin");
std.debug.Info: extract to separate file
2024-08-01 14:18:16 -07:00
const std = @import("std.zig");
breaking change to std.io API * Merge io.InStream and io.OutStream into io.File * Introduce io.OutStream and io.InStream interfaces - io.File implements both of these * Move mem.IncrementingAllocator to heap.IncrementingAllocator Instead of: ``` %return std.io.stderr.printf("hello\n"); ``` now do: ``` std.debug.warn("hello\n"); ``` To print to stdout, see `io.getStdOut()`. * Rename std.ArrayList.resizeDown to std.ArrayList.shrink.
2017-10-31 04:47:55 -04:00
const math = std.math;
const mem = std.mem;
const io = std.io;
extract std.posix from std.os closes #5019
2024-03-18 22:39:59 -07:00
const posix = std.posix;
clean up references to os
2019-05-26 13:17:34 -04:00
const fs = std.fs;
debug: fix edge cases in macOS debug symbol lookup This commit fixes two related things: 1. If the loop goes all the way through the slice without a match, on the last iteration `mid == symbols.len - 1` which causes `&symbols[mid + 1]` to be out of bounds. End one step before that instead. 2. If the address we're looking for is greater than the address of the last symbol in the slice, we now match it to that symbol. Previously, we would miss this case since we only matched if the address was _in between_ the address of two symbols.
2022-01-22 22:52:27 +01:00
const testing = std.testing;
disable segfault handler when panicking this prevents a segfault in stack trace printing to activate the segfault handler.
2019-07-22 12:15:16 -04:00
const root = @import("root");
starting to fix the regressions
2019-05-24 22:52:07 -04:00
const File = std.fs.File;
clean up references to os
2019-05-26 13:17:34 -04:00
const windows = std.os.windows;
migrate from `std.Target.current` to `@import("builtin").target` closes #9388 closes #9321
2021-10-04 23:47:27 -07:00
const native_arch = builtin.cpu.arch;
const native_os = builtin.os.tag;
std: change `@import("builtin")` to `std.builtin`
2021-04-12 16:43:50 -07:00
const native_endian = native_arch.endian();
progress toward stack trace printing
2016-08-17 20:11:04 -07:00
std.debug: reorg and clarify API goals After this commit: `std.debug.SelfInfo` is a cross-platform abstraction for the current executable's own debug information, with a goal of minimal code bloat and compilation speed penalty. `std.debug.Dwarf` does not assume the current executable is itself the thing being debugged, however, it does assume the debug info has the same CPU architecture and OS as the current executable. It is planned to remove this limitation.
2024-08-01 22:04:40 -07:00
pub const MemoryAccessor = @import("debug/MemoryAccessor.zig");
std.debug.FixedBufferReader is fine it does not need to be deprecated
2024-08-02 21:22:33 -07:00
pub const FixedBufferReader = @import("debug/FixedBufferReader.zig");
std: dwarf namespace reorg std.debug.Dwarf is the parsing/decoding logic. std.dwarf remains the unopinionated types and bits alone. If you look at this diff you can see a lot less redundancy in namespaces.
2024-08-01 13:40:47 -07:00
pub const Dwarf = @import("debug/Dwarf.zig");
std.debug: rename Info to SelfInfo This code has the hard-coded goal of supporting the executable's own debug information and makes design choices along that goal, such as memory-mapping the inputs, using dl_iterate_phdr, and doing conditional compilation on the host target. A more general-purpose implementation of debug information may be able to share code with this, but there are some fundamental incompatibilities. For example, the "SelfInfo" implementation wants to avoid bloating the binary with PDB on POSIX systems, and likewise DWARF on Windows systems, while a general-purpose implementation needs to support both PDB and DWARF from the same binary. It might, for example, inspect the debug information from a cross-compiled binary. `SourceLocation` now lives at `std.debug.SourceLocation` and is documented. Deprecate `std.debug.runtime_safety` because it returns the optimization mode of the standard library, when the caller probably wants to use the optimization mode of their own module. `std.pdb.Pdb` is moved to `std.debug.Pdb`, mirroring the recent extraction of `std.debug.Dwarf` from `std.dwarf`. I have no idea why we have both Module (with a Windows-specific definition) and WindowsModule. I left some passive aggressive doc comments to express my frustration.
2024-08-01 16:31:03 -07:00
pub const Pdb = @import("debug/Pdb.zig");
pub const SelfInfo = @import("debug/SelfInfo.zig");
introduce tool for dumping coverage file with debug info resolved. begin efforts of providing `std.debug.Info`, a cross-platform abstraction for loading debug information into an in-memory format that supports queries such as "what is the source location of this virtual memory address?" Unlike `std.debug.SelfInfo`, this API does not assume the debug information in question happens to match the host CPU architecture, OS, or other target properties.
2024-08-02 16:31:49 -07:00
pub const Info = @import("debug/Info.zig");
fuzzing: progress towards web UI * libfuzzer: close file after mmap * fuzzer/main.js: connect with EventSource and debug dump the messages. currently this prints how many fuzzer runs have been attempted to console.log. * extract some `std.debug.Info` logic into `std.debug.Coverage`. Prepares for consolidation across multiple different executables which share source files, and makes it possible to send all the PC/SourceLocation mapping data with 4 memcpy'd arrays. * std.Build.Fuzz: - spawn a thread to watch the message queue and signal event subscribers. - track coverage map data - respond to /events URL with EventSource messages on a timer
2024-08-04 00:16:28 -07:00
pub const Coverage = @import("debug/Coverage.zig");
std.debug: rename Info to SelfInfo This code has the hard-coded goal of supporting the executable's own debug information and makes design choices along that goal, such as memory-mapping the inputs, using dl_iterate_phdr, and doing conditional compilation on the host target. A more general-purpose implementation of debug information may be able to share code with this, but there are some fundamental incompatibilities. For example, the "SelfInfo" implementation wants to avoid bloating the binary with PDB on POSIX systems, and likewise DWARF on Windows systems, while a general-purpose implementation needs to support both PDB and DWARF from the same binary. It might, for example, inspect the debug information from a cross-compiled binary. `SourceLocation` now lives at `std.debug.SourceLocation` and is documented. Deprecate `std.debug.runtime_safety` because it returns the optimization mode of the standard library, when the caller probably wants to use the optimization mode of their own module. `std.pdb.Pdb` is moved to `std.debug.Pdb`, mirroring the recent extraction of `std.debug.Dwarf` from `std.dwarf`. I have no idea why we have both Module (with a Windows-specific definition) and WindowsModule. I left some passive aggressive doc comments to express my frustration.
2024-08-01 16:31:03 -07:00
compiler: yet more panic handler changes * `std.builtin.Panic` -> `std.builtin.panic`, because it is a namespace. * `root.Panic` -> `root.panic` for the same reason. There are type checks so that we still allow the legacy `pub fn panic` strategy in the 0.14.0 release. * `std.debug.SimplePanic` -> `std.debug.simple_panic`, same reason. * `std.debug.NoPanic` -> `std.debug.no_panic`, same reason. * `std.debug.FormattedPanic` is now a function `std.debug.FullPanic` which takes as input a `panicFn` and returns a namespace with all the panic functions. This handles the incredibly common case of just wanting to override how the message is printed, whilst keeping nice formatted panics. * Remove `std.builtin.panic.messages`; now, every safety panic has its own function. This reduces binary bloat, as calls to these functions no longer need to prepare any arguments (aside from the error return trace). * Remove some legacy declarations, since a zig1.wasm update has happened. Most of these were related to the panic handler, but a quick grep for "zig1" brought up a couple more results too. Also, add some missing type checks to Sema. Resolves: #22584 formatted -> full
2025-01-24 02:19:28 +00:00
pub const simple_panic = @import("debug/simple_panic.zig");
pub const no_panic = @import("debug/no_panic.zig");
/// 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`.
all: update for `panic.unwrapError` and `panic.call` signature changes
2025-01-24 04:20:55 +00:00
pub fn FullPanic(comptime panicFn: fn ([]const u8, ?usize) noreturn) type {
compiler: yet more panic handler changes * `std.builtin.Panic` -> `std.builtin.panic`, because it is a namespace. * `root.Panic` -> `root.panic` for the same reason. There are type checks so that we still allow the legacy `pub fn panic` strategy in the 0.14.0 release. * `std.debug.SimplePanic` -> `std.debug.simple_panic`, same reason. * `std.debug.NoPanic` -> `std.debug.no_panic`, same reason. * `std.debug.FormattedPanic` is now a function `std.debug.FullPanic` which takes as input a `panicFn` and returns a namespace with all the panic functions. This handles the incredibly common case of just wanting to override how the message is printed, whilst keeping nice formatted panics. * Remove `std.builtin.panic.messages`; now, every safety panic has its own function. This reduces binary bloat, as calls to these functions no longer need to prepare any arguments (aside from the error return trace). * Remove some legacy declarations, since a zig1.wasm update has happened. Most of these were related to the panic handler, but a quick grep for "zig1" brought up a couple more results too. Also, add some missing type checks to Sema. Resolves: #22584 formatted -> full
2025-01-24 02:19:28 +00:00
return struct {
pub const call = panicFn;
pub fn sentinelMismatch(expected: anytype, found: @TypeOf(expected)) noreturn {
@branchHint(.cold);
all: update for `panic.unwrapError` and `panic.call` signature changes
2025-01-24 04:20:55 +00:00
std.debug.panicExtra(@returnAddress(), "sentinel mismatch: expected {any}, found {any}", .{
compiler: yet more panic handler changes * `std.builtin.Panic` -> `std.builtin.panic`, because it is a namespace. * `root.Panic` -> `root.panic` for the same reason. There are type checks so that we still allow the legacy `pub fn panic` strategy in the 0.14.0 release. * `std.debug.SimplePanic` -> `std.debug.simple_panic`, same reason. * `std.debug.NoPanic` -> `std.debug.no_panic`, same reason. * `std.debug.FormattedPanic` is now a function `std.debug.FullPanic` which takes as input a `panicFn` and returns a namespace with all the panic functions. This handles the incredibly common case of just wanting to override how the message is printed, whilst keeping nice formatted panics. * Remove `std.builtin.panic.messages`; now, every safety panic has its own function. This reduces binary bloat, as calls to these functions no longer need to prepare any arguments (aside from the error return trace). * Remove some legacy declarations, since a zig1.wasm update has happened. Most of these were related to the panic handler, but a quick grep for "zig1" brought up a couple more results too. Also, add some missing type checks to Sema. Resolves: #22584 formatted -> full
2025-01-24 02:19:28 +00:00
expected, found,
});
}
all: update for `panic.unwrapError` and `panic.call` signature changes
2025-01-24 04:20:55 +00:00
pub fn unwrapError(err: anyerror) noreturn {
compiler: yet more panic handler changes * `std.builtin.Panic` -> `std.builtin.panic`, because it is a namespace. * `root.Panic` -> `root.panic` for the same reason. There are type checks so that we still allow the legacy `pub fn panic` strategy in the 0.14.0 release. * `std.debug.SimplePanic` -> `std.debug.simple_panic`, same reason. * `std.debug.NoPanic` -> `std.debug.no_panic`, same reason. * `std.debug.FormattedPanic` is now a function `std.debug.FullPanic` which takes as input a `panicFn` and returns a namespace with all the panic functions. This handles the incredibly common case of just wanting to override how the message is printed, whilst keeping nice formatted panics. * Remove `std.builtin.panic.messages`; now, every safety panic has its own function. This reduces binary bloat, as calls to these functions no longer need to prepare any arguments (aside from the error return trace). * Remove some legacy declarations, since a zig1.wasm update has happened. Most of these were related to the panic handler, but a quick grep for "zig1" brought up a couple more results too. Also, add some missing type checks to Sema. Resolves: #22584 formatted -> full
2025-01-24 02:19:28 +00:00
@branchHint(.cold);
all: update for `panic.unwrapError` and `panic.call` signature changes
2025-01-24 04:20:55 +00:00
std.debug.panicExtra(@returnAddress(), "attempt to unwrap error: {s}", .{@errorName(err)});
compiler: yet more panic handler changes * `std.builtin.Panic` -> `std.builtin.panic`, because it is a namespace. * `root.Panic` -> `root.panic` for the same reason. There are type checks so that we still allow the legacy `pub fn panic` strategy in the 0.14.0 release. * `std.debug.SimplePanic` -> `std.debug.simple_panic`, same reason. * `std.debug.NoPanic` -> `std.debug.no_panic`, same reason. * `std.debug.FormattedPanic` is now a function `std.debug.FullPanic` which takes as input a `panicFn` and returns a namespace with all the panic functions. This handles the incredibly common case of just wanting to override how the message is printed, whilst keeping nice formatted panics. * Remove `std.builtin.panic.messages`; now, every safety panic has its own function. This reduces binary bloat, as calls to these functions no longer need to prepare any arguments (aside from the error return trace). * Remove some legacy declarations, since a zig1.wasm update has happened. Most of these were related to the panic handler, but a quick grep for "zig1" brought up a couple more results too. Also, add some missing type checks to Sema. Resolves: #22584 formatted -> full
2025-01-24 02:19:28 +00:00
}
pub fn outOfBounds(index: usize, len: usize) noreturn {
@branchHint(.cold);
all: update for `panic.unwrapError` and `panic.call` signature changes
2025-01-24 04:20:55 +00:00
std.debug.panicExtra(@returnAddress(), "index out of bounds: index {d}, len {d}", .{ index, len });
compiler: yet more panic handler changes * `std.builtin.Panic` -> `std.builtin.panic`, because it is a namespace. * `root.Panic` -> `root.panic` for the same reason. There are type checks so that we still allow the legacy `pub fn panic` strategy in the 0.14.0 release. * `std.debug.SimplePanic` -> `std.debug.simple_panic`, same reason. * `std.debug.NoPanic` -> `std.debug.no_panic`, same reason. * `std.debug.FormattedPanic` is now a function `std.debug.FullPanic` which takes as input a `panicFn` and returns a namespace with all the panic functions. This handles the incredibly common case of just wanting to override how the message is printed, whilst keeping nice formatted panics. * Remove `std.builtin.panic.messages`; now, every safety panic has its own function. This reduces binary bloat, as calls to these functions no longer need to prepare any arguments (aside from the error return trace). * Remove some legacy declarations, since a zig1.wasm update has happened. Most of these were related to the panic handler, but a quick grep for "zig1" brought up a couple more results too. Also, add some missing type checks to Sema. Resolves: #22584 formatted -> full
2025-01-24 02:19:28 +00:00
}
pub fn startGreaterThanEnd(start: usize, end: usize) noreturn {
@branchHint(.cold);
all: update for `panic.unwrapError` and `panic.call` signature changes
2025-01-24 04:20:55 +00:00
std.debug.panicExtra(@returnAddress(), "start index {d} is larger than end index {d}", .{ start, end });
compiler: yet more panic handler changes * `std.builtin.Panic` -> `std.builtin.panic`, because it is a namespace. * `root.Panic` -> `root.panic` for the same reason. There are type checks so that we still allow the legacy `pub fn panic` strategy in the 0.14.0 release. * `std.debug.SimplePanic` -> `std.debug.simple_panic`, same reason. * `std.debug.NoPanic` -> `std.debug.no_panic`, same reason. * `std.debug.FormattedPanic` is now a function `std.debug.FullPanic` which takes as input a `panicFn` and returns a namespace with all the panic functions. This handles the incredibly common case of just wanting to override how the message is printed, whilst keeping nice formatted panics. * Remove `std.builtin.panic.messages`; now, every safety panic has its own function. This reduces binary bloat, as calls to these functions no longer need to prepare any arguments (aside from the error return trace). * Remove some legacy declarations, since a zig1.wasm update has happened. Most of these were related to the panic handler, but a quick grep for "zig1" brought up a couple more results too. Also, add some missing type checks to Sema. Resolves: #22584 formatted -> full
2025-01-24 02:19:28 +00:00
}
pub fn inactiveUnionField(active: anytype, accessed: @TypeOf(active)) noreturn {
@branchHint(.cold);
all: update for `panic.unwrapError` and `panic.call` signature changes
2025-01-24 04:20:55 +00:00
std.debug.panicExtra(@returnAddress(), "access of union field '{s}' while field '{s}' is active", .{
compiler: yet more panic handler changes * `std.builtin.Panic` -> `std.builtin.panic`, because it is a namespace. * `root.Panic` -> `root.panic` for the same reason. There are type checks so that we still allow the legacy `pub fn panic` strategy in the 0.14.0 release. * `std.debug.SimplePanic` -> `std.debug.simple_panic`, same reason. * `std.debug.NoPanic` -> `std.debug.no_panic`, same reason. * `std.debug.FormattedPanic` is now a function `std.debug.FullPanic` which takes as input a `panicFn` and returns a namespace with all the panic functions. This handles the incredibly common case of just wanting to override how the message is printed, whilst keeping nice formatted panics. * Remove `std.builtin.panic.messages`; now, every safety panic has its own function. This reduces binary bloat, as calls to these functions no longer need to prepare any arguments (aside from the error return trace). * Remove some legacy declarations, since a zig1.wasm update has happened. Most of these were related to the panic handler, but a quick grep for "zig1" brought up a couple more results too. Also, add some missing type checks to Sema. Resolves: #22584 formatted -> full
2025-01-24 02:19:28 +00:00
@tagName(accessed), @tagName(active),
});
}
Sema: allow `@ptrCast` of slices changing the length Also, refactor `Sema.ptrCastFull` to not be a horrifying hellscape.
2025-02-01 07:37:27 +00:00
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});
}
compiler: yet more panic handler changes * `std.builtin.Panic` -> `std.builtin.panic`, because it is a namespace. * `root.Panic` -> `root.panic` for the same reason. There are type checks so that we still allow the legacy `pub fn panic` strategy in the 0.14.0 release. * `std.debug.SimplePanic` -> `std.debug.simple_panic`, same reason. * `std.debug.NoPanic` -> `std.debug.no_panic`, same reason. * `std.debug.FormattedPanic` is now a function `std.debug.FullPanic` which takes as input a `panicFn` and returns a namespace with all the panic functions. This handles the incredibly common case of just wanting to override how the message is printed, whilst keeping nice formatted panics. * Remove `std.builtin.panic.messages`; now, every safety panic has its own function. This reduces binary bloat, as calls to these functions no longer need to prepare any arguments (aside from the error return trace). * Remove some legacy declarations, since a zig1.wasm update has happened. Most of these were related to the panic handler, but a quick grep for "zig1" brought up a couple more results too. Also, add some missing type checks to Sema. Resolves: #22584 formatted -> full
2025-01-24 02:19:28 +00:00
pub fn reachedUnreachable() noreturn {
@branchHint(.cold);
all: update for `panic.unwrapError` and `panic.call` signature changes
2025-01-24 04:20:55 +00:00
call("reached unreachable code", @returnAddress());
compiler: yet more panic handler changes * `std.builtin.Panic` -> `std.builtin.panic`, because it is a namespace. * `root.Panic` -> `root.panic` for the same reason. There are type checks so that we still allow the legacy `pub fn panic` strategy in the 0.14.0 release. * `std.debug.SimplePanic` -> `std.debug.simple_panic`, same reason. * `std.debug.NoPanic` -> `std.debug.no_panic`, same reason. * `std.debug.FormattedPanic` is now a function `std.debug.FullPanic` which takes as input a `panicFn` and returns a namespace with all the panic functions. This handles the incredibly common case of just wanting to override how the message is printed, whilst keeping nice formatted panics. * Remove `std.builtin.panic.messages`; now, every safety panic has its own function. This reduces binary bloat, as calls to these functions no longer need to prepare any arguments (aside from the error return trace). * Remove some legacy declarations, since a zig1.wasm update has happened. Most of these were related to the panic handler, but a quick grep for "zig1" brought up a couple more results too. Also, add some missing type checks to Sema. Resolves: #22584 formatted -> full
2025-01-24 02:19:28 +00:00
}
pub fn unwrapNull() noreturn {
@branchHint(.cold);
all: update for `panic.unwrapError` and `panic.call` signature changes
2025-01-24 04:20:55 +00:00
call("attempt to use null value", @returnAddress());
compiler: yet more panic handler changes * `std.builtin.Panic` -> `std.builtin.panic`, because it is a namespace. * `root.Panic` -> `root.panic` for the same reason. There are type checks so that we still allow the legacy `pub fn panic` strategy in the 0.14.0 release. * `std.debug.SimplePanic` -> `std.debug.simple_panic`, same reason. * `std.debug.NoPanic` -> `std.debug.no_panic`, same reason. * `std.debug.FormattedPanic` is now a function `std.debug.FullPanic` which takes as input a `panicFn` and returns a namespace with all the panic functions. This handles the incredibly common case of just wanting to override how the message is printed, whilst keeping nice formatted panics. * Remove `std.builtin.panic.messages`; now, every safety panic has its own function. This reduces binary bloat, as calls to these functions no longer need to prepare any arguments (aside from the error return trace). * Remove some legacy declarations, since a zig1.wasm update has happened. Most of these were related to the panic handler, but a quick grep for "zig1" brought up a couple more results too. Also, add some missing type checks to Sema. Resolves: #22584 formatted -> full
2025-01-24 02:19:28 +00:00
}
pub fn castToNull() noreturn {
@branchHint(.cold);
all: update for `panic.unwrapError` and `panic.call` signature changes
2025-01-24 04:20:55 +00:00
call("cast causes pointer to be null", @returnAddress());
compiler: yet more panic handler changes * `std.builtin.Panic` -> `std.builtin.panic`, because it is a namespace. * `root.Panic` -> `root.panic` for the same reason. There are type checks so that we still allow the legacy `pub fn panic` strategy in the 0.14.0 release. * `std.debug.SimplePanic` -> `std.debug.simple_panic`, same reason. * `std.debug.NoPanic` -> `std.debug.no_panic`, same reason. * `std.debug.FormattedPanic` is now a function `std.debug.FullPanic` which takes as input a `panicFn` and returns a namespace with all the panic functions. This handles the incredibly common case of just wanting to override how the message is printed, whilst keeping nice formatted panics. * Remove `std.builtin.panic.messages`; now, every safety panic has its own function. This reduces binary bloat, as calls to these functions no longer need to prepare any arguments (aside from the error return trace). * Remove some legacy declarations, since a zig1.wasm update has happened. Most of these were related to the panic handler, but a quick grep for "zig1" brought up a couple more results too. Also, add some missing type checks to Sema. Resolves: #22584 formatted -> full
2025-01-24 02:19:28 +00:00
}
pub fn incorrectAlignment() noreturn {
@branchHint(.cold);
all: update for `panic.unwrapError` and `panic.call` signature changes
2025-01-24 04:20:55 +00:00
call("incorrect alignment", @returnAddress());
compiler: yet more panic handler changes * `std.builtin.Panic` -> `std.builtin.panic`, because it is a namespace. * `root.Panic` -> `root.panic` for the same reason. There are type checks so that we still allow the legacy `pub fn panic` strategy in the 0.14.0 release. * `std.debug.SimplePanic` -> `std.debug.simple_panic`, same reason. * `std.debug.NoPanic` -> `std.debug.no_panic`, same reason. * `std.debug.FormattedPanic` is now a function `std.debug.FullPanic` which takes as input a `panicFn` and returns a namespace with all the panic functions. This handles the incredibly common case of just wanting to override how the message is printed, whilst keeping nice formatted panics. * Remove `std.builtin.panic.messages`; now, every safety panic has its own function. This reduces binary bloat, as calls to these functions no longer need to prepare any arguments (aside from the error return trace). * Remove some legacy declarations, since a zig1.wasm update has happened. Most of these were related to the panic handler, but a quick grep for "zig1" brought up a couple more results too. Also, add some missing type checks to Sema. Resolves: #22584 formatted -> full
2025-01-24 02:19:28 +00:00
}
pub fn invalidErrorCode() noreturn {
@branchHint(.cold);
all: update for `panic.unwrapError` and `panic.call` signature changes
2025-01-24 04:20:55 +00:00
call("invalid error code", @returnAddress());
compiler: yet more panic handler changes * `std.builtin.Panic` -> `std.builtin.panic`, because it is a namespace. * `root.Panic` -> `root.panic` for the same reason. There are type checks so that we still allow the legacy `pub fn panic` strategy in the 0.14.0 release. * `std.debug.SimplePanic` -> `std.debug.simple_panic`, same reason. * `std.debug.NoPanic` -> `std.debug.no_panic`, same reason. * `std.debug.FormattedPanic` is now a function `std.debug.FullPanic` which takes as input a `panicFn` and returns a namespace with all the panic functions. This handles the incredibly common case of just wanting to override how the message is printed, whilst keeping nice formatted panics. * Remove `std.builtin.panic.messages`; now, every safety panic has its own function. This reduces binary bloat, as calls to these functions no longer need to prepare any arguments (aside from the error return trace). * Remove some legacy declarations, since a zig1.wasm update has happened. Most of these were related to the panic handler, but a quick grep for "zig1" brought up a couple more results too. Also, add some missing type checks to Sema. Resolves: #22584 formatted -> full
2025-01-24 02:19:28 +00:00
}
pub fn castTruncatedData() noreturn {
@branchHint(.cold);
all: update for `panic.unwrapError` and `panic.call` signature changes
2025-01-24 04:20:55 +00:00
call("integer cast truncated bits", @returnAddress());
compiler: yet more panic handler changes * `std.builtin.Panic` -> `std.builtin.panic`, because it is a namespace. * `root.Panic` -> `root.panic` for the same reason. There are type checks so that we still allow the legacy `pub fn panic` strategy in the 0.14.0 release. * `std.debug.SimplePanic` -> `std.debug.simple_panic`, same reason. * `std.debug.NoPanic` -> `std.debug.no_panic`, same reason. * `std.debug.FormattedPanic` is now a function `std.debug.FullPanic` which takes as input a `panicFn` and returns a namespace with all the panic functions. This handles the incredibly common case of just wanting to override how the message is printed, whilst keeping nice formatted panics. * Remove `std.builtin.panic.messages`; now, every safety panic has its own function. This reduces binary bloat, as calls to these functions no longer need to prepare any arguments (aside from the error return trace). * Remove some legacy declarations, since a zig1.wasm update has happened. Most of these were related to the panic handler, but a quick grep for "zig1" brought up a couple more results too. Also, add some missing type checks to Sema. Resolves: #22584 formatted -> full
2025-01-24 02:19:28 +00:00
}
pub fn negativeToUnsigned() noreturn {
@branchHint(.cold);
all: update for `panic.unwrapError` and `panic.call` signature changes
2025-01-24 04:20:55 +00:00
call("attempt to cast negative value to unsigned integer", @returnAddress());
compiler: yet more panic handler changes * `std.builtin.Panic` -> `std.builtin.panic`, because it is a namespace. * `root.Panic` -> `root.panic` for the same reason. There are type checks so that we still allow the legacy `pub fn panic` strategy in the 0.14.0 release. * `std.debug.SimplePanic` -> `std.debug.simple_panic`, same reason. * `std.debug.NoPanic` -> `std.debug.no_panic`, same reason. * `std.debug.FormattedPanic` is now a function `std.debug.FullPanic` which takes as input a `panicFn` and returns a namespace with all the panic functions. This handles the incredibly common case of just wanting to override how the message is printed, whilst keeping nice formatted panics. * Remove `std.builtin.panic.messages`; now, every safety panic has its own function. This reduces binary bloat, as calls to these functions no longer need to prepare any arguments (aside from the error return trace). * Remove some legacy declarations, since a zig1.wasm update has happened. Most of these were related to the panic handler, but a quick grep for "zig1" brought up a couple more results too. Also, add some missing type checks to Sema. Resolves: #22584 formatted -> full
2025-01-24 02:19:28 +00:00
}
pub fn integerOverflow() noreturn {
@branchHint(.cold);
all: update for `panic.unwrapError` and `panic.call` signature changes
2025-01-24 04:20:55 +00:00
call("integer overflow", @returnAddress());
compiler: yet more panic handler changes * `std.builtin.Panic` -> `std.builtin.panic`, because it is a namespace. * `root.Panic` -> `root.panic` for the same reason. There are type checks so that we still allow the legacy `pub fn panic` strategy in the 0.14.0 release. * `std.debug.SimplePanic` -> `std.debug.simple_panic`, same reason. * `std.debug.NoPanic` -> `std.debug.no_panic`, same reason. * `std.debug.FormattedPanic` is now a function `std.debug.FullPanic` which takes as input a `panicFn` and returns a namespace with all the panic functions. This handles the incredibly common case of just wanting to override how the message is printed, whilst keeping nice formatted panics. * Remove `std.builtin.panic.messages`; now, every safety panic has its own function. This reduces binary bloat, as calls to these functions no longer need to prepare any arguments (aside from the error return trace). * Remove some legacy declarations, since a zig1.wasm update has happened. Most of these were related to the panic handler, but a quick grep for "zig1" brought up a couple more results too. Also, add some missing type checks to Sema. Resolves: #22584 formatted -> full
2025-01-24 02:19:28 +00:00
}
pub fn shlOverflow() noreturn {
@branchHint(.cold);
all: update for `panic.unwrapError` and `panic.call` signature changes
2025-01-24 04:20:55 +00:00
call("left shift overflowed bits", @returnAddress());
compiler: yet more panic handler changes * `std.builtin.Panic` -> `std.builtin.panic`, because it is a namespace. * `root.Panic` -> `root.panic` for the same reason. There are type checks so that we still allow the legacy `pub fn panic` strategy in the 0.14.0 release. * `std.debug.SimplePanic` -> `std.debug.simple_panic`, same reason. * `std.debug.NoPanic` -> `std.debug.no_panic`, same reason. * `std.debug.FormattedPanic` is now a function `std.debug.FullPanic` which takes as input a `panicFn` and returns a namespace with all the panic functions. This handles the incredibly common case of just wanting to override how the message is printed, whilst keeping nice formatted panics. * Remove `std.builtin.panic.messages`; now, every safety panic has its own function. This reduces binary bloat, as calls to these functions no longer need to prepare any arguments (aside from the error return trace). * Remove some legacy declarations, since a zig1.wasm update has happened. Most of these were related to the panic handler, but a quick grep for "zig1" brought up a couple more results too. Also, add some missing type checks to Sema. Resolves: #22584 formatted -> full
2025-01-24 02:19:28 +00:00
}
pub fn shrOverflow() noreturn {
@branchHint(.cold);
all: update for `panic.unwrapError` and `panic.call` signature changes
2025-01-24 04:20:55 +00:00
call("right shift overflowed bits", @returnAddress());
compiler: yet more panic handler changes * `std.builtin.Panic` -> `std.builtin.panic`, because it is a namespace. * `root.Panic` -> `root.panic` for the same reason. There are type checks so that we still allow the legacy `pub fn panic` strategy in the 0.14.0 release. * `std.debug.SimplePanic` -> `std.debug.simple_panic`, same reason. * `std.debug.NoPanic` -> `std.debug.no_panic`, same reason. * `std.debug.FormattedPanic` is now a function `std.debug.FullPanic` which takes as input a `panicFn` and returns a namespace with all the panic functions. This handles the incredibly common case of just wanting to override how the message is printed, whilst keeping nice formatted panics. * Remove `std.builtin.panic.messages`; now, every safety panic has its own function. This reduces binary bloat, as calls to these functions no longer need to prepare any arguments (aside from the error return trace). * Remove some legacy declarations, since a zig1.wasm update has happened. Most of these were related to the panic handler, but a quick grep for "zig1" brought up a couple more results too. Also, add some missing type checks to Sema. Resolves: #22584 formatted -> full
2025-01-24 02:19:28 +00:00
}
pub fn divideByZero() noreturn {
@branchHint(.cold);
all: update for `panic.unwrapError` and `panic.call` signature changes
2025-01-24 04:20:55 +00:00
call("division by zero", @returnAddress());
compiler: yet more panic handler changes * `std.builtin.Panic` -> `std.builtin.panic`, because it is a namespace. * `root.Panic` -> `root.panic` for the same reason. There are type checks so that we still allow the legacy `pub fn panic` strategy in the 0.14.0 release. * `std.debug.SimplePanic` -> `std.debug.simple_panic`, same reason. * `std.debug.NoPanic` -> `std.debug.no_panic`, same reason. * `std.debug.FormattedPanic` is now a function `std.debug.FullPanic` which takes as input a `panicFn` and returns a namespace with all the panic functions. This handles the incredibly common case of just wanting to override how the message is printed, whilst keeping nice formatted panics. * Remove `std.builtin.panic.messages`; now, every safety panic has its own function. This reduces binary bloat, as calls to these functions no longer need to prepare any arguments (aside from the error return trace). * Remove some legacy declarations, since a zig1.wasm update has happened. Most of these were related to the panic handler, but a quick grep for "zig1" brought up a couple more results too. Also, add some missing type checks to Sema. Resolves: #22584 formatted -> full
2025-01-24 02:19:28 +00:00
}
pub fn exactDivisionRemainder() noreturn {
@branchHint(.cold);
all: update for `panic.unwrapError` and `panic.call` signature changes
2025-01-24 04:20:55 +00:00
call("exact division produced remainder", @returnAddress());
compiler: yet more panic handler changes * `std.builtin.Panic` -> `std.builtin.panic`, because it is a namespace. * `root.Panic` -> `root.panic` for the same reason. There are type checks so that we still allow the legacy `pub fn panic` strategy in the 0.14.0 release. * `std.debug.SimplePanic` -> `std.debug.simple_panic`, same reason. * `std.debug.NoPanic` -> `std.debug.no_panic`, same reason. * `std.debug.FormattedPanic` is now a function `std.debug.FullPanic` which takes as input a `panicFn` and returns a namespace with all the panic functions. This handles the incredibly common case of just wanting to override how the message is printed, whilst keeping nice formatted panics. * Remove `std.builtin.panic.messages`; now, every safety panic has its own function. This reduces binary bloat, as calls to these functions no longer need to prepare any arguments (aside from the error return trace). * Remove some legacy declarations, since a zig1.wasm update has happened. Most of these were related to the panic handler, but a quick grep for "zig1" brought up a couple more results too. Also, add some missing type checks to Sema. Resolves: #22584 formatted -> full
2025-01-24 02:19:28 +00:00
}
pub fn integerPartOutOfBounds() noreturn {
@branchHint(.cold);
all: update for `panic.unwrapError` and `panic.call` signature changes
2025-01-24 04:20:55 +00:00
call("integer part of floating point value out of bounds", @returnAddress());
compiler: yet more panic handler changes * `std.builtin.Panic` -> `std.builtin.panic`, because it is a namespace. * `root.Panic` -> `root.panic` for the same reason. There are type checks so that we still allow the legacy `pub fn panic` strategy in the 0.14.0 release. * `std.debug.SimplePanic` -> `std.debug.simple_panic`, same reason. * `std.debug.NoPanic` -> `std.debug.no_panic`, same reason. * `std.debug.FormattedPanic` is now a function `std.debug.FullPanic` which takes as input a `panicFn` and returns a namespace with all the panic functions. This handles the incredibly common case of just wanting to override how the message is printed, whilst keeping nice formatted panics. * Remove `std.builtin.panic.messages`; now, every safety panic has its own function. This reduces binary bloat, as calls to these functions no longer need to prepare any arguments (aside from the error return trace). * Remove some legacy declarations, since a zig1.wasm update has happened. Most of these were related to the panic handler, but a quick grep for "zig1" brought up a couple more results too. Also, add some missing type checks to Sema. Resolves: #22584 formatted -> full
2025-01-24 02:19:28 +00:00
}
pub fn corruptSwitch() noreturn {
@branchHint(.cold);
all: update for `panic.unwrapError` and `panic.call` signature changes
2025-01-24 04:20:55 +00:00
call("switch on corrupt value", @returnAddress());
compiler: yet more panic handler changes * `std.builtin.Panic` -> `std.builtin.panic`, because it is a namespace. * `root.Panic` -> `root.panic` for the same reason. There are type checks so that we still allow the legacy `pub fn panic` strategy in the 0.14.0 release. * `std.debug.SimplePanic` -> `std.debug.simple_panic`, same reason. * `std.debug.NoPanic` -> `std.debug.no_panic`, same reason. * `std.debug.FormattedPanic` is now a function `std.debug.FullPanic` which takes as input a `panicFn` and returns a namespace with all the panic functions. This handles the incredibly common case of just wanting to override how the message is printed, whilst keeping nice formatted panics. * Remove `std.builtin.panic.messages`; now, every safety panic has its own function. This reduces binary bloat, as calls to these functions no longer need to prepare any arguments (aside from the error return trace). * Remove some legacy declarations, since a zig1.wasm update has happened. Most of these were related to the panic handler, but a quick grep for "zig1" brought up a couple more results too. Also, add some missing type checks to Sema. Resolves: #22584 formatted -> full
2025-01-24 02:19:28 +00:00
}
pub fn shiftRhsTooBig() noreturn {
@branchHint(.cold);
all: update for `panic.unwrapError` and `panic.call` signature changes
2025-01-24 04:20:55 +00:00
call("shift amount is greater than the type size", @returnAddress());
compiler: yet more panic handler changes * `std.builtin.Panic` -> `std.builtin.panic`, because it is a namespace. * `root.Panic` -> `root.panic` for the same reason. There are type checks so that we still allow the legacy `pub fn panic` strategy in the 0.14.0 release. * `std.debug.SimplePanic` -> `std.debug.simple_panic`, same reason. * `std.debug.NoPanic` -> `std.debug.no_panic`, same reason. * `std.debug.FormattedPanic` is now a function `std.debug.FullPanic` which takes as input a `panicFn` and returns a namespace with all the panic functions. This handles the incredibly common case of just wanting to override how the message is printed, whilst keeping nice formatted panics. * Remove `std.builtin.panic.messages`; now, every safety panic has its own function. This reduces binary bloat, as calls to these functions no longer need to prepare any arguments (aside from the error return trace). * Remove some legacy declarations, since a zig1.wasm update has happened. Most of these were related to the panic handler, but a quick grep for "zig1" brought up a couple more results too. Also, add some missing type checks to Sema. Resolves: #22584 formatted -> full
2025-01-24 02:19:28 +00:00
}
pub fn invalidEnumValue() noreturn {
@branchHint(.cold);
all: update for `panic.unwrapError` and `panic.call` signature changes
2025-01-24 04:20:55 +00:00
call("invalid enum value", @returnAddress());
compiler: yet more panic handler changes * `std.builtin.Panic` -> `std.builtin.panic`, because it is a namespace. * `root.Panic` -> `root.panic` for the same reason. There are type checks so that we still allow the legacy `pub fn panic` strategy in the 0.14.0 release. * `std.debug.SimplePanic` -> `std.debug.simple_panic`, same reason. * `std.debug.NoPanic` -> `std.debug.no_panic`, same reason. * `std.debug.FormattedPanic` is now a function `std.debug.FullPanic` which takes as input a `panicFn` and returns a namespace with all the panic functions. This handles the incredibly common case of just wanting to override how the message is printed, whilst keeping nice formatted panics. * Remove `std.builtin.panic.messages`; now, every safety panic has its own function. This reduces binary bloat, as calls to these functions no longer need to prepare any arguments (aside from the error return trace). * Remove some legacy declarations, since a zig1.wasm update has happened. Most of these were related to the panic handler, but a quick grep for "zig1" brought up a couple more results too. Also, add some missing type checks to Sema. Resolves: #22584 formatted -> full
2025-01-24 02:19:28 +00:00
}
pub fn forLenMismatch() noreturn {
@branchHint(.cold);
all: update for `panic.unwrapError` and `panic.call` signature changes
2025-01-24 04:20:55 +00:00
call("for loop over objects with non-equal lengths", @returnAddress());
compiler: yet more panic handler changes * `std.builtin.Panic` -> `std.builtin.panic`, because it is a namespace. * `root.Panic` -> `root.panic` for the same reason. There are type checks so that we still allow the legacy `pub fn panic` strategy in the 0.14.0 release. * `std.debug.SimplePanic` -> `std.debug.simple_panic`, same reason. * `std.debug.NoPanic` -> `std.debug.no_panic`, same reason. * `std.debug.FormattedPanic` is now a function `std.debug.FullPanic` which takes as input a `panicFn` and returns a namespace with all the panic functions. This handles the incredibly common case of just wanting to override how the message is printed, whilst keeping nice formatted panics. * Remove `std.builtin.panic.messages`; now, every safety panic has its own function. This reduces binary bloat, as calls to these functions no longer need to prepare any arguments (aside from the error return trace). * Remove some legacy declarations, since a zig1.wasm update has happened. Most of these were related to the panic handler, but a quick grep for "zig1" brought up a couple more results too. Also, add some missing type checks to Sema. Resolves: #22584 formatted -> full
2025-01-24 02:19:28 +00:00
}
make `@memcpy` and `@memmove` share panic handlers
2025-04-27 12:17:59 -07:00
/// Delete after next zig1.wasm update
pub const memcpyLenMismatch = copyLenMismatch;
pub fn copyLenMismatch() noreturn {
compiler: yet more panic handler changes * `std.builtin.Panic` -> `std.builtin.panic`, because it is a namespace. * `root.Panic` -> `root.panic` for the same reason. There are type checks so that we still allow the legacy `pub fn panic` strategy in the 0.14.0 release. * `std.debug.SimplePanic` -> `std.debug.simple_panic`, same reason. * `std.debug.NoPanic` -> `std.debug.no_panic`, same reason. * `std.debug.FormattedPanic` is now a function `std.debug.FullPanic` which takes as input a `panicFn` and returns a namespace with all the panic functions. This handles the incredibly common case of just wanting to override how the message is printed, whilst keeping nice formatted panics. * Remove `std.builtin.panic.messages`; now, every safety panic has its own function. This reduces binary bloat, as calls to these functions no longer need to prepare any arguments (aside from the error return trace). * Remove some legacy declarations, since a zig1.wasm update has happened. Most of these were related to the panic handler, but a quick grep for "zig1" brought up a couple more results too. Also, add some missing type checks to Sema. Resolves: #22584 formatted -> full
2025-01-24 02:19:28 +00:00
@branchHint(.cold);
make `@memcpy` and `@memmove` share panic handlers
2025-04-27 12:17:59 -07:00
call("source and destination arguments have non-equal lengths", @returnAddress());
compiler: yet more panic handler changes * `std.builtin.Panic` -> `std.builtin.panic`, because it is a namespace. * `root.Panic` -> `root.panic` for the same reason. There are type checks so that we still allow the legacy `pub fn panic` strategy in the 0.14.0 release. * `std.debug.SimplePanic` -> `std.debug.simple_panic`, same reason. * `std.debug.NoPanic` -> `std.debug.no_panic`, same reason. * `std.debug.FormattedPanic` is now a function `std.debug.FullPanic` which takes as input a `panicFn` and returns a namespace with all the panic functions. This handles the incredibly common case of just wanting to override how the message is printed, whilst keeping nice formatted panics. * Remove `std.builtin.panic.messages`; now, every safety panic has its own function. This reduces binary bloat, as calls to these functions no longer need to prepare any arguments (aside from the error return trace). * Remove some legacy declarations, since a zig1.wasm update has happened. Most of these were related to the panic handler, but a quick grep for "zig1" brought up a couple more results too. Also, add some missing type checks to Sema. Resolves: #22584 formatted -> full
2025-01-24 02:19:28 +00:00
}
pub fn memcpyAlias() noreturn {
@branchHint(.cold);
all: update for `panic.unwrapError` and `panic.call` signature changes
2025-01-24 04:20:55 +00:00
call("@memcpy arguments alias", @returnAddress());
compiler: yet more panic handler changes * `std.builtin.Panic` -> `std.builtin.panic`, because it is a namespace. * `root.Panic` -> `root.panic` for the same reason. There are type checks so that we still allow the legacy `pub fn panic` strategy in the 0.14.0 release. * `std.debug.SimplePanic` -> `std.debug.simple_panic`, same reason. * `std.debug.NoPanic` -> `std.debug.no_panic`, same reason. * `std.debug.FormattedPanic` is now a function `std.debug.FullPanic` which takes as input a `panicFn` and returns a namespace with all the panic functions. This handles the incredibly common case of just wanting to override how the message is printed, whilst keeping nice formatted panics. * Remove `std.builtin.panic.messages`; now, every safety panic has its own function. This reduces binary bloat, as calls to these functions no longer need to prepare any arguments (aside from the error return trace). * Remove some legacy declarations, since a zig1.wasm update has happened. Most of these were related to the panic handler, but a quick grep for "zig1" brought up a couple more results too. Also, add some missing type checks to Sema. Resolves: #22584 formatted -> full
2025-01-24 02:19:28 +00:00
}
pub fn noreturnReturned() noreturn {
@branchHint(.cold);
all: update for `panic.unwrapError` and `panic.call` signature changes
2025-01-24 04:20:55 +00:00
call("'noreturn' function returned", @returnAddress());
compiler: yet more panic handler changes * `std.builtin.Panic` -> `std.builtin.panic`, because it is a namespace. * `root.Panic` -> `root.panic` for the same reason. There are type checks so that we still allow the legacy `pub fn panic` strategy in the 0.14.0 release. * `std.debug.SimplePanic` -> `std.debug.simple_panic`, same reason. * `std.debug.NoPanic` -> `std.debug.no_panic`, same reason. * `std.debug.FormattedPanic` is now a function `std.debug.FullPanic` which takes as input a `panicFn` and returns a namespace with all the panic functions. This handles the incredibly common case of just wanting to override how the message is printed, whilst keeping nice formatted panics. * Remove `std.builtin.panic.messages`; now, every safety panic has its own function. This reduces binary bloat, as calls to these functions no longer need to prepare any arguments (aside from the error return trace). * Remove some legacy declarations, since a zig1.wasm update has happened. Most of these were related to the panic handler, but a quick grep for "zig1" brought up a couple more results too. Also, add some missing type checks to Sema. Resolves: #22584 formatted -> full
2025-01-24 02:19:28 +00:00
}
};
}
embrace panic helpers Introduces `std.builtin.Panic` which is a complete interface for panicking. Provide `std.debug.FormattedPanic` and `std.debug.SimplePanic` and let the user choose, or make their own.
2024-09-26 14:24:18 -07:00
std.debug: rename Info to SelfInfo This code has the hard-coded goal of supporting the executable's own debug information and makes design choices along that goal, such as memory-mapping the inputs, using dl_iterate_phdr, and doing conditional compilation on the host target. A more general-purpose implementation of debug information may be able to share code with this, but there are some fundamental incompatibilities. For example, the "SelfInfo" implementation wants to avoid bloating the binary with PDB on POSIX systems, and likewise DWARF on Windows systems, while a general-purpose implementation needs to support both PDB and DWARF from the same binary. It might, for example, inspect the debug information from a cross-compiled binary. `SourceLocation` now lives at `std.debug.SourceLocation` and is documented. Deprecate `std.debug.runtime_safety` because it returns the optimization mode of the standard library, when the caller probably wants to use the optimization mode of their own module. `std.pdb.Pdb` is moved to `std.debug.Pdb`, mirroring the recent extraction of `std.debug.Dwarf` from `std.dwarf`. I have no idea why we have both Module (with a Windows-specific definition) and WindowsModule. I left some passive aggressive doc comments to express my frustration.
2024-08-01 16:31:03 -07:00
/// Unresolved source locations can be represented with a single `usize` that
/// corresponds to a virtual memory address of the program counter. Combined
/// with debug information, those values can be converted into a resolved
/// source location, including file, line, and column.
pub const SourceLocation = struct {
line: u64,
column: u64,
file_name: []const u8,
code coverage dumping tool basic implementation * std.debug.Dwarf: add `sortCompileUnits` along with a field to track the state for the purpose of assertions and correct API usage. This makes batch lookups faster. - in the future, findCompileUnit should be enhanced to rely on sorted compile units as well. * implement `std.debug.Dwarf.resolveSourceLocations` as well as `std.debug.Info.resolveSourceLocations`. It's still pretty slow, since it calls getLineNumberInfo for each array element, repeating a lot of work unnecessarily. * integrate these APIs with `std.Progress` to understand what is taking so long. The output I'm seeing from this tool shows a lot of missing source locations. In particular, the main area of interest is missing for my tokenizer fuzzing example.
2024-08-02 17:45:31 -07:00
pub const invalid: SourceLocation = .{
.line = 0,
.column = 0,
.file_name = &.{},
};
std.debug: rename Info to SelfInfo This code has the hard-coded goal of supporting the executable's own debug information and makes design choices along that goal, such as memory-mapping the inputs, using dl_iterate_phdr, and doing conditional compilation on the host target. A more general-purpose implementation of debug information may be able to share code with this, but there are some fundamental incompatibilities. For example, the "SelfInfo" implementation wants to avoid bloating the binary with PDB on POSIX systems, and likewise DWARF on Windows systems, while a general-purpose implementation needs to support both PDB and DWARF from the same binary. It might, for example, inspect the debug information from a cross-compiled binary. `SourceLocation` now lives at `std.debug.SourceLocation` and is documented. Deprecate `std.debug.runtime_safety` because it returns the optimization mode of the standard library, when the caller probably wants to use the optimization mode of their own module. `std.pdb.Pdb` is moved to `std.debug.Pdb`, mirroring the recent extraction of `std.debug.Dwarf` from `std.dwarf`. I have no idea why we have both Module (with a Windows-specific definition) and WindowsModule. I left some passive aggressive doc comments to express my frustration.
2024-08-01 16:31:03 -07:00
};
std: dwarf namespace reorg std.debug.Dwarf is the parsing/decoding logic. std.dwarf remains the unopinionated types and bits alone. If you look at this diff you can see a lot less redundancy in namespaces.
2024-08-01 13:40:47 -07:00
introduce tool for dumping coverage file with debug info resolved. begin efforts of providing `std.debug.Info`, a cross-platform abstraction for loading debug information into an in-memory format that supports queries such as "what is the source location of this virtual memory address?" Unlike `std.debug.SelfInfo`, this API does not assume the debug information in question happens to match the host CPU architecture, OS, or other target properties.
2024-08-02 16:31:49 -07:00
pub const Symbol = struct {
name: []const u8 = "???",
compile_unit_name: []const u8 = "???",
source_location: ?SourceLocation = null,
};
std.debug: rename Info to SelfInfo This code has the hard-coded goal of supporting the executable's own debug information and makes design choices along that goal, such as memory-mapping the inputs, using dl_iterate_phdr, and doing conditional compilation on the host target. A more general-purpose implementation of debug information may be able to share code with this, but there are some fundamental incompatibilities. For example, the "SelfInfo" implementation wants to avoid bloating the binary with PDB on POSIX systems, and likewise DWARF on Windows systems, while a general-purpose implementation needs to support both PDB and DWARF from the same binary. It might, for example, inspect the debug information from a cross-compiled binary. `SourceLocation` now lives at `std.debug.SourceLocation` and is documented. Deprecate `std.debug.runtime_safety` because it returns the optimization mode of the standard library, when the caller probably wants to use the optimization mode of their own module. `std.pdb.Pdb` is moved to `std.debug.Pdb`, mirroring the recent extraction of `std.debug.Dwarf` from `std.dwarf`. I have no idea why we have both Module (with a Windows-specific definition) and WindowsModule. I left some passive aggressive doc comments to express my frustration.
2024-08-01 16:31:03 -07:00
/// 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.
M:N threading * add std.atomic.QueueMpsc.isEmpty * make std.debug.global_allocator thread-safe * std.event.Loop: now you have to choose between - initSingleThreaded - initMultiThreaded * std.event.Loop multiplexes coroutines onto kernel threads * Remove std.event.Loop.stop. Instead the event loop run() function returns once there are no pending coroutines. * fix crash in ir.cpp for calling methods under some conditions * small progress self-hosted compiler, analyzing top level declarations * Introduce std.event.Lock for synchronizing coroutines * introduce std.event.Locked(T) for data that only 1 coroutine should modify at once. * make the self hosted compiler use multi threaded event loop * make std.heap.DirectAllocator thread-safe See #174 TODO: * call sched_getaffinity instead of hard coding thread pool size 4 * support for Windows and MacOS * #1194 * #1197
2018-07-05 15:09:02 -04:00
pub const runtime_safety = switch (builtin.mode) {
clean up references to os
2019-05-26 13:17:34 -04:00
.Debug, .ReleaseSafe => true,
.ReleaseFast, .ReleaseSmall => false,
M:N threading * add std.atomic.QueueMpsc.isEmpty * make std.debug.global_allocator thread-safe * std.event.Loop: now you have to choose between - initSingleThreaded - initMultiThreaded * std.event.Loop multiplexes coroutines onto kernel threads * Remove std.event.Loop.stop. Instead the event loop run() function returns once there are no pending coroutines. * fix crash in ir.cpp for calling methods under some conditions * small progress self-hosted compiler, analyzing top level declarations * Introduce std.event.Lock for synchronizing coroutines * introduce std.event.Locked(T) for data that only 1 coroutine should modify at once. * make the self hosted compiler use multi threaded event loop * make std.heap.DirectAllocator thread-safe See #174 TODO: * call sched_getaffinity instead of hard coding thread pool size 4 * support for Windows and MacOS * #1194 * #1197
2018-07-05 15:09:02 -04:00
};
Move sys_can_stack_trace from GPA to std.debug so that it can be re-used as needed
2022-06-25 21:27:56 -07:00
pub const sys_can_stack_trace = switch (builtin.cpu.arch) {
// Observed to go into an infinite loop.
// TODO: Make this work.
.mips,
.mipsel,
std.debug: Also disable stack traces on mips64.
2024-08-16 11:07:18 +02:00
.mips64,
.mips64el,
std.debug: Disable stack traces on s390x.
2024-10-01 12:45:34 +02:00
.s390x,
Move sys_can_stack_trace from GPA to std.debug so that it can be re-used as needed
2022-06-25 21:27:56 -07:00
=> false,
// `@returnAddress()` in LLVM 10 gives
// "Non-Emscripten WebAssembly hasn't implemented __builtin_return_address".
Lower `@returnAddress` to a constant 0 in Emscripten release builds Emscripten currently implements `emscripten_return_address()` by calling out into JavaScript and parsing a stack trace, which introduces significant overhead that we would prefer to avoid in release builds. This is especially problematic for allocators because the generic parts of `std.mem.Allocator` make frequent use of `@returnAddress`, even though very few allocator implementations even observe the return address, which makes allocators nigh unusable for performance-critical applications like games if the compiler is unable to devirtualize the allocator calls.
2025-03-23 13:12:45 +01:00
// On Emscripten, Zig only supports `@returnAddress()` in debug builds
// because Emscripten's implementation is very slow.
Move sys_can_stack_trace from GPA to std.debug so that it can be re-used as needed
2022-06-25 21:27:56 -07:00
.wasm32,
.wasm64,
Lower `@returnAddress` to a constant 0 in Emscripten release builds Emscripten currently implements `emscripten_return_address()` by calling out into JavaScript and parsing a stack trace, which introduces significant overhead that we would prefer to avoid in release builds. This is especially problematic for allocators because the generic parts of `std.mem.Allocator` make frequent use of `@returnAddress`, even though very few allocator implementations even observe the return address, which makes allocators nigh unusable for performance-critical applications like games if the compiler is unable to devirtualize the allocator calls.
2025-03-23 13:12:45 +01:00
=> native_os == .emscripten and builtin.mode == .Debug,
Move sys_can_stack_trace from GPA to std.debug so that it can be re-used as needed
2022-06-25 21:27:56 -07:00
// `@returnAddress()` is unsupported in LLVM 13.
.bpfel,
.bpfeb,
=> false,
else => true,
};
update the codebase for the new std.Progress API
2024-05-24 08:22:47 -07:00
/// 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();
}
std.json.Value: added dumpStream(), utilize WriteStream for dump()
2019-10-28 21:33:40 +01:00
Add std.debug.print for "printf debugging"
2020-06-02 19:22:22 +02:00
/// Print to stderr, unbuffered, and silently returning on failure. Intended
/// for use in "printf debugging." Use `std.log` functions for proper logging.
run zig fmt on std lib and self hosted
2020-07-11 14:09:04 +03:00
pub fn print(comptime fmt: []const u8, args: anytype) void {
update the codebase for the new std.Progress API
2024-05-24 08:22:47 -07:00
lockStdErr();
defer unlockStdErr();
std: remove std.debug.getStderrStream Rather than migrate to new 'writer' interface, just remove it
2020-06-15 23:51:25 +10:00
const stderr = io.getStdErr().writer();
zig fmt
2020-05-05 05:14:22 -06:00
nosuspend stderr.print(fmt, args) catch return;
breaking change to std.io API * Merge io.InStream and io.OutStream into io.File * Introduce io.OutStream and io.InStream interfaces - io.File implements both of these * Move mem.IncrementingAllocator to heap.IncrementingAllocator Instead of: ``` %return std.io.stderr.printf("hello\n"); ``` now do: ``` std.debug.warn("hello\n"); ``` To print to stdout, see `io.getStdOut()`. * Rename std.ArrayList.resizeDown to std.ArrayList.shrink.
2017-10-31 04:47:55 -04:00
}
MacOS stack traces use the already mmapped executable ...rather than trying to find the executable on the file system. Also use a more robust PIE offset calculation based on the available metadata. And for the last function, use the data that tells the end rather than assuming 4K. Also they print in a consistent way with Linux stack traces.
2018-08-23 16:11:34 -04:00
organize std lib concurrency primitives and add RwLock * move concurrency primitives that always operate on kernel threads to the std.Thread namespace * remove std.SpinLock. Nobody should use this in a non-freestanding environment; the other primitives are always preferable. In freestanding, it will be necessary to put custom spin logic in there, so there are no use cases for a std lib version. * move some std lib files to the top level fields convention * add std.Thread.spinLoopHint * add std.Thread.Condition * add std.Thread.Semaphore * new implementation of std.Thread.Mutex for Windows and non-pthreads Linux * add std.Thread.RwLock Implementations provided by @kprotty
2021-01-14 20:41:37 -07:00
pub fn getStderrMutex() *std.Thread.Mutex {
update the codebase for the new std.Progress API
2024-05-24 08:22:47 -07:00
@compileError("deprecated. call std.debug.lockStdErr() and std.debug.unlockStdErr() instead which will integrate properly with std.Progress");
std.json.Value: added dumpStream(), utilize WriteStream for dump()
2019-10-28 21:33:40 +01:00
}
MacOS stack traces use the already mmapped executable ...rather than trying to find the executable on the file system. Also use a more robust PIE offset calculation based on the available metadata. And for the last function, use the data that tells the end rather than assuming 4K. Also they print in a consistent way with Linux stack traces.
2018-08-23 16:11:34 -04:00
/// TODO multithreaded awareness
std.debug: rename Info to SelfInfo This code has the hard-coded goal of supporting the executable's own debug information and makes design choices along that goal, such as memory-mapping the inputs, using dl_iterate_phdr, and doing conditional compilation on the host target. A more general-purpose implementation of debug information may be able to share code with this, but there are some fundamental incompatibilities. For example, the "SelfInfo" implementation wants to avoid bloating the binary with PDB on POSIX systems, and likewise DWARF on Windows systems, while a general-purpose implementation needs to support both PDB and DWARF from the same binary. It might, for example, inspect the debug information from a cross-compiled binary. `SourceLocation` now lives at `std.debug.SourceLocation` and is documented. Deprecate `std.debug.runtime_safety` because it returns the optimization mode of the standard library, when the caller probably wants to use the optimization mode of their own module. `std.pdb.Pdb` is moved to `std.debug.Pdb`, mirroring the recent extraction of `std.debug.Dwarf` from `std.dwarf`. I have no idea why we have both Module (with a Windows-specific definition) and WindowsModule. I left some passive aggressive doc comments to express my frustration.
2024-08-01 16:31:03 -07:00
var self_debug_info: ?SelfInfo = null;
MacOS stack traces use the already mmapped executable ...rather than trying to find the executable on the file system. Also use a more robust PIE offset calculation based on the available metadata. And for the last function, use the data that tells the end rather than assuming 4K. Also they print in a consistent way with Linux stack traces.
2018-08-23 16:11:34 -04:00
std.debug: rename Info to SelfInfo This code has the hard-coded goal of supporting the executable's own debug information and makes design choices along that goal, such as memory-mapping the inputs, using dl_iterate_phdr, and doing conditional compilation on the host target. A more general-purpose implementation of debug information may be able to share code with this, but there are some fundamental incompatibilities. For example, the "SelfInfo" implementation wants to avoid bloating the binary with PDB on POSIX systems, and likewise DWARF on Windows systems, while a general-purpose implementation needs to support both PDB and DWARF from the same binary. It might, for example, inspect the debug information from a cross-compiled binary. `SourceLocation` now lives at `std.debug.SourceLocation` and is documented. Deprecate `std.debug.runtime_safety` because it returns the optimization mode of the standard library, when the caller probably wants to use the optimization mode of their own module. `std.pdb.Pdb` is moved to `std.debug.Pdb`, mirroring the recent extraction of `std.debug.Dwarf` from `std.dwarf`. I have no idea why we have both Module (with a Windows-specific definition) and WindowsModule. I left some passive aggressive doc comments to express my frustration.
2024-08-01 16:31:03 -07:00
pub fn getSelfDebugInfo() !*SelfInfo {
MacOS stack traces use the already mmapped executable ...rather than trying to find the executable on the file system. Also use a more robust PIE offset calculation based on the available metadata. And for the last function, use the data that tells the end rather than assuming 4K. Also they print in a consistent way with Linux stack traces.
2018-08-23 16:11:34 -04:00
if (self_debug_info) |*info| {
fix getting debug info twice in default panic handler
2018-01-15 16:26:13 -05:00
return info;
} else {
fix compilation on powerpc GNU systems ...which have a ucontext_t but not a PC register. The current stack unwinding implementation does not yet support this architecture. Also fix name of `std.debug.SelfInfo.openSelf` to remove redundancy. Also removed this hook into root providing an "openSelfDebugInfo" function. Sorry, this debugging code is not of sufficient quality to offer a plugin API right now.
2024-08-02 12:00:08 -07:00
self_debug_info = try SelfInfo.open(getDebugInfoAllocator());
MacOS stack traces use the already mmapped executable ...rather than trying to find the executable on the file system. Also use a more robust PIE offset calculation based on the available metadata. And for the last function, use the data that tells the end rather than assuming 4K. Also they print in a consistent way with Linux stack traces.
2018-08-23 16:11:34 -04:00
return &self_debug_info.?;
fix getting debug info twice in default panic handler
2018-01-15 16:26:13 -05:00
}
}
general-use std.debug.hexdump for printing hexdumps Recently, when I've been working with structures of data that is not directly in RAM but rather laid out in bytes somewhere else, it was always very useful to print out maybe the next 50 bytes or the previous 50 bytes or so to see what's ahead or before me. I would usually do this with a quick `std.debug.print("{any}\n", .{bytes});` or something but the output is not as nice obviously.
2023-08-03 09:02:24 +02:00
/// Tries to print a hexadecimal view of the bytes, unbuffered, and ignores any error returned.
fixups from previous commit * rename the functions * make the other function public and give it a better name * interact with stderr_mutex * std lib test coverage
2024-01-08 00:21:57 -07:00
/// Obtains the stderr mutex while dumping.
debug: correct dump_hex and dump_hex_fallible casing (#19296) #1097 is closed.
2024-07-22 09:00:08 +09:00
pub fn dumpHex(bytes: []const u8) void {
update the codebase for the new std.Progress API
2024-05-24 08:22:47 -07:00
lockStdErr();
defer unlockStdErr();
debug: correct dump_hex and dump_hex_fallible casing (#19296) #1097 is closed.
2024-07-22 09:00:08 +09:00
dumpHexFallible(bytes) catch {};
general-use std.debug.hexdump for printing hexdumps Recently, when I've been working with structures of data that is not directly in RAM but rather laid out in bytes somewhere else, it was always very useful to print out maybe the next 50 bytes or the previous 50 bytes or so to see what's ahead or before me. I would usually do this with a quick `std.debug.print("{any}\n", .{bytes});` or something but the output is not as nice obviously.
2023-08-03 09:02:24 +02:00
}
fixups from previous commit * rename the functions * make the other function public and give it a better name * interact with stderr_mutex * std lib test coverage
2024-01-08 00:21:57 -07:00
/// Prints a hexadecimal view of the bytes, unbuffered, returning any error that occurs.
debug: correct dump_hex and dump_hex_fallible casing (#19296) #1097 is closed.
2024-07-22 09:00:08 +09:00
pub fn dumpHexFallible(bytes: []const u8) !void {
general-use std.debug.hexdump for printing hexdumps Recently, when I've been working with structures of data that is not directly in RAM but rather laid out in bytes somewhere else, it was always very useful to print out maybe the next 50 bytes or the previous 50 bytes or so to see what's ahead or before me. I would usually do this with a quick `std.debug.print("{any}\n", .{bytes});` or something but the output is not as nice obviously.
2023-08-03 09:02:24 +02:00
const stderr = std.io.getStdErr();
const ttyconf = std.io.tty.detectConfig(stderr);
const writer = stderr.writer();
Fix std.debug.dumpHex address offsets
2025-03-25 23:20:56 +01:00
try dumpHexInternal(bytes, ttyconf, writer);
}
fn dumpHexInternal(bytes: []const u8, ttyconf: std.io.tty.Config, writer: anytype) !void {
general-use std.debug.hexdump for printing hexdumps Recently, when I've been working with structures of data that is not directly in RAM but rather laid out in bytes somewhere else, it was always very useful to print out maybe the next 50 bytes or the previous 50 bytes or so to see what's ahead or before me. I would usually do this with a quick `std.debug.print("{any}\n", .{bytes});` or something but the output is not as nice obviously.
2023-08-03 09:02:24 +02:00
var chunks = mem.window(u8, bytes, 16, 16);
while (chunks.next()) |window| {
// 1. Print the address.
Fix std.debug.dumpHex address offsets
2025-03-25 23:20:56 +01:00
const address = (@intFromPtr(bytes.ptr) + 0x10 * (std.math.divCeil(usize, chunks.index orelse bytes.len, 16) catch unreachable)) - 0x10;
general-use std.debug.hexdump for printing hexdumps Recently, when I've been working with structures of data that is not directly in RAM but rather laid out in bytes somewhere else, it was always very useful to print out maybe the next 50 bytes or the previous 50 bytes or so to see what's ahead or before me. I would usually do this with a quick `std.debug.print("{any}\n", .{bytes});` or something but the output is not as nice obviously.
2023-08-03 09:02:24 +02:00
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 {
fixups from previous commit * rename the functions * make the other function public and give it a better name * interact with stderr_mutex * std lib test coverage
2024-01-08 00:21:57 -07:00
// Related: https://github.com/ziglang/zig/issues/7600
general-use std.debug.hexdump for printing hexdumps Recently, when I've been working with structures of data that is not directly in RAM but rather laid out in bytes somewhere else, it was always very useful to print out maybe the next 50 bytes or the previous 50 bytes or so to see what's ahead or before me. I would usually do this with a quick `std.debug.print("{any}\n", .{bytes});` or something but the output is not as nice obviously.
2023-08-03 09:02:24 +02:00
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');
}
}
Fix std.debug.dumpHex address offsets
2025-03-25 23:20:56 +01:00
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);
}
*WIP* proof of concept error return traces
2018-01-12 02:12:11 -05:00
/// Tries to print the current stack trace to stderr, unbuffered, and ignores any error returned.
macos stack traces: read debug info sections from .o files
2018-08-23 23:08:34 -04:00
/// TODO multithreaded awareness
refactor stack trace code to remove global state
2018-03-09 22:21:13 -05:00
pub fn dumpCurrentStackTrace(start_addr: ?usize) void {
zig fmt
2020-05-05 05:14:22 -06:00
nosuspend {
std.Target: Remove functions that just wrap component functions. Functions like isMinGW() and isGnuLibC() have a good reason to exist: They look at multiple components of the target. But functions like isWasm(), isDarwin(), isGnu(), etc only exist to save 4-8 characters. I don't think this is a good enough reason to keep them, especially given that: * It's not immediately obvious to a reader whether target.isDarwin() means the same thing as target.os.tag.isDarwin() precisely because isMinGW() and similar functions *do* look at multiple components. * It's not clear where we would draw the line. The logical conclusion before this commit would be to also wrap Arch.isX86(), Os.Tag.isSolarish(), Abi.isOpenHarmony(), etc... this obviously quickly gets out of hand. * It's nice to just have a single correct way of doing something.
2025-01-24 03:45:38 +01:00
if (builtin.target.cpu.arch.isWasm()) {
wasm: Fix unreachable paths When the last instruction is a debug instruction, the type of it is void. Similarly for 'noreturn' emit an 'unreachable' instruction to tell the wasm-validator the path cannot be reached. Also respect the '--strip' flag in the self-hosted wasm linker and not emit a 'name' section when the flag is set to `true`.
2022-04-17 19:41:05 +02:00
if (native_os == .wasi) {
const stderr = io.getStdErr().writer();
stderr.print("Unable to dump stack trace: not implemented for Wasm\n", .{}) catch return;
}
wasm: Add support for debug info This implements basic DWARF output when building for the wasm target. Stacktraces, however, are currently not supported.
2022-04-18 13:11:37 +02:00
return;
}
wasm: Fix unreachable paths When the last instruction is a debug instruction, the type of it is void. Similarly for 'noreturn' emit an 'unreachable' instruction to tell the wasm-validator the path cannot be reached. Also respect the '--strip' flag in the self-hosted wasm linker and not emit a 'name' section when the flag is set to `true`.
2022-04-17 19:41:05 +02:00
const stderr = io.getStdErr().writer();
std.event.Loop: promote the fs thread to be available for all OS's
2020-05-02 00:41:19 -04:00
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| {
std: Use {s} instead of {} when printing strings
2020-11-26 09:48:12 +01:00
stderr.print("Unable to dump stack trace: Unable to open debug info: {s}\n", .{@errorName(err)}) catch return;
std.event.Loop: promote the fs thread to be available for all OS's
2020-05-02 00:41:19 -04:00
return;
};
std: Move std.debug.{TTY.Config,detectTTYConfig} to std.io.tty Also get rid of the TTY wrapper struct, which was exlusively used as a namespace - this is done by the tty.zig root struct now. detectTTYConfig has been renamed to just detectConfig, which is enough given the new namespace. Additionally, a doc comment had been added.
2023-05-21 14:27:28 +01:00
writeCurrentStackTrace(stderr, debug_info, io.tty.detectConfig(io.getStdErr()), start_addr) catch |err| {
std: Use {s} instead of {} when printing strings
2020-11-26 09:48:12 +01:00
stderr.print("Unable to dump stack trace: {s}\n", .{@errorName(err)}) catch return;
std.event.Loop: promote the fs thread to be available for all OS's
2020-05-02 00:41:19 -04:00
return;
};
fix debug builds of WASI
2019-05-27 02:16:05 -04:00
}
*WIP* proof of concept error return traces
2018-01-12 02:12:11 -05:00
}
std.c reorganization It is now composed of these main sections: * Declarations that are shared among all operating systems. * Declarations that have the same name, but different type signatures depending on the operating system. Often multiple operating systems share the same type signatures however. * Declarations that are specific to a single operating system. - These are imported one per line so you can see where they come from, protected by a comptime block to prevent accessing the wrong one. Closes #19352 by changing the convention to making types `void` and functions `{}`, so that it becomes possible to update `@hasDecl` sites to use `@TypeOf(f) != void` or `T != void`. Happily, this ended up removing some duplicate logic and update some bitrotted feature detection checks. A handful of types have been modified to gain namespacing and type safety. This is a breaking change. Oh, and the last usage of `usingnamespace` site is eliminated.
2024-07-18 23:35:19 -07:00
pub const have_ucontext = posix.ucontext_t != void;
debug: add relocateContext dwarf: fixup tests that used a ThreadContext
2023-07-09 14:45:34 -04:00
debug: add dupeContext, store a pointer to a copy of ThreadContext on UnwindContext
2023-07-07 10:13:48 -04:00
/// 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
dwarf: skip register tests on unimplemented arch / os, add tests for type convesions debug: dupeContext -> copyContext
2023-07-08 01:16:11 -04:00
/// use internal pointers within this structure. To make a copy, use `copyContext`.
debug: rename StackTraceContext to ThreadContext dwarf: use ThreadContext instead of os.ucontext_t dwarf: add regBytes impl for windows dwarf: fixup expression types for non-native
2023-07-06 22:02:47 -04:00
pub const ThreadContext = blk: {
debug: use an explicit context type instead of anytype for dumpStackTraceFromBase, update crash_report to use this for exceptions
2023-05-25 13:11:21 -04:00
if (native_os == .windows) {
extract std.posix from std.os closes #5019
2024-03-18 22:39:59 -07:00
break :blk windows.CONTEXT;
c: fixup getcontext debug: supports_context -> have_ucontext, supports_getcontext -> have_getcontext test: rework dwarf_unwind test case to also test the non-libc path
2023-07-01 15:23:37 -04:00
} else if (have_ucontext) {
extract std.posix from std.os closes #5019
2024-03-18 22:39:59 -07:00
break :blk posix.ucontext_t;
debug: use an explicit context type instead of anytype for dumpStackTraceFromBase, update crash_report to use this for exceptions
2023-05-25 13:11:21 -04:00
} else {
break :blk void;
}
};
debug: add relocateContext dwarf: fixup tests that used a ThreadContext
2023-07-09 14:45:34 -04:00
/// 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);
}
debug: fix initialization of the optional fields on StackIterator dwarf: documentation fixups target: enable unwind tables on macho
2023-07-10 18:43:19 -04:00
/// Updates any internal pointers in the context to reflect its current location
debug: add relocateContext dwarf: fixup tests that used a ThreadContext
2023-07-09 14:45:34 -04:00
pub fn relocateContext(context: *ThreadContext) void {
return switch (native_os) {
.macos => {
context.mcontext = &context.__mcontext_data;
},
else => {},
};
}
std.c reorganization It is now composed of these main sections: * Declarations that are shared among all operating systems. * Declarations that have the same name, but different type signatures depending on the operating system. Often multiple operating systems share the same type signatures however. * Declarations that are specific to a single operating system. - These are imported one per line so you can see where they come from, protected by a comptime block to prevent accessing the wrong one. Closes #19352 by changing the convention to making types `void` and functions `{}`, so that it becomes possible to update `@hasDecl` sites to use `@TypeOf(f) != void` or `T != void`. Happily, this ended up removing some duplicate logic and update some bitrotted feature detection checks. A handful of types have been modified to gain namespacing and type safety. This is a breaking change. Oh, and the last usage of `usingnamespace` site is eliminated.
2024-07-18 23:35:19 -07:00
pub const have_getcontext = @TypeOf(posix.system.getcontext) != void;
debug: add relocateContext dwarf: fixup tests that used a ThreadContext
2023-07-09 14:45:34 -04:00
/// Capture the current context. The register values in the context will reflect the
debug: fix initialization of the optional fields on StackIterator dwarf: documentation fixups target: enable unwind tables on macho
2023-07-10 18:43:19 -04:00
/// state after the platform `getcontext` function returns.
debug: add relocateContext dwarf: fixup tests that used a ThreadContext
2023-07-09 14:45:34 -04:00
///
/// 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;
}
extract std.posix from std.os closes #5019
2024-03-18 22:39:59 -07:00
const result = have_getcontext and posix.system.getcontext(context) == 0;
debug: fixup an inconsistency in the getcontext implementation on aarch64-macos
2023-07-12 21:45:26 -04:00
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;
}
debug: add relocateContext dwarf: fixup tests that used a ThreadContext
2023-07-09 14:45:34 -04:00
return result;
}
stack traces on segfault by default for linux-x86_64 closes #2355
2019-07-02 13:27:40 -04:00
/// Tries to print the stack trace starting from the supplied base pointer to stderr,
/// unbuffered, and ignores any error returned.
/// TODO multithreaded awareness
std.debug: reorg and clarify API goals After this commit: `std.debug.SelfInfo` is a cross-platform abstraction for the current executable's own debug information, with a goal of minimal code bloat and compilation speed penalty. `std.debug.Dwarf` does not assume the current executable is itself the thing being debugged, however, it does assume the debug info has the same CPU architecture and OS as the current executable. It is planned to remove this limitation.
2024-08-01 22:04:40 -07:00
pub fn dumpStackTraceFromBase(context: *ThreadContext) void {
zig fmt
2020-05-05 05:14:22 -06:00
nosuspend {
std.Target: Remove functions that just wrap component functions. Functions like isMinGW() and isGnuLibC() have a good reason to exist: They look at multiple components of the target. But functions like isWasm(), isDarwin(), isGnu(), etc only exist to save 4-8 characters. I don't think this is a good enough reason to keep them, especially given that: * It's not immediately obvious to a reader whether target.isDarwin() means the same thing as target.os.tag.isDarwin() precisely because isMinGW() and similar functions *do* look at multiple components. * It's not clear where we would draw the line. The logical conclusion before this commit would be to also wrap Arch.isX86(), Os.Tag.isSolarish(), Abi.isOpenHarmony(), etc... this obviously quickly gets out of hand. * It's nice to just have a single correct way of doing something.
2025-01-24 03:45:38 +01:00
if (builtin.target.cpu.arch.isWasm()) {
wasm: Fix unreachable paths When the last instruction is a debug instruction, the type of it is void. Similarly for 'noreturn' emit an 'unreachable' instruction to tell the wasm-validator the path cannot be reached. Also respect the '--strip' flag in the self-hosted wasm linker and not emit a 'name' section when the flag is set to `true`.
2022-04-17 19:41:05 +02:00
if (native_os == .wasi) {
const stderr = io.getStdErr().writer();
stderr.print("Unable to dump stack trace: not implemented for Wasm\n", .{}) catch return;
}
return;
}
std: remove std.debug.getStderrStream Rather than migrate to new 'writer' interface, just remove it
2020-06-15 23:51:25 +10:00
const stderr = io.getStdErr().writer();
std.event.Loop: promote the fs thread to be available for all OS's
2020-05-02 00:41:19 -04:00
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| {
std: Use {s} instead of {} when printing strings
2020-11-26 09:48:12 +01:00
stderr.print("Unable to dump stack trace: Unable to open debug info: {s}\n", .{@errorName(err)}) catch return;
std.event.Loop: promote the fs thread to be available for all OS's
2020-05-02 00:41:19 -04:00
return;
};
std: Move std.debug.{TTY.Config,detectTTYConfig} to std.io.tty Also get rid of the TTY wrapper struct, which was exlusively used as a namespace - this is done by the tty.zig root struct now. detectTTYConfig has been renamed to just detectConfig, which is enough given the new namespace. Additionally, a doc comment had been added.
2023-05-21 14:27:28 +01:00
const tty_config = io.tty.detectConfig(io.getStdErr());
debug: fix missing stack traces during crashes on windows - walk the stack via the method that is aware of unwind info (fixes x86_64 / aarch64 traces) - enhance the output for frames where the debug info isn't available by printing the module name
2023-04-18 00:01:41 -04:00
if (native_os == .windows) {
debug: x86 unwinding support, more unwinding fixes - Fix unwindFrame using the previous FDE row instead of the current one - Handle unwinding through noreturn functions - Add x86-linux getcontext - Fixup x86_64-linux getcontext not restoring the fp env - Fix start_addr filtering on x86-windows
2023-06-27 02:02:49 -04:00
// 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;
debug: fix missing stack traces during crashes on windows - walk the stack via the method that is aware of unwind info (fixes x86_64 / aarch64 traces) - enhance the output for frames where the debug info isn't available by printing the module name
2023-04-18 00:01:41 -04:00
return;
}
- rework StackIterator to optionally use debug_info to unwind the stack - add abi routines for getting register values - unwding is working!
2023-05-15 01:52:53 -04:00
var it = StackIterator.initWithContext(null, debug_info, context) catch return;
dwarf: add support for .eh_frame_hdr when unwinding - .eh_frame_hdr contains a binary-searchable data structure for finding an FDE. If present, we can use this section to avoid having to parse the entire FDE/CIE list in the binary, instead only entries that are actually required for unwinding are read. - rework the inputs pc-relative pointer decoding to support both already-mapped sections as well as sections mapped from a file - store the VirtualMachine on UnwindContext so the allocations can be reused
2023-05-29 01:26:30 -04:00
defer it.deinit();
debug: fix initialization of the optional fields on StackIterator dwarf: documentation fixups target: enable unwind tables on macho
2023-07-10 18:43:19 -04:00
printSourceAtAddress(debug_info, stderr, it.unwind_state.?.dwarf_context.pc, tty_config) catch return;
- rework StackIterator to optionally use debug_info to unwind the stack - add abi routines for getting register values - unwding is working!
2023-05-15 01:52:53 -04:00
std.event.Loop: promote the fs thread to be available for all OS's
2020-05-02 00:41:19 -04:00
while (it.next()) |return_address| {
debug: skip unwind error printing on platforms that don't have_ucontext
2023-07-26 22:10:22 -04:00
printLastUnwindError(&it, debug_info, stderr, tty_config);
debug: rework how unwind errors are printed, and add module name lookup for linux This change enhances stack trace output to include a note that debug info was missing, and therefore the stack trace may not be accurate. For example, if the user is using a libc compiled with -fomit-frame-pointer and doesn't have debug symbols installed, any traces that begin in a libc function may not unwind correctly. This allows the user to notice this and potentially install debug symbols to improve the output.
2023-07-02 18:15:36 -04:00
std: check for overflow in dumpStackTraceFromBase same change as [68e26a2ceea85a1] "std: check for overflow in writeCurrentStackTrace" On arm64 macOS, the address of the last frame is 0x0 rather than a positive value like 0x1 on x86_64 macOS, therefore, we overflow an integer trying to subtract 1 when printing the stack trace. This patch fixes it by first checking for this condition before trying to subtract 1. Same behaviour on i386-windows-msvc. Note that we do not need to signal the `SignalIterator` about this as it will correctly detect this condition on the subsequent iteration and return `null`, thus terminating the loop.
2022-10-15 16:58:29 +02:00
// 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.
all: rename i386 to x86
2022-10-07 21:24:44 +03:30
// same behaviour for x86-windows-msvc
std: check for overflow in dumpStackTraceFromBase same change as [68e26a2ceea85a1] "std: check for overflow in writeCurrentStackTrace" On arm64 macOS, the address of the last frame is 0x0 rather than a positive value like 0x1 on x86_64 macOS, therefore, we overflow an integer trying to subtract 1 when printing the stack trace. This patch fixes it by first checking for this condition before trying to subtract 1. Same behaviour on i386-windows-msvc. Note that we do not need to signal the `SignalIterator` about this as it will correctly detect this condition on the subsequent iteration and return `null`, thus terminating the loop.
2022-10-15 16:58:29 +02:00
const address = if (return_address == 0) return_address else return_address - 1;
printSourceAtAddress(debug_info, stderr, address, tty_config) catch return;
debug: skip unwind error printing on platforms that don't have_ucontext
2023-07-26 22:10:22 -04:00
} else printLastUnwindError(&it, debug_info, stderr, tty_config);
stack traces on segfault by default for linux-x86_64 closes #2355
2019-07-02 13:27:40 -04:00
}
}
introduce std.debug.captureStackTrace and fix the implementation of writeStackTrace it was printing the first frame in the wrong place
2019-02-23 13:19:06 -05:00
/// 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.
migrate from `std.Target.current` to `@import("builtin").target` closes #9388 closes #9321
2021-10-04 23:47:27 -07:00
pub fn captureStackTrace(first_address: ?usize, stack_trace: *std.builtin.StackTrace) void {
std: change `@import("builtin")` to `std.builtin`
2021-04-12 16:43:50 -07:00
if (native_os == .windows) {
clean up references to os
2019-05-26 13:17:34 -04:00
const addrs = stack_trace.instruction_addresses;
const first_addr = first_address orelse {
debug: x86 unwinding support, more unwinding fixes - Fix unwindFrame using the previous FDE row instead of the current one - Handle unwinding through noreturn functions - Add x86-linux getcontext - Fixup x86_64-linux getcontext not restoring the fp env - Fix start_addr filtering on x86-windows
2023-06-27 02:02:49 -04:00
stack_trace.index = walkStackWindows(addrs[0..], null);
clean up references to os
2019-05-26 13:17:34 -04:00
return;
};
var addr_buf_stack: [32]usize = undefined;
const addr_buf = if (addr_buf_stack.len > addrs.len) addr_buf_stack[0..] else addrs;
debug: x86 unwinding support, more unwinding fixes - Fix unwindFrame using the previous FDE row instead of the current one - Handle unwinding through noreturn functions - Add x86-linux getcontext - Fixup x86_64-linux getcontext not restoring the fp env - Fix start_addr filtering on x86-windows
2023-06-27 02:02:49 -04:00
const n = walkStackWindows(addr_buf[0..], null);
update std lib and compiler sources to new for loop syntax
2023-02-18 09:02:57 -07:00
const first_index = for (addr_buf[0..n], 0..) |addr, i| {
clean up references to os
2019-05-26 13:17:34 -04:00
if (addr == first_addr) {
break i;
}
} else {
stack_trace.index = 0;
return;
};
migration: std.math.{min, min3, max, max3} -> `@min` & `@max`
2023-06-02 22:02:45 -04:00
const end_index = @min(first_index + addrs.len, n);
Fix stack traces with non-null `first_address` on Windows Before this commit, the passed in length would always be given to the RtlCaptureStackBackTrace call. Now we always give the length of the actual buffer we're using (the addr_buf_stack size of 32 or the passed in length if it's larger than 32; this matches what the doc comment says the function was meant to be doing as well). This was causing empty stack traces for things like the GeneralPurposeAllocator leak checking. Fixes #6687
2022-06-17 22:05:41 -07:00
const slice = addr_buf[first_index..end_index];
clean up references to os
2019-05-26 13:17:34 -04:00
// We use a for loop here because slice and addrs may alias.
update std lib and compiler sources to new for loop syntax
2023-02-18 09:02:57 -07:00
for (slice, 0..) |addr, i| {
clean up references to os
2019-05-26 13:17:34 -04:00
addrs[i] = addr;
}
stack_trace.index = slice.len;
} else {
debug: rework how unwind errors are printed, and add module name lookup for linux This change enhances stack trace output to include a note that debug info was missing, and therefore the stack trace may not be accurate. For example, if the user is using a libc compiled with -fomit-frame-pointer and doesn't have debug symbols installed, any traces that begin in a libc function may not unwind correctly. This allows the user to notice this and potentially install debug symbols to improve the output.
2023-07-02 18:15:36 -04:00
// TODO: This should use the DWARF unwinder if .eh_frame_hdr is available (so that full debug info parsing isn't required).
std.debug: rename Info to SelfInfo This code has the hard-coded goal of supporting the executable's own debug information and makes design choices along that goal, such as memory-mapping the inputs, using dl_iterate_phdr, and doing conditional compilation on the host target. A more general-purpose implementation of debug information may be able to share code with this, but there are some fundamental incompatibilities. For example, the "SelfInfo" implementation wants to avoid bloating the binary with PDB on POSIX systems, and likewise DWARF on Windows systems, while a general-purpose implementation needs to support both PDB and DWARF from the same binary. It might, for example, inspect the debug information from a cross-compiled binary. `SourceLocation` now lives at `std.debug.SourceLocation` and is documented. Deprecate `std.debug.runtime_safety` because it returns the optimization mode of the standard library, when the caller probably wants to use the optimization mode of their own module. `std.pdb.Pdb` is moved to `std.debug.Pdb`, mirroring the recent extraction of `std.debug.Dwarf` from `std.dwarf`. I have no idea why we have both Module (with a Windows-specific definition) and WindowsModule. I left some passive aggressive doc comments to express my frustration.
2024-08-01 16:31:03 -07:00
// A new path for loading SelfInfo needs to be created which will only attempt to parse in-memory sections, because
debug: rework how unwind errors are printed, and add module name lookup for linux This change enhances stack trace output to include a note that debug info was missing, and therefore the stack trace may not be accurate. For example, if the user is using a libc compiled with -fomit-frame-pointer and doesn't have debug symbols installed, any traces that begin in a libc function may not unwind correctly. This allows the user to notice this and potentially install debug symbols to improve the output.
2023-07-02 18:15:36 -04:00
// stopping to load other debug info (ie. source line info) from disk here is not required for unwinding.
debug: Improve the frame-walking strategy Clean up the code a bit and introduce a few checks meant to avoid overshooting the end of the frame chain. The code is now stable enough not to cause panics during the call frame walking.
2020-02-05 23:40:36 +01:00
var it = StackIterator.init(first_address, null);
dwarf: add support for .eh_frame_hdr when unwinding - .eh_frame_hdr contains a binary-searchable data structure for finding an FDE. If present, we can use this section to avoid having to parse the entire FDE/CIE list in the binary, instead only entries that are actually required for unwinding are read. - rework the inputs pc-relative pointer decoding to support both already-mapped sections as well as sections mapped from a file - store the VirtualMachine on UnwindContext so the allocations can be reused
2023-05-29 01:26:30 -04:00
defer it.deinit();
update std lib and compiler sources to new for loop syntax
2023-02-18 09:02:57 -07:00
for (stack_trace.instruction_addresses, 0..) |*addr, i| {
clean up references to os
2019-05-26 13:17:34 -04:00
addr.* = it.next() orelse {
stack_trace.index = i;
introduce std.debug.captureStackTrace and fix the implementation of writeStackTrace it was printing the first frame in the wrong place
2019-02-23 13:19:06 -05:00
return;
};
clean up references to os
2019-05-26 13:17:34 -04:00
}
stack_trace.index = stack_trace.instruction_addresses.len;
introduce std.debug.captureStackTrace and fix the implementation of writeStackTrace it was printing the first frame in the wrong place
2019-02-23 13:19:06 -05:00
}
}
breaking change to std.io API * Merge io.InStream and io.OutStream into io.File * Introduce io.OutStream and io.InStream interfaces - io.File implements both of these * Move mem.IncrementingAllocator to heap.IncrementingAllocator Instead of: ``` %return std.io.stderr.printf("hello\n"); ``` now do: ``` std.debug.warn("hello\n"); ``` To print to stdout, see `io.getStdOut()`. * Rename std.ArrayList.resizeDown to std.ArrayList.shrink.
2017-10-31 04:47:55 -04:00
/// Tries to print a stack trace to stderr, unbuffered, and ignores any error returned.
macos stack traces: read debug info sections from .o files
2018-08-23 23:08:34 -04:00
/// TODO multithreaded awareness
migrate from `std.Target.current` to `@import("builtin").target` closes #9388 closes #9321
2021-10-04 23:47:27 -07:00
pub fn dumpStackTrace(stack_trace: std.builtin.StackTrace) void {
zig fmt
2020-05-05 05:14:22 -06:00
nosuspend {
std.Target: Remove functions that just wrap component functions. Functions like isMinGW() and isGnuLibC() have a good reason to exist: They look at multiple components of the target. But functions like isWasm(), isDarwin(), isGnu(), etc only exist to save 4-8 characters. I don't think this is a good enough reason to keep them, especially given that: * It's not immediately obvious to a reader whether target.isDarwin() means the same thing as target.os.tag.isDarwin() precisely because isMinGW() and similar functions *do* look at multiple components. * It's not clear where we would draw the line. The logical conclusion before this commit would be to also wrap Arch.isX86(), Os.Tag.isSolarish(), Abi.isOpenHarmony(), etc... this obviously quickly gets out of hand. * It's nice to just have a single correct way of doing something.
2025-01-24 03:45:38 +01:00
if (builtin.target.cpu.arch.isWasm()) {
wasm: Fix unreachable paths When the last instruction is a debug instruction, the type of it is void. Similarly for 'noreturn' emit an 'unreachable' instruction to tell the wasm-validator the path cannot be reached. Also respect the '--strip' flag in the self-hosted wasm linker and not emit a 'name' section when the flag is set to `true`.
2022-04-17 19:41:05 +02:00
if (native_os == .wasi) {
const stderr = io.getStdErr().writer();
stderr.print("Unable to dump stack trace: not implemented for Wasm\n", .{}) catch return;
}
return;
}
std: remove std.debug.getStderrStream Rather than migrate to new 'writer' interface, just remove it
2020-06-15 23:51:25 +10:00
const stderr = io.getStdErr().writer();
std.event.Loop: promote the fs thread to be available for all OS's
2020-05-02 00:41:19 -04:00
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| {
std: Use {s} instead of {} when printing strings
2020-11-26 09:48:12 +01:00
stderr.print("Unable to dump stack trace: Unable to open debug info: {s}\n", .{@errorName(err)}) catch return;
std.event.Loop: promote the fs thread to be available for all OS's
2020-05-02 00:41:19 -04:00
return;
};
std.debug: remove allocator from std.debug.writeStackTrace()
2024-08-22 17:10:32 -07:00
writeStackTrace(stack_trace, stderr, debug_info, io.tty.detectConfig(io.getStdErr())) catch |err| {
std: Use {s} instead of {} when printing strings
2020-11-26 09:48:12 +01:00
stderr.print("Unable to dump stack trace: {s}\n", .{@errorName(err)}) catch return;
std.event.Loop: promote the fs thread to be available for all OS's
2020-05-02 00:41:19 -04:00
return;
};
fix debug builds of WASI
2019-05-27 02:16:05 -04:00
}
breaking change to std.io API * Merge io.InStream and io.OutStream into io.File * Introduce io.OutStream and io.InStream interfaces - io.File implements both of these * Move mem.IncrementingAllocator to heap.IncrementingAllocator Instead of: ``` %return std.io.stderr.printf("hello\n"); ``` now do: ``` std.debug.warn("hello\n"); ``` To print to stdout, see `io.getStdOut()`. * Rename std.ArrayList.resizeDown to std.ArrayList.shrink.
2017-10-31 04:47:55 -04:00
}
add std.debug.assertReadable Useful when trying to figure out whether a slice is valid memory.
2024-07-03 13:28:21 -07:00
/// Invokes detectable illegal behavior when `ok` is `false`.
///
breaking change to std.io API * Merge io.InStream and io.OutStream into io.File * Introduce io.OutStream and io.InStream interfaces - io.File implements both of these * Move mem.IncrementingAllocator to heap.IncrementingAllocator Instead of: ``` %return std.io.stderr.printf("hello\n"); ``` now do: ``` std.debug.warn("hello\n"); ``` To print to stdout, see `io.getStdOut()`. * Rename std.ArrayList.resizeDown to std.ArrayList.shrink.
2017-10-31 04:47:55 -04:00
/// In Debug and ReleaseSafe modes, calls to this function are always
/// generated, and the `unreachable` statement triggers a panic.
add std.debug.assertReadable Useful when trying to figure out whether a slice is valid memory.
2024-07-03 13:28:21 -07:00
///
/// 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
std.debug.assert: remove special case for test builds Previously, std.debug.assert would `@panic` in test builds, if the assertion failed. Now, it's always `unreachable`. This makes release mode test builds more accurately test the actual code that will be run. However this requires tests to call `std.testing.expect` rather than `std.debug.assert` to make sure output is correct. Here is the explanation of when to use either one, copied from the assert doc comments: Inside a test block, it is best to use the `std.testing` module rather than assert, because assert may not detect a test failure in ReleaseFast and ReleaseSafe mode. Outside of a test block, assert is the correct function to use. closes #1304
2019-02-08 18:18:47 -05:00
/// function is the correct function to use.
syntax: functions require return type. remove `->` The purpose of this is: * Only one way to do things * Changing a function with void return type to return a possible error becomes a 1 character change, subtly encouraging people to use errors. See #632 Here are some imperfect sed commands for performing this update: remove arrow: ``` sed -i 's/\(\bfn\b.*\)-> /\1/g' $(find . -name "*.zig") ``` add void: ``` sed -i 's/\(\bfn\b.*\))\s*{/\1) void {/g' $(find ../ -name "*.zig") ``` Some cleanup may be necessary, but this should do the bulk of the work.
2018-01-25 04:10:11 -05:00
pub fn assert(ok: bool) void {
std.debug.assert: remove special case for test builds Previously, std.debug.assert would `@panic` in test builds, if the assertion failed. Now, it's always `unreachable`. This makes release mode test builds more accurately test the actual code that will be run. However this requires tests to call `std.testing.expect` rather than `std.debug.assert` to make sure output is correct. Here is the explanation of when to use either one, copied from the assert doc comments: Inside a test block, it is best to use the `std.testing` module rather than assert, because assert may not detect a test failure in ReleaseFast and ReleaseSafe mode. Outside of a test block, assert is the correct function to use. closes #1304
2019-02-08 18:18:47 -05:00
if (!ok) unreachable; // assertion failure
breaking change to std.io API * Merge io.InStream and io.OutStream into io.File * Introduce io.OutStream and io.InStream interfaces - io.File implements both of these * Move mem.IncrementingAllocator to heap.IncrementingAllocator Instead of: ``` %return std.io.stderr.printf("hello\n"); ``` now do: ``` std.debug.warn("hello\n"); ``` To print to stdout, see `io.getStdOut()`. * Rename std.ArrayList.resizeDown to std.ArrayList.shrink.
2017-10-31 04:47:55 -04:00
}
add std.debug.assertReadable Useful when trying to figure out whether a slice is valid memory.
2024-07-03 13:28:21 -07:00
/// 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.*;
}
remove formatted panics implements #17969
2024-09-25 11:11:48 -07:00
/// Equivalent to `@panic` but with a formatted message.
run zig fmt on std lib and self hosted
2020-07-11 14:09:04 +03:00
pub fn panic(comptime format: []const u8, args: anytype) noreturn {
compiler,lib,test,langref: migrate `@setCold` to `@branchHint`
2024-08-24 16:16:53 +01:00
@branchHint(.cold);
all: update for `panic.unwrapError` and `panic.call` signature changes
2025-01-24 04:20:55 +00:00
panicExtra(@returnAddress(), format, args);
improve panic hierarchy by always using builtin.panic
2021-06-26 11:28:03 -05:00
}
remove formatted panics implements #17969
2024-09-25 11:11:48 -07:00
/// Equivalent to `@panic` but with a formatted message, and with an explicitly
all: update for `panic.unwrapError` and `panic.call` signature changes
2025-01-24 04:20:55 +00:00
/// provided return address.
improve panic hierarchy by always using builtin.panic
2021-06-26 11:28:03 -05:00
pub fn panicExtra(
std: add return address parameter to panic fn
2022-09-15 00:43:48 +03:00
ret_addr: ?usize,
improve panic hierarchy by always using builtin.panic
2021-06-26 11:28:03 -05:00
comptime format: []const u8,
args: anytype,
) noreturn {
compiler,lib,test,langref: migrate `@setCold` to `@branchHint`
2024-08-24 16:16:53 +01:00
@branchHint(.cold);
improve panic hierarchy by always using builtin.panic
2021-06-26 11:28:03 -05:00
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) {
std: update to use `@memcpy` directly
2023-04-27 15:16:01 -07:00
error.NoSpaceLeft => blk: {
@memcpy(buf[size..], trunc_msg);
improve panic hierarchy by always using builtin.panic
2021-06-26 11:28:03 -05:00
break :blk &buf;
},
};
all: update for `panic.unwrapError` and `panic.call` signature changes
2025-01-24 04:20:55 +00:00
std.builtin.panic.call(msg, ret_addr);
refactor stack trace code to remove global state
2018-03-09 22:21:13 -05:00
}
std: Multithreaded-aware panic handler Gracefully handle the case of several threads panicking at the same time.
2020-03-13 17:55:40 +01:00
/// Non-zero whenever the program triggered a panic.
/// The counter is incremented/decremented atomically.
rework std.atomic * move std.atomic.Atomic to std.atomic.Value * fix incorrect argument order passed to testing.expectEqual * make the functions be a thin wrapper over the atomic builtins and stick to the naming conventions. * remove pointless functions loadUnchecked and storeUnchecked. Instead, name the field `raw` instead of `value` (which is redundant with the type name). * simplify the tests by not passing every possible combination. Many cases were iterating over every possible combinations but then not even using the for loop element value! * remove the redundant compile errors which are already implemented by the language itself. * remove dead x86 inline assembly. this should be implemented in the language if at all.
2023-11-22 18:49:18 -07:00
var panicking = std.atomic.Value(u8).init(0);
refactor stack trace code to remove global state
2018-03-09 22:21:13 -05:00
std: Multithreaded-aware panic handler Gracefully handle the case of several threads panicking at the same time.
2020-03-13 17:55:40 +01:00
/// 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;
embrace panic helpers Introduces `std.builtin.Panic` which is a complete interface for panicking. Provide `std.debug.FormattedPanic` and `std.debug.SimplePanic` and let the user choose, or make their own.
2024-09-26 14:24:18 -07:00
/// Dumps a stack trace to standard error, then aborts.
remove formatted panics implements #17969
2024-09-25 11:11:48 -07:00
pub fn defaultPanic(
embrace panic helpers Introduces `std.builtin.Panic` which is a complete interface for panicking. Provide `std.debug.FormattedPanic` and `std.debug.SimplePanic` and let the user choose, or make their own.
2024-09-26 14:24:18 -07:00
msg: []const u8,
remove formatted panics implements #17969
2024-09-25 11:11:48 -07:00
first_trace_addr: ?usize,
) noreturn {
compiler,lib,test,langref: migrate `@setCold` to `@branchHint`
2024-08-24 16:16:53 +01:00
@branchHint(.cold);
progress toward windows hello world working
2017-06-14 00:04:34 -04:00
remove formatted panics implements #17969
2024-09-25 11:11:48 -07:00
// 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) {
defaultPanic: @trap on 'other' target The freestanding and other OS targets by default need to just @trap in the default Panic implementation. And `isValidMemory` won't work with freestanding or other targets. Update the unwind_freestanding.zig test case to also run on the 'other' OS target, too. This should keep the Zig's stacktrace generation from regressing on the standalone targets.
2024-07-28 13:14:45 -07:00
.freestanding, .other => {
remove formatted panics implements #17969
2024-09-25 11:11:48 -07:00
@trap();
},
.uefi => {
const uefi = std.os.uefi;
var utf16_buffer: [1000]u16 = undefined;
embrace panic helpers Introduces `std.builtin.Panic` which is a complete interface for panicking. Provide `std.debug.FormattedPanic` and `std.debug.SimplePanic` and let the user choose, or make their own.
2024-09-26 14:24:18 -07:00
const len_minus_3 = std.unicode.utf8ToUtf16Le(&utf16_buffer, msg) catch 0;
std.debug: Fix defaultPanic() uefi build lib/std/debug.zig:491:38: error: slice of non-array type 'u16' utf16_buffer[len_minus_3][0..3].* = .{ '\r', '\n', 0 }; ~~~~~~~~~~~~~~~~~~~~~~~~~^~~~~~ lib/std/debug.zig:510:70: error: expected type '?*const anyopaque', found '[]u16' _ = bs.exit(uefi.handle, .Aborted, exit_msg.len + 1, exit_data); ^~~~~~~~~ Regressed in #21520.
2024-10-07 01:33:42 +09:00
utf16_buffer[len_minus_3..][0..3].* = .{ '\r', '\n', 0 };
embrace panic helpers Introduces `std.builtin.Panic` which is a complete interface for panicking. Provide `std.debug.FormattedPanic` and `std.debug.SimplePanic` and let the user choose, or make their own.
2024-09-26 14:24:18 -07:00
const len = len_minus_3 + 3;
remove formatted panics implements #17969
2024-09-25 11:11:48 -07:00
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| {
std.os.uefi.protocol: ziggify function signatures (#23214)
2025-04-01 03:47:51 -07:00
out.setAttribute(.{ .foreground = .red }) catch {};
_ = out.outputString(exit_msg) catch {};
out.setAttribute(.{ .foreground = .white }) catch {};
remove formatted panics implements #17969
2024-09-25 11:11:48 -07:00
}
}
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.
std.os.uefi: Adjust casing of remaining enum fields Work towards #2101.
2025-02-08 21:47:34 +00:00
_ = bs.exit(uefi.handle, .aborted, exit_data.len, exit_data.ptr);
remove formatted panics implements #17969
2024-09-25 11:11:48 -07:00
}
@trap();
},
.cuda, .amdhsa => std.posix.abort(),
.plan9 => {
embrace panic helpers Introduces `std.builtin.Panic` which is a complete interface for panicking. Provide `std.debug.FormattedPanic` and `std.debug.SimplePanic` and let the user choose, or make their own.
2024-09-26 14:24:18 -07:00
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]);
remove formatted panics implements #17969
2024-09-25 11:11:48 -07:00
},
else => {},
}
disable segfault handler when panicking this prevents a segfault in stack trace printing to activate the segfault handler.
2019-07-22 12:15:16 -04:00
if (enable_segfault_handler) {
// If a segfault happens while panicking, we want it to actually segfault, not trigger
// the handler.
resetSegfaultHandler();
}
std.debug: fix segfault/panic race condition closes #7859 closes #12207
2023-04-08 08:36:31 -07:00
// Note there is similar logic in handleSegfaultPosix and handleSegfaultWindowsExtra.
zig fmt
2020-05-05 05:14:22 -06:00
nosuspend switch (panic_stage) {
Correctly count all the loaded modules on Windows
2020-02-18 19:03:31 +01:00
0 => {
std: Multithreaded-aware panic handler Gracefully handle the case of several threads panicking at the same time.
2020-03-13 17:55:40 +01:00
panic_stage = 1;
std.builtin: make atomic order fields lowercase
2024-02-18 21:52:23 -08:00
_ = panicking.fetchAdd(1, .seq_cst);
std: Multithreaded-aware panic handler Gracefully handle the case of several threads panicking at the same time.
2020-03-13 17:55:40 +01:00
{
embrace panic helpers Introduces `std.builtin.Panic` which is a complete interface for panicking. Provide `std.debug.FormattedPanic` and `std.debug.SimplePanic` and let the user choose, or make their own.
2024-09-26 14:24:18 -07:00
lockStdErr();
defer unlockStdErr();
const stderr = io.getStdErr().writer();
std: Show the panicking thread ID Annotate the panic message with the thread ID to know who's the culprit.
2020-10-29 20:51:37 +01:00
if (builtin.single_threaded) {
embrace panic helpers Introduces `std.builtin.Panic` which is a complete interface for panicking. Provide `std.debug.FormattedPanic` and `std.debug.SimplePanic` and let the user choose, or make their own.
2024-09-26 14:24:18 -07:00
stderr.print("panic: ", .{}) catch posix.abort();
std: Show the panicking thread ID Annotate the panic message with the thread ID to know who's the culprit.
2020-10-29 20:51:37 +01:00
} else {
embrace panic helpers Introduces `std.builtin.Panic` which is a complete interface for panicking. Provide `std.debug.FormattedPanic` and `std.debug.SimplePanic` and let the user choose, or make their own.
2024-09-26 14:24:18 -07:00
const current_thread_id = std.Thread.getCurrentId();
stderr.print("thread {} panic: ", .{current_thread_id}) catch posix.abort();
std: Multithreaded-aware panic handler Gracefully handle the case of several threads panicking at the same time.
2020-03-13 17:55:40 +01:00
}
embrace panic helpers Introduces `std.builtin.Panic` which is a complete interface for panicking. Provide `std.debug.FormattedPanic` and `std.debug.SimplePanic` and let the user choose, or make their own.
2024-09-26 14:24:18 -07:00
stderr.print("{s}\n", .{msg}) catch posix.abort();
remove formatted panics implements #17969
2024-09-25 11:11:48 -07:00
all: update for `panic.unwrapError` and `panic.call` signature changes
2025-01-24 04:20:55 +00:00
if (@errorReturnTrace()) |t| dumpStackTrace(t.*);
remove formatted panics implements #17969
2024-09-25 11:11:48 -07:00
dumpCurrentStackTrace(first_trace_addr orelse @returnAddress());
std: Multithreaded-aware panic handler Gracefully handle the case of several threads panicking at the same time.
2020-03-13 17:55:40 +01:00
}
std.debug: fix segfault/panic race condition closes #7859 closes #12207
2023-04-08 08:36:31 -07:00
waitForOtherThreadToFinishPanicking();
sentinel slicing improvements * add runtime safety for slicing pointers, arrays, and slices. * slicing without a sentinel value results in non-sentineled slice * improved `std.debug.panic` handling of panic-during-panic
2019-12-20 17:48:45 -05:00
},
Correctly count all the loaded modules on Windows
2020-02-18 19:03:31 +01:00
1 => {
std: Multithreaded-aware panic handler Gracefully handle the case of several threads panicking at the same time.
2020-03-13 17:55:40 +01:00
panic_stage = 2;
remove formatted panics implements #17969
2024-09-25 11:11:48 -07:00
// 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 {};
sentinel slicing improvements * add runtime safety for slicing pointers, arrays, and slices. * slicing without a sentinel value results in non-sentineled slice * improved `std.debug.panic` handling of panic-during-panic
2019-12-20 17:48:45 -05:00
},
remove formatted panics implements #17969
2024-09-25 11:11:48 -07:00
else => {}, // Panicked while printing the recursive panic message.
std.event.Loop: promote the fs thread to be available for all OS's
2020-05-02 00:41:19 -04:00
};
std: Multithreaded-aware panic handler Gracefully handle the case of several threads panicking at the same time.
2020-03-13 17:55:40 +01:00
extract std.posix from std.os closes #5019
2024-03-18 22:39:59 -07:00
posix.abort();
fix getting debug info twice in default panic handler
2018-01-15 16:26:13 -05:00
}
std.debug: fix segfault/panic race condition closes #7859 closes #12207
2023-04-08 08:36:31 -07:00
/// Must be called only after adding 1 to `panicking`. There are three callsites.
fn waitForOtherThreadToFinishPanicking() void {
std.builtin: make atomic order fields lowercase
2024-02-18 21:52:23 -08:00
if (panicking.fetchSub(1, .seq_cst) != 1) {
std.debug: fix segfault/panic race condition closes #7859 closes #12207
2023-04-08 08:36:31 -07:00
// 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
rework std.atomic * move std.atomic.Atomic to std.atomic.Value * fix incorrect argument order passed to testing.expectEqual * make the functions be a thin wrapper over the atomic builtins and stick to the naming conventions. * remove pointless functions loadUnchecked and storeUnchecked. Instead, name the field `raw` instead of `value` (which is redundant with the type name). * simplify the tests by not passing every possible combination. Many cases were iterating over every possible combinations but then not even using the for loop element value! * remove the redundant compile errors which are already implemented by the language itself. * remove dead x86 inline assembly. this should be implemented in the language if at all.
2023-11-22 18:49:18 -07:00
var futex = std.atomic.Value(u32).init(0);
std.debug: fix segfault/panic race condition closes #7859 closes #12207
2023-04-08 08:36:31 -07:00
while (true) std.Thread.Futex.wait(&futex, 0);
unreachable;
}
}
introduce std.debug.captureStackTrace and fix the implementation of writeStackTrace it was printing the first frame in the wrong place
2019-02-23 13:19:06 -05:00
pub fn writeStackTrace(
migrate from `std.Target.current` to `@import("builtin").target` closes #9388 closes #9321
2021-10-04 23:47:27 -07:00
stack_trace: std.builtin.StackTrace,
run zig fmt on std lib and self hosted
2020-07-11 14:09:04 +03:00
out_stream: anytype,
std.debug: rename Info to SelfInfo This code has the hard-coded goal of supporting the executable's own debug information and makes design choices along that goal, such as memory-mapping the inputs, using dl_iterate_phdr, and doing conditional compilation on the host target. A more general-purpose implementation of debug information may be able to share code with this, but there are some fundamental incompatibilities. For example, the "SelfInfo" implementation wants to avoid bloating the binary with PDB on POSIX systems, and likewise DWARF on Windows systems, while a general-purpose implementation needs to support both PDB and DWARF from the same binary. It might, for example, inspect the debug information from a cross-compiled binary. `SourceLocation` now lives at `std.debug.SourceLocation` and is documented. Deprecate `std.debug.runtime_safety` because it returns the optimization mode of the standard library, when the caller probably wants to use the optimization mode of their own module. `std.pdb.Pdb` is moved to `std.debug.Pdb`, mirroring the recent extraction of `std.debug.Dwarf` from `std.dwarf`. I have no idea why we have both Module (with a Windows-specific definition) and WindowsModule. I left some passive aggressive doc comments to express my frustration.
2024-08-01 16:31:03 -07:00
debug_info: *SelfInfo,
std: Move std.debug.{TTY.Config,detectTTYConfig} to std.io.tty Also get rid of the TTY wrapper struct, which was exlusively used as a namespace - this is done by the tty.zig root struct now. detectTTYConfig has been renamed to just detectConfig, which is enough given the new namespace. Additionally, a doc comment had been added.
2023-05-21 14:27:28 +01:00
tty_config: io.tty.Config,
introduce std.debug.captureStackTrace and fix the implementation of writeStackTrace it was printing the first frame in the wrong place
2019-02-23 13:19:06 -05:00
) !void {
standard library integrates with knowledge of stripped debug info
2019-06-14 18:45:41 -04:00
if (builtin.strip_debug_info) return error.MissingDebugInfo;
introduce std.debug.captureStackTrace and fix the implementation of writeStackTrace it was printing the first frame in the wrong place
2019-02-23 13:19:06 -05:00
var frame_index: usize = 0;
migration: std.math.{min, min3, max, max3} -> `@min` & `@max`
2023-06-02 22:02:45 -04:00
var frames_left: usize = @min(stack_trace.index, stack_trace.instruction_addresses.len);
*WIP* proof of concept error return traces
2018-01-12 02:12:11 -05:00
fix duplicate stack trace code
2018-01-14 10:19:21 -05:00
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];
fix debug info code not being freestanding compatible in stack tracing code, the idea was to detect the tty settings at the top of the stack and pass the information down. somewhere along the way this got changed so that setTtyColor was assuming the global stderr_file was related to the output stream the stack trace was being printed to. now, tty_color is changed to tty_config, and it is an enum rather than a bool, telling how tty colors are expected to be handled. windows is still incorrectly looking at stderr_file.
2020-01-26 09:55:04 -05:00
try printSourceAtAddress(debug_info, out_stream, return_address - 1, tty_config);
fix duplicate stack trace code
2018-01-14 10:19:21 -05:00
}
builtin.zig: Do not overwrite error frames when trace full Previously, we'd overwrite the errors in a circular buffer. Now that error return traces are intended to follow a stack discipline, we no longer have to support the index rolling over. By treating the trace like a saturating stack, any pop/restore code still behaves correctly past-the-end of the trace. As a bonus, this adds a small blurb to let the user know when the trace saturated and x number of frames were dropped.
2022-09-25 20:18:15 -07:00
if (stack_trace.index > stack_trace.instruction_addresses.len) {
const dropped_frames = stack_trace.index - stack_trace.instruction_addresses.len;
std.debug: Rename TTY.Color enum values to snake case
2023-05-20 22:30:02 +01:00
tty_config.setColor(out_stream, .bold) catch {};
builtin.zig: Do not overwrite error frames when trace full Previously, we'd overwrite the errors in a circular buffer. Now that error return traces are intended to follow a stack discipline, we no longer have to support the index rolling over. By treating the trace like a saturating stack, any pop/restore code still behaves correctly past-the-end of the trace. As a bonus, this adds a small blurb to let the user know when the trace saturated and x number of frames were dropped.
2022-09-25 20:18:15 -07:00
try out_stream.print("({d} additional stack frames skipped...)\n", .{dropped_frames});
std.debug: Rename TTY.Color enum values to snake case
2023-05-20 22:30:02 +01:00
tty_config.setColor(out_stream, .reset) catch {};
builtin.zig: Do not overwrite error frames when trace full Previously, we'd overwrite the errors in a circular buffer. Now that error return traces are intended to follow a stack discipline, we no longer have to support the index rolling over. By treating the trace like a saturating stack, any pop/restore code still behaves correctly past-the-end of the trace. As a bonus, this adds a small blurb to let the user know when the trace saturated and x number of frames were dropped.
2022-09-25 20:18:15 -07:00
}
fix duplicate stack trace code
2018-01-14 10:19:21 -05:00
}
*WIP* proof of concept error return traces
2018-01-12 02:12:11 -05:00
debug: rework how unwind errors are printed, and add module name lookup for linux This change enhances stack trace output to include a note that debug info was missing, and therefore the stack trace may not be accurate. For example, if the user is using a libc compiled with -fomit-frame-pointer and doesn't have debug symbols installed, any traces that begin in a libc function may not unwind correctly. This allows the user to notice this and potentially install debug symbols to improve the output.
2023-07-02 18:15:36 -04:00
pub const UnwindError = if (have_ucontext)
std: update `std.builtin.Type` fields to follow naming conventions The compiler actually doesn't need any functional changes for this: Sema does reification based on the tag indices of `std.builtin.Type` already! So, no zig1.wasm update is necessary. This change is necessary to disallow name clashes between fields and decls on a type, which is a prerequisite of #9938.
2024-08-28 02:35:53 +01:00
@typeInfo(@typeInfo(@TypeOf(StackIterator.next_unwind)).@"fn".return_type.?).error_union.error_set
debug: rework how unwind errors are printed, and add module name lookup for linux This change enhances stack trace output to include a note that debug info was missing, and therefore the stack trace may not be accurate. For example, if the user is using a libc compiled with -fomit-frame-pointer and doesn't have debug symbols installed, any traces that begin in a libc function may not unwind correctly. This allows the user to notice this and potentially install debug symbols to improve the output.
2023-07-02 18:15:36 -04:00
else
void;
std.debug.StackIterator
2018-12-02 18:54:04 -05:00
pub const StackIterator = struct {
std: Minor changes to startup code * Smaller startup sequence for ppc64 * Terminate the frame-pointer chain when executing _start * Make the stack traces work on ppc64 * Make the stack traces coloured on ppc64, some ioctls numbers are different and the whole set of constants should be audited.
2020-10-19 11:40:46 +02:00
// Skip every frame before this address is found.
debug: Improve the frame-walking strategy Clean up the code a bit and introduce a few checks meant to avoid overshooting the end of the frame chain. The code is now stable enough not to cause panics during the call frame walking.
2020-02-05 23:40:36 +01:00
first_address: ?usize,
std: Minor changes to startup code * Smaller startup sequence for ppc64 * Terminate the frame-pointer chain when executing _start * Make the stack traces work on ppc64 * Make the stack traces coloured on ppc64, some ioctls numbers are different and the whole set of constants should be audited.
2020-10-19 11:40:46 +02:00
// Last known value of the frame pointer register.
std.debug.StackIterator
2018-12-02 18:54:04 -05:00
fp: usize,
debug: prevent segfaults on linux
2024-07-09 12:51:48 -04:00
ma: MemoryAccessor = MemoryAccessor.init,
std.debug.StackIterator
2018-12-02 18:54:04 -05:00
std.debug: rename Info to SelfInfo This code has the hard-coded goal of supporting the executable's own debug information and makes design choices along that goal, such as memory-mapping the inputs, using dl_iterate_phdr, and doing conditional compilation on the host target. A more general-purpose implementation of debug information may be able to share code with this, but there are some fundamental incompatibilities. For example, the "SelfInfo" implementation wants to avoid bloating the binary with PDB on POSIX systems, and likewise DWARF on Windows systems, while a general-purpose implementation needs to support both PDB and DWARF from the same binary. It might, for example, inspect the debug information from a cross-compiled binary. `SourceLocation` now lives at `std.debug.SourceLocation` and is documented. Deprecate `std.debug.runtime_safety` because it returns the optimization mode of the standard library, when the caller probably wants to use the optimization mode of their own module. `std.pdb.Pdb` is moved to `std.debug.Pdb`, mirroring the recent extraction of `std.debug.Dwarf` from `std.dwarf`. I have no idea why we have both Module (with a Windows-specific definition) and WindowsModule. I left some passive aggressive doc comments to express my frustration.
2024-08-01 16:31:03 -07:00
// When SelfInfo and a register context is available, this iterator can unwind
debug: fix initialization of the optional fields on StackIterator dwarf: documentation fixups target: enable unwind tables on macho
2023-07-10 18:43:19 -04:00
// 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 {
std.debug: rename Info to SelfInfo This code has the hard-coded goal of supporting the executable's own debug information and makes design choices along that goal, such as memory-mapping the inputs, using dl_iterate_phdr, and doing conditional compilation on the host target. A more general-purpose implementation of debug information may be able to share code with this, but there are some fundamental incompatibilities. For example, the "SelfInfo" implementation wants to avoid bloating the binary with PDB on POSIX systems, and likewise DWARF on Windows systems, while a general-purpose implementation needs to support both PDB and DWARF from the same binary. It might, for example, inspect the debug information from a cross-compiled binary. `SourceLocation` now lives at `std.debug.SourceLocation` and is documented. Deprecate `std.debug.runtime_safety` because it returns the optimization mode of the standard library, when the caller probably wants to use the optimization mode of their own module. `std.pdb.Pdb` is moved to `std.debug.Pdb`, mirroring the recent extraction of `std.debug.Dwarf` from `std.dwarf`. I have no idea why we have both Module (with a Windows-specific definition) and WindowsModule. I left some passive aggressive doc comments to express my frustration.
2024-08-01 16:31:03 -07:00
debug_info: *SelfInfo,
std.debug: reorg and clarify API goals After this commit: `std.debug.SelfInfo` is a cross-platform abstraction for the current executable's own debug information, with a goal of minimal code bloat and compilation speed penalty. `std.debug.Dwarf` does not assume the current executable is itself the thing being debugged, however, it does assume the debug info has the same CPU architecture and OS as the current executable. It is planned to remove this limitation.
2024-08-01 22:04:40 -07:00
dwarf_context: SelfInfo.UnwindContext,
debug: fix initialization of the optional fields on StackIterator dwarf: documentation fixups target: enable unwind tables on macho
2023-07-10 18:43:19 -04:00
last_error: ?UnwindError = null,
debug: fixup last_error being printed too many times
2023-07-10 20:18:58 -04:00
failed: bool = false,
debug: fix initialization of the optional fields on StackIterator dwarf: documentation fixups target: enable unwind tables on macho
2023-07-10 18:43:19 -04:00
} else void = if (have_ucontext) null else {},
- rework StackIterator to optionally use debug_info to unwind the stack - add abi routines for getting register values - unwding is working!
2023-05-15 01:52:53 -04:00
debug: Improve the frame-walking strategy Clean up the code a bit and introduce a few checks meant to avoid overshooting the end of the frame chain. The code is now stable enough not to cause panics during the call frame walking.
2020-02-05 23:40:36 +01:00
pub fn init(first_address: ?usize, fp: ?usize) StackIterator {
std.debug: Support sparc32 in StackIterator.init().
2024-08-12 03:51:48 +02:00
if (native_arch.isSPARC()) {
std: Fix backtraces on sparcv9 Flush all the register windows to stack before starting the stack walk, we may otherwise try to read garbage and crash and burn. Add a few comptime annotations to debloat some functions.
2021-04-25 19:10:11 +02:00
// Flush all the register windows on stack.
std.debug: Support sparc32 in StackIterator.init().
2024-08-12 03:51:48 +02:00
asm volatile (if (std.Target.sparc.featureSetHas(builtin.cpu.features, .v9))
"flushw"
else
"ta 3" // ST_FLUSH_WINDOWS
std: Fix backtraces on sparcv9 Flush all the register windows to stack before starting the stack walk, we may otherwise try to read garbage and crash and burn. Add a few comptime annotations to debloat some functions.
2021-04-25 19:10:11 +02:00
::: "memory");
}
std.debug.StackIterator
2018-12-02 18:54:04 -05:00
return StackIterator{
debug: Improve the frame-walking strategy Clean up the code a bit and introduce a few checks meant to avoid overshooting the end of the frame chain. The code is now stable enough not to cause panics during the call frame walking.
2020-02-05 23:40:36 +01:00
.first_address = first_address,
compiler: preserve result type information through address-of operator This commit introduces the new `ref_coerced_ty` result type into AstGen. This represents a expression which we want to treat as an lvalue, and the pointer will be coerced to a given type. This change gives known result types to many expressions, in particular struct and array initializations. This allows certain casts to work which previously required explicitly specifying types via `@as`. It also eliminates our dependence on anonymous struct types for expressions of the form `&.{ ... }` - this paves the way for #16865, and also results in less Sema magic happening for such initializations, also leading to potentially better runtime code. As part of these changes, this commit also implements #17194 by disallowing RLS on explicitly-typed struct and array initializations. Apologies for linking these changes - it seemed rather pointless to try and separate them, since they both make big changes to struct and array initializations in AstGen. The rationale for this change can be found in the proposal - in essence, performing RLS whilst maintaining the semantics of the intermediary type is a very difficult problem to solve. This allowed the problematic `coerce_result_ptr` ZIR instruction to be completely eliminated, which in turn also simplified the logic for inferred allocations in Sema - thanks to this, we almost break even on line count! In doing this, the ZIR instructions surrounding these initializations have been restructured - some have been added and removed, and others renamed for clarity (and their semantics changed slightly). In order to optimize ZIR tag count, the `struct_init_anon_ref` and `array_init_anon_ref` instructions have been removed in favour of using `ref` on a standard anonymous value initialization, since these instructions are now virtually never used. Lastly, it's worth noting that this commit introduces a slightly strange source of generic poison types: in the expression `@as(*anyopaque, &x)`, the sub-expression `x` has a generic poison result type, despite no generic code being involved. This turns out to be a logical choice, because we don't know the result type for `x`, and the generic poison type represents precisely this case, providing the semantics we need. Resolves: #16512 Resolves: #17194
2023-09-18 14:49:18 +01:00
// TODO: this is a workaround for #16876
//.fp = fp orelse @frameAddress(),
.fp = fp orelse blk: {
const fa = @frameAddress();
break :blk fa;
},
std.debug.StackIterator
2018-12-02 18:54:04 -05:00
};
fix cancel and await semantics
2018-07-29 23:25:40 -04:00
}
std.debug.StackIterator
2018-12-02 18:54:04 -05:00
std.debug: reorg and clarify API goals After this commit: `std.debug.SelfInfo` is a cross-platform abstraction for the current executable's own debug information, with a goal of minimal code bloat and compilation speed penalty. `std.debug.Dwarf` does not assume the current executable is itself the thing being debugged, however, it does assume the debug info has the same CPU architecture and OS as the current executable. It is planned to remove this limitation.
2024-08-01 22:04:40 -07:00
pub fn initWithContext(first_address: ?usize, debug_info: *SelfInfo, context: *posix.ucontext_t) !StackIterator {
debug: disable the new unwinder on aarch64-macos
2023-07-18 22:51:52 -04:00
// 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.
std.Target: Remove functions that just wrap component functions. Functions like isMinGW() and isGnuLibC() have a good reason to exist: They look at multiple components of the target. But functions like isWasm(), isDarwin(), isGnu(), etc only exist to save 4-8 characters. I don't think this is a good enough reason to keep them, especially given that: * It's not immediately obvious to a reader whether target.isDarwin() means the same thing as target.os.tag.isDarwin() precisely because isMinGW() and similar functions *do* look at multiple components. * It's not clear where we would draw the line. The logical conclusion before this commit would be to also wrap Arch.isX86(), Os.Tag.isSolarish(), Abi.isOpenHarmony(), etc... this obviously quickly gets out of hand. * It's nice to just have a single correct way of doing something.
2025-01-24 03:45:38 +01:00
if (builtin.target.os.tag.isDarwin() and native_arch == .aarch64)
std.debug: watchOS: fixes for ilp32 ABI (#21765) Xcode requires target arm64_32 (aarch64-watchos-ilp32) in order to build code for Apple Watches. This commit fixes compilation errors that appear when compiling with that target.
2024-10-29 22:12:57 +01:00
return init(first_address, @truncate(context.mcontext.ss.fp));
fix compilation on powerpc GNU systems ...which have a ucontext_t but not a PC register. The current stack unwinding implementation does not yet support this architecture. Also fix name of `std.debug.SelfInfo.openSelf` to remove redundancy. Also removed this hook into root providing an "openSelfDebugInfo" function. Sorry, this debugging code is not of sufficient quality to offer a plugin API right now.
2024-08-02 12:00:08 -07:00
if (SelfInfo.supports_unwinding) {
debug: disable the new unwinder on aarch64-macos
2023-07-18 22:51:52 -04:00
var iterator = init(first_address, null);
iterator.unwind_state = .{
.debug_info = debug_info,
std.debug: reorg and clarify API goals After this commit: `std.debug.SelfInfo` is a cross-platform abstraction for the current executable's own debug information, with a goal of minimal code bloat and compilation speed penalty. `std.debug.Dwarf` does not assume the current executable is itself the thing being debugged, however, it does assume the debug info has the same CPU architecture and OS as the current executable. It is planned to remove this limitation.
2024-08-01 22:04:40 -07:00
.dwarf_context = try SelfInfo.UnwindContext.init(debug_info.allocator, context),
debug: disable the new unwinder on aarch64-macos
2023-07-18 22:51:52 -04:00
};
return iterator;
}
fix compilation on powerpc GNU systems ...which have a ucontext_t but not a PC register. The current stack unwinding implementation does not yet support this architecture. Also fix name of `std.debug.SelfInfo.openSelf` to remove redundancy. Also removed this hook into root providing an "openSelfDebugInfo" function. Sorry, this debugging code is not of sufficient quality to offer a plugin API right now.
2024-08-02 12:00:08 -07:00
return init(first_address, null);
- rework StackIterator to optionally use debug_info to unwind the stack - add abi routines for getting register values - unwding is working!
2023-05-15 01:52:53 -04:00
}
debug: prevent segfaults on linux
2024-07-09 12:51:48 -04:00
pub fn deinit(it: *StackIterator) void {
debug: fix MemoryAccessor file leak - patch authored by Jacob Young - tested on alpine-aarch64, 3.21.0, qemu-system 9.2.0 - issue manifested on Alpine Linux aarch64 under qemu-system where zig2 fails during bootstrap: error.ProcessFdQuotaExceeded
2025-01-30 09:27:32 -05:00
it.ma.deinit();
debug: prevent segfaults on linux
2024-07-09 12:51:48 -04:00
if (have_ucontext and it.unwind_state != null) it.unwind_state.?.dwarf_context.deinit();
dwarf: add support for .eh_frame_hdr when unwinding - .eh_frame_hdr contains a binary-searchable data structure for finding an FDE. If present, we can use this section to avoid having to parse the entire FDE/CIE list in the binary, instead only entries that are actually required for unwinding are read. - rework the inputs pc-relative pointer decoding to support both already-mapped sections as well as sections mapped from a file - store the VirtualMachine on UnwindContext so the allocations can be reused
2023-05-29 01:26:30 -04:00
}
debug: prevent segfaults on linux
2024-07-09 12:51:48 -04:00
pub fn getLastError(it: *StackIterator) ?struct {
debug: rework how unwind errors are printed, and add module name lookup for linux This change enhances stack trace output to include a note that debug info was missing, and therefore the stack trace may not be accurate. For example, if the user is using a libc compiled with -fomit-frame-pointer and doesn't have debug symbols installed, any traces that begin in a libc function may not unwind correctly. This allows the user to notice this and potentially install debug symbols to improve the output.
2023-07-02 18:15:36 -04:00
err: UnwindError,
debug: fix initialization of the optional fields on StackIterator dwarf: documentation fixups target: enable unwind tables on macho
2023-07-10 18:43:19 -04:00
address: usize,
debug: rework how unwind errors are printed, and add module name lookup for linux This change enhances stack trace output to include a note that debug info was missing, and therefore the stack trace may not be accurate. For example, if the user is using a libc compiled with -fomit-frame-pointer and doesn't have debug symbols installed, any traces that begin in a libc function may not unwind correctly. This allows the user to notice this and potentially install debug symbols to improve the output.
2023-07-02 18:15:36 -04:00
} {
debug: fix initialization of the optional fields on StackIterator dwarf: documentation fixups target: enable unwind tables on macho
2023-07-10 18:43:19 -04:00
if (!have_ucontext) return null;
debug: prevent segfaults on linux
2024-07-09 12:51:48 -04:00
if (it.unwind_state) |*unwind_state| {
debug: fix initialization of the optional fields on StackIterator dwarf: documentation fixups target: enable unwind tables on macho
2023-07-10 18:43:19 -04:00
if (unwind_state.last_error) |err| {
debug: fixup last_error being printed too many times
2023-07-10 20:18:58 -04:00
unwind_state.last_error = null;
debug: rework how unwind errors are printed, and add module name lookup for linux This change enhances stack trace output to include a note that debug info was missing, and therefore the stack trace may not be accurate. For example, if the user is using a libc compiled with -fomit-frame-pointer and doesn't have debug symbols installed, any traces that begin in a libc function may not unwind correctly. This allows the user to notice this and potentially install debug symbols to improve the output.
2023-07-02 18:15:36 -04:00
return .{
.err = err,
debug: fix initialization of the optional fields on StackIterator dwarf: documentation fixups target: enable unwind tables on macho
2023-07-10 18:43:19 -04:00
.address = unwind_state.dwarf_context.pc,
debug: rework how unwind errors are printed, and add module name lookup for linux This change enhances stack trace output to include a note that debug info was missing, and therefore the stack trace may not be accurate. For example, if the user is using a libc compiled with -fomit-frame-pointer and doesn't have debug symbols installed, any traces that begin in a libc function may not unwind correctly. This allows the user to notice this and potentially install debug symbols to improve the output.
2023-07-02 18:15:36 -04:00
};
}
}
return null;
}
Fix previous %fp calculation
2021-02-05 00:28:07 +07:00
// Offset of the saved BP wrt the frame pointer.
std: remove redundant comptime keyword @g-w1's fancy new compile error in action
2021-04-28 22:58:12 -07:00
const fp_offset = if (native_arch.isRISCV())
std: Minor changes to startup code * Smaller startup sequence for ppc64 * Terminate the frame-pointer chain when executing _start * Make the stack traces work on ppc64 * Make the stack traces coloured on ppc64, some ioctls numbers are different and the whole set of constants should be audited.
2020-10-19 11:40:46 +02:00
// 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.
Fix fp-based backtracing on RISC-V The fp points to the top of the frame instead of pointing to the old fp, compensate this difference with an offset.
2019-10-13 12:13:41 +02:00
2 * @sizeOf(usize)
std: remove redundant comptime keyword @g-w1's fancy new compile error in action
2021-04-28 22:58:12 -07:00
else if (native_arch.isSPARC())
std.debug.StackIterator: account for SPARC %fp quirk On SPARC, previous %fp is saved with a 14 slots offset from current %fp+bias. Also account for the bias constant at the new_fp calculation.
2021-02-04 20:51:41 +07:00
// On SPARC the previous frame pointer is stored at 14 slots past %fp+BIAS.
14 * @sizeOf(usize)
Fix fp-based backtracing on RISC-V The fp points to the top of the frame instead of pointing to the old fp, compensate this difference with an offset.
2019-10-13 12:13:41 +02:00
else
0;
std.debug.StackIterator: account for SPARC %fp quirk On SPARC, previous %fp is saved with a 14 slots offset from current %fp+bias. Also account for the bias constant at the new_fp calculation.
2021-02-04 20:51:41 +07:00
std: remove redundant comptime keyword @g-w1's fancy new compile error in action
2021-04-28 22:58:12 -07:00
const fp_bias = if (native_arch.isSPARC())
std.debug.StackIterator: account for SPARC %fp quirk On SPARC, previous %fp is saved with a 14 slots offset from current %fp+bias. Also account for the bias constant at the new_fp calculation.
2021-02-04 20:51:41 +07:00
// On SPARC frame pointers are biased by a constant.
2047
else
0;
std: Minor changes to startup code * Smaller startup sequence for ppc64 * Terminate the frame-pointer chain when executing _start * Make the stack traces work on ppc64 * Make the stack traces coloured on ppc64, some ioctls numbers are different and the whole set of constants should be audited.
2020-10-19 11:40:46 +02:00
// Positive offset of the saved PC wrt the frame pointer.
std: change `@import("builtin")` to `std.builtin`
2021-04-12 16:43:50 -07:00
const pc_offset = if (native_arch == .powerpc64le)
std: Minor changes to startup code * Smaller startup sequence for ppc64 * Terminate the frame-pointer chain when executing _start * Make the stack traces work on ppc64 * Make the stack traces coloured on ppc64, some ioctls numbers are different and the whole set of constants should be audited.
2020-10-19 11:40:46 +02:00
2 * @sizeOf(usize)
else
@sizeOf(usize);
Fix fp-based backtracing on RISC-V The fp points to the top of the frame instead of pointing to the old fp, compensate this difference with an offset.
2019-10-13 12:13:41 +02:00
debug: prevent segfaults on linux
2024-07-09 12:51:48 -04:00
pub fn next(it: *StackIterator) ?usize {
var address = it.next_internal() orelse return null;
debug: Improve the frame-walking strategy Clean up the code a bit and introduce a few checks meant to avoid overshooting the end of the frame chain. The code is now stable enough not to cause panics during the call frame walking.
2020-02-05 23:40:36 +01:00
debug: prevent segfaults on linux
2024-07-09 12:51:48 -04:00
if (it.first_address) |first_address| {
debug: Improve the frame-walking strategy Clean up the code a bit and introduce a few checks meant to avoid overshooting the end of the frame chain. The code is now stable enough not to cause panics during the call frame walking.
2020-02-05 23:40:36 +01:00
while (address != first_address) {
debug: prevent segfaults on linux
2024-07-09 12:51:48 -04:00
address = it.next_internal() orelse return null;
std.debug.StackIterator
2018-12-02 18:54:04 -05:00
}
debug: prevent segfaults on linux
2024-07-09 12:51:48 -04:00
it.first_address = null;
std.debug.StackIterator
2018-12-02 18:54:04 -05:00
}
debug: Improve the frame-walking strategy Clean up the code a bit and introduce a few checks meant to avoid overshooting the end of the frame chain. The code is now stable enough not to cause panics during the call frame walking.
2020-02-05 23:40:36 +01:00
return address;
}
debug: prevent segfaults on linux
2024-07-09 12:51:48 -04:00
fn next_unwind(it: *StackIterator) !usize {
const unwind_state = &it.unwind_state.?;
debug: fix initialization of the optional fields on StackIterator dwarf: documentation fixups target: enable unwind tables on macho
2023-07-10 18:43:19 -04:00
const module = try unwind_state.debug_info.getModuleForAddress(unwind_state.dwarf_context.pc);
dwarf: skip register tests on unimplemented arch / os, add tests for type convesions debug: dupeContext -> copyContext
2023-07-08 01:16:11 -04:00
switch (native_os) {
handle visionos target OS tag in the compiler * rename .xros to .visionos as agreed in the tracking issue * add support for VisionOS platform in the MachO linker
2024-05-09 15:04:13 +02:00
.macos, .ios, .watchos, .tvos, .visionos => {
macho: add unwindFrame which can unwind stack frames using the __unwind_info section dwarf: fixup missing error
2023-07-08 16:39:38 -04:00
// __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| {
std.debug: reorg and clarify API goals After this commit: `std.debug.SelfInfo` is a cross-platform abstraction for the current executable's own debug information, with a goal of minimal code bloat and compilation speed penalty. `std.debug.Dwarf` does not assume the current executable is itself the thing being debugged, however, it does assume the debug info has the same CPU architecture and OS as the current executable. It is planned to remove this limitation.
2024-08-01 22:04:40 -07:00
if (SelfInfo.unwindFrameMachO(
std.debug: Fall back to .eh_frame/.debug_frame if .eh_frame_hdr is incomplete. When using the self-hosted backends, especially in incremental mode, the .eh_frame_hdr section may be incomplete, so we can't treat it as authoritative. Instead, if we started out intending to use .eh_frame_hdr but find that it's incomplete, load .eh_frame/.debug_frame on demand and use that info going forward.
2025-01-23 20:55:20 +01:00
unwind_state.debug_info.allocator,
module.base_address,
std.debug: reorg and clarify API goals After this commit: `std.debug.SelfInfo` is a cross-platform abstraction for the current executable's own debug information, with a goal of minimal code bloat and compilation speed penalty. `std.debug.Dwarf` does not assume the current executable is itself the thing being debugged, however, it does assume the debug info has the same CPU architecture and OS as the current executable. It is planned to remove this limitation.
2024-08-01 22:04:40 -07:00
&unwind_state.dwarf_context,
&it.ma,
unwind_info,
module.eh_frame,
)) |return_address| {
macho: add unwindFrame which can unwind stack frames using the __unwind_info section dwarf: fixup missing error
2023-07-08 16:39:38 -04:00
return return_address;
} else |err| {
if (err != error.RequiresDWARFUnwind) return err;
}
} else return error.MissingUnwindInfo;
dwarf: skip register tests on unimplemented arch / os, add tests for type convesions debug: dupeContext -> copyContext
2023-07-08 01:16:11 -04:00
},
else => {},
}
debug: fix initialization of the optional fields on StackIterator dwarf: documentation fixups target: enable unwind tables on macho
2023-07-10 18:43:19 -04:00
if (try module.getDwarfInfoForAddress(unwind_state.debug_info.allocator, unwind_state.dwarf_context.pc)) |di| {
std.debug: Fall back to .eh_frame/.debug_frame if .eh_frame_hdr is incomplete. When using the self-hosted backends, especially in incremental mode, the .eh_frame_hdr section may be incomplete, so we can't treat it as authoritative. Instead, if we started out intending to use .eh_frame_hdr but find that it's incomplete, load .eh_frame/.debug_frame on demand and use that info going forward.
2025-01-23 20:55:20 +01:00
return SelfInfo.unwindFrameDwarf(
unwind_state.debug_info.allocator,
di,
module.base_address,
&unwind_state.dwarf_context,
&it.ma,
null,
);
- rework StackIterator to optionally use debug_info to unwind the stack - add abi routines for getting register values - unwding is working!
2023-05-15 01:52:53 -04:00
} else return error.MissingDebugInfo;
}
debug: prevent segfaults on linux
2024-07-09 12:51:48 -04:00
fn next_internal(it: *StackIterator) ?usize {
debug: fix initialization of the optional fields on StackIterator dwarf: documentation fixups target: enable unwind tables on macho
2023-07-10 18:43:19 -04:00
if (have_ucontext) {
debug: prevent segfaults on linux
2024-07-09 12:51:48 -04:00
if (it.unwind_state) |*unwind_state| {
debug: fixup last_error being printed too many times
2023-07-10 20:18:58 -04:00
if (!unwind_state.failed) {
if (unwind_state.dwarf_context.pc == 0) return null;
debug: prevent segfaults on linux
2024-07-09 12:51:48 -04:00
defer it.fp = unwind_state.dwarf_context.getFp() catch 0;
if (it.next_unwind()) |return_address| {
debug: fixup have_getcontext
2023-07-11 01:06:41 -04:00
return return_address;
} else |err| {
unwind_state.last_error = err;
unwind_state.failed = true;
// Fall back to fp-based unwinding on the first failure.
debug: disable the new unwinder on aarch64-macos
2023-07-18 22:51:52 -04:00
// We can't attempt it again for other modules higher in the
// stack because the full register state won't have been unwound.
debug: fix initialization of the optional fields on StackIterator dwarf: documentation fixups target: enable unwind tables on macho
2023-07-10 18:43:19 -04:00
}
}
- rework StackIterator to optionally use debug_info to unwind the stack - add abi routines for getting register values - unwding is working!
2023-05-15 01:52:53 -04:00
}
}
Merge remote-tracking branch 'origin/master' into stage2-whole-file-astgen In particular I wanted to take advantage of the new hex float parsing code.
2021-04-28 14:53:50 -07:00
const fp = if (comptime native_arch.isSPARC())
Fix previous %fp calculation
2021-02-05 00:28:07 +07:00
// On SPARC the offset is positive. (!)
debug: prevent segfaults on linux
2024-07-09 12:51:48 -04:00
math.add(usize, it.fp, fp_offset) catch return null
Fix previous %fp calculation
2021-02-05 00:28:07 +07:00
else
debug: prevent segfaults on linux
2024-07-09 12:51:48 -04:00
math.sub(usize, it.fp, fp_offset) catch return null;
debug: Improve the frame-walking strategy Clean up the code a bit and introduce a few checks meant to avoid overshooting the end of the frame chain. The code is now stable enough not to cause panics during the call frame walking.
2020-02-05 23:40:36 +01:00
std: Minor changes to startup code * Smaller startup sequence for ppc64 * Terminate the frame-pointer chain when executing _start * Make the stack traces work on ppc64 * Make the stack traces coloured on ppc64, some ioctls numbers are different and the whole set of constants should be audited.
2020-10-19 11:40:46 +02:00
// Sanity check.
debug: prevent segfaults on linux
2024-07-09 12:51:48 -04:00
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
debug: Improve the frame-walking strategy Clean up the code a bit and introduce a few checks meant to avoid overshooting the end of the frame chain. The code is now stable enough not to cause panics during the call frame walking.
2020-02-05 23:40:36 +01:00
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
std: Minor changes to startup code * Smaller startup sequence for ppc64 * Terminate the frame-pointer chain when executing _start * Make the stack traces work on ppc64 * Make the stack traces coloured on ppc64, some ioctls numbers are different and the whole set of constants should be audited.
2020-10-19 11:40:46 +02:00
// is gracefully handled by the next call to next_internal.
debug: prevent segfaults on linux
2024-07-09 12:51:48 -04:00
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
debug: Improve the frame-walking strategy Clean up the code a bit and introduce a few checks meant to avoid overshooting the end of the frame chain. The code is now stable enough not to cause panics during the call frame walking.
2020-02-05 23:40:36 +01:00
return null;
debug: prevent segfaults on linux
2024-07-09 12:51:48 -04:00
it.fp = new_fp;
debug: Improve the frame-walking strategy Clean up the code a bit and introduce a few checks meant to avoid overshooting the end of the frame chain. The code is now stable enough not to cause panics during the call frame walking.
2020-02-05 23:40:36 +01:00
return new_pc;
std.debug.StackIterator
2018-12-02 18:54:04 -05:00
}
};
fix cancel and await semantics
2018-07-29 23:25:40 -04:00
fix debug info code not being freestanding compatible in stack tracing code, the idea was to detect the tty settings at the top of the stack and pass the information down. somewhere along the way this got changed so that setTtyColor was assuming the global stderr_file was related to the output stream the stack trace was being printed to. now, tty_color is changed to tty_config, and it is an enum rather than a bool, telling how tty colors are expected to be handled. windows is still incorrectly looking at stderr_file.
2020-01-26 09:55:04 -05:00
pub fn writeCurrentStackTrace(
run zig fmt on std lib and self hosted
2020-07-11 14:09:04 +03:00
out_stream: anytype,
std.debug: rename Info to SelfInfo This code has the hard-coded goal of supporting the executable's own debug information and makes design choices along that goal, such as memory-mapping the inputs, using dl_iterate_phdr, and doing conditional compilation on the host target. A more general-purpose implementation of debug information may be able to share code with this, but there are some fundamental incompatibilities. For example, the "SelfInfo" implementation wants to avoid bloating the binary with PDB on POSIX systems, and likewise DWARF on Windows systems, while a general-purpose implementation needs to support both PDB and DWARF from the same binary. It might, for example, inspect the debug information from a cross-compiled binary. `SourceLocation` now lives at `std.debug.SourceLocation` and is documented. Deprecate `std.debug.runtime_safety` because it returns the optimization mode of the standard library, when the caller probably wants to use the optimization mode of their own module. `std.pdb.Pdb` is moved to `std.debug.Pdb`, mirroring the recent extraction of `std.debug.Dwarf` from `std.dwarf`. I have no idea why we have both Module (with a Windows-specific definition) and WindowsModule. I left some passive aggressive doc comments to express my frustration.
2024-08-01 16:31:03 -07:00
debug_info: *SelfInfo,
std: Move std.debug.{TTY.Config,detectTTYConfig} to std.io.tty Also get rid of the TTY wrapper struct, which was exlusively used as a namespace - this is done by the tty.zig root struct now. detectTTYConfig has been renamed to just detectConfig, which is enough given the new namespace. Additionally, a doc comment had been added.
2023-05-21 14:27:28 +01:00
tty_config: io.tty.Config,
fix debug info code not being freestanding compatible in stack tracing code, the idea was to detect the tty settings at the top of the stack and pass the information down. somewhere along the way this got changed so that setTtyColor was assuming the global stderr_file was related to the output stream the stack trace was being printed to. now, tty_color is changed to tty_config, and it is an enum rather than a bool, telling how tty colors are expected to be handled. windows is still incorrectly looking at stderr_file.
2020-01-26 09:55:04 -05:00
start_addr: ?usize,
) !void {
std: change `@import("builtin")` to `std.builtin`
2021-04-12 16:43:50 -07:00
if (native_os == .windows) {
fix compilation on powerpc GNU systems ...which have a ucontext_t but not a PC register. The current stack unwinding implementation does not yet support this architecture. Also fix name of `std.debug.SelfInfo.openSelf` to remove redundancy. Also removed this hook into root providing an "openSelfDebugInfo" function. Sorry, this debugging code is not of sufficient quality to offer a plugin API right now.
2024-08-02 12:00:08 -07:00
var context: ThreadContext = undefined;
assert(getContext(&context));
debug: x86 unwinding support, more unwinding fixes - Fix unwindFrame using the previous FDE row instead of the current one - Handle unwinding through noreturn functions - Add x86-linux getcontext - Fixup x86_64-linux getcontext not restoring the fp env - Fix start_addr filtering on x86-windows
2023-06-27 02:02:49 -04:00
return writeStackTraceWindows(out_stream, debug_info, tty_config, &context, start_addr);
use RtlCaptureStackBackTrace on windows
2018-08-29 16:35:51 -04:00
}
fix compilation on powerpc GNU systems ...which have a ucontext_t but not a PC register. The current stack unwinding implementation does not yet support this architecture. Also fix name of `std.debug.SelfInfo.openSelf` to remove redundancy. Also removed this hook into root providing an "openSelfDebugInfo" function. Sorry, this debugging code is not of sufficient quality to offer a plugin API right now.
2024-08-02 12:00:08 -07:00
var context: ThreadContext = undefined;
const has_context = getContext(&context);
- rework StackIterator to optionally use debug_info to unwind the stack - add abi routines for getting register values - unwding is working!
2023-05-15 01:52:53 -04:00
debug: x86 unwinding support, more unwinding fixes - Fix unwindFrame using the previous FDE row instead of the current one - Handle unwinding through noreturn functions - Add x86-linux getcontext - Fixup x86_64-linux getcontext not restoring the fp env - Fix start_addr filtering on x86-windows
2023-06-27 02:02:49 -04:00
var it = (if (has_context) blk: {
debug: enhance writeCurrentStackTrace to use context-based unwinding when available
2023-06-26 00:59:28 -04:00
break :blk StackIterator.initWithContext(start_addr, debug_info, &context) catch null;
} else null) orelse StackIterator.init(start_addr, null);
dwarf: add support for .eh_frame_hdr when unwinding - .eh_frame_hdr contains a binary-searchable data structure for finding an FDE. If present, we can use this section to avoid having to parse the entire FDE/CIE list in the binary, instead only entries that are actually required for unwinding are read. - rework the inputs pc-relative pointer decoding to support both already-mapped sections as well as sections mapped from a file - store the VirtualMachine on UnwindContext so the allocations can be reused
2023-05-29 01:26:30 -04:00
defer it.deinit();
std.debug.StackIterator
2018-12-02 18:54:04 -05:00
while (it.next()) |return_address| {
debug: skip unwind error printing on platforms that don't have_ucontext
2023-07-26 22:10:22 -04:00
printLastUnwindError(&it, debug_info, out_stream, tty_config);
debug: rework how unwind errors are printed, and add module name lookup for linux This change enhances stack trace output to include a note that debug info was missing, and therefore the stack trace may not be accurate. For example, if the user is using a libc compiled with -fomit-frame-pointer and doesn't have debug symbols installed, any traces that begin in a libc function may not unwind correctly. This allows the user to notice this and potentially install debug symbols to improve the output.
2023-07-02 18:15:36 -04:00
std: check for overflow in writeCurrentStackTrace On arm64 macOS, the address of the last frame is 0x0 rather than a positive value like 0x1 on x86_64 macOS, therefore, we overflow an integer trying to subtract 1 when printing the stack trace. This patch fixes it by first checking for this condition before trying to subtract 1. Note that we do not need to signal the `SignalIterator` about this as it will correctly detect this condition on the subsequent iteration and return `null`, thus terminating the loop.
2021-08-02 11:10:07 +02:00
// 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.
all: rename i386 to x86
2022-10-07 21:24:44 +03:30
// same behaviour for x86-windows-msvc
std.debug.Dwarf: precompute .debug_line table yields a 60x speedup for resolveSourceLocations in debug builds
2024-08-02 23:31:28 -07:00
const address = return_address -| 1;
std: check for overflow in writeCurrentStackTrace On arm64 macOS, the address of the last frame is 0x0 rather than a positive value like 0x1 on x86_64 macOS, therefore, we overflow an integer trying to subtract 1 when printing the stack trace. This patch fixes it by first checking for this condition before trying to subtract 1. Note that we do not need to signal the `SignalIterator` about this as it will correctly detect this condition on the subsequent iteration and return `null`, thus terminating the loop.
2021-08-02 11:10:07 +02:00
try printSourceAtAddress(debug_info, out_stream, address, tty_config);
debug: skip unwind error printing on platforms that don't have_ucontext
2023-07-26 22:10:22 -04:00
} else printLastUnwindError(&it, debug_info, out_stream, tty_config);
fix duplicate stack trace code
2018-01-14 10:19:21 -05:00
}
*WIP* proof of concept error return traces
2018-01-12 02:12:11 -05:00
debug: x86 unwinding support, more unwinding fixes - Fix unwindFrame using the previous FDE row instead of the current one - Handle unwinding through noreturn functions - Add x86-linux getcontext - Fixup x86_64-linux getcontext not restoring the fp env - Fix start_addr filtering on x86-windows
2023-06-27 02:02:49 -04:00
pub noinline fn walkStackWindows(addresses: []usize, existing_context: ?*const windows.CONTEXT) usize {
debug: replace RtlCaptureStackBackTrace (which was spuriously failing) with a new implementation which uses RtlVirtualUnwind instead (#12740) windows: add RtlCaptureContext, RtlLookupFunctionEntry, RtlVirtualUnwind and supporting types windows: fix alignment of CONTEXT structs to match winnt.h as required by RtlCaptureContext (fxsave instr) windows aarch64: fix __chkstk being defined twice if libc is not linked on msvc Co-authored-by: Jakub Konka <kubkon@jakubkonka.com>
2023-01-04 14:54:49 -05:00
if (builtin.cpu.arch == .x86) {
// RtlVirtualUnwind doesn't exist on x86
all: migrate code to new cast builtin syntax Most of this migration was performed automatically with `zig fmt`. There were a few exceptions which I had to manually fix: * `@alignCast` and `@addrSpaceCast` cannot be automatically rewritten * `@truncate`'s fixup is incorrect for vectors * Test cases are not formatted, and their error locations change
2023-06-22 18:46:56 +01:00
return windows.ntdll.RtlCaptureStackBackTrace(0, addresses.len, @as(**anyopaque, @ptrCast(addresses.ptr)), null);
debug: replace RtlCaptureStackBackTrace (which was spuriously failing) with a new implementation which uses RtlVirtualUnwind instead (#12740) windows: add RtlCaptureContext, RtlLookupFunctionEntry, RtlVirtualUnwind and supporting types windows: fix alignment of CONTEXT structs to match winnt.h as required by RtlCaptureContext (fxsave instr) windows aarch64: fix __chkstk being defined twice if libc is not linked on msvc Co-authored-by: Jakub Konka <kubkon@jakubkonka.com>
2023-01-04 14:54:49 -05:00
}
Windows: Add wrappers for `GetCurrent(Process|Thread)` via NT_TIB This is how they've been implemented in `kernel32` since NT 3.1.
2024-03-12 22:21:55 +11:00
const tib = &windows.teb().NtTib;
debug: replace RtlCaptureStackBackTrace (which was spuriously failing) with a new implementation which uses RtlVirtualUnwind instead (#12740) windows: add RtlCaptureContext, RtlLookupFunctionEntry, RtlVirtualUnwind and supporting types windows: fix alignment of CONTEXT structs to match winnt.h as required by RtlCaptureContext (fxsave instr) windows aarch64: fix __chkstk being defined twice if libc is not linked on msvc Co-authored-by: Jakub Konka <kubkon@jakubkonka.com>
2023-01-04 14:54:49 -05:00
debug: x86 unwinding support, more unwinding fixes - Fix unwindFrame using the previous FDE row instead of the current one - Handle unwinding through noreturn functions - Add x86-linux getcontext - Fixup x86_64-linux getcontext not restoring the fp env - Fix start_addr filtering on x86-windows
2023-06-27 02:02:49 -04:00
var context: windows.CONTEXT = undefined;
if (existing_context) |context_ptr| {
context = context_ptr.*;
} else {
context = std.mem.zeroes(windows.CONTEXT);
windows.ntdll.RtlCaptureContext(&context);
}
debug: replace RtlCaptureStackBackTrace (which was spuriously failing) with a new implementation which uses RtlVirtualUnwind instead (#12740) windows: add RtlCaptureContext, RtlLookupFunctionEntry, RtlVirtualUnwind and supporting types windows: fix alignment of CONTEXT structs to match winnt.h as required by RtlCaptureContext (fxsave instr) windows aarch64: fix __chkstk being defined twice if libc is not linked on msvc Co-authored-by: Jakub Konka <kubkon@jakubkonka.com>
2023-01-04 14:54:49 -05:00
var i: usize = 0;
std.debug: Fix a bitness portability issue in walkStackWindows().
2024-08-21 15:49:09 +02:00
var image_base: windows.DWORD64 = undefined;
debug: replace RtlCaptureStackBackTrace (which was spuriously failing) with a new implementation which uses RtlVirtualUnwind instead (#12740) windows: add RtlCaptureContext, RtlLookupFunctionEntry, RtlVirtualUnwind and supporting types windows: fix alignment of CONTEXT structs to match winnt.h as required by RtlCaptureContext (fxsave instr) windows aarch64: fix __chkstk being defined twice if libc is not linked on msvc Co-authored-by: Jakub Konka <kubkon@jakubkonka.com>
2023-01-04 14:54:49 -05:00
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;
debug: fix missing stack traces during crashes on windows - walk the stack via the method that is aware of unwind info (fixes x86_64 / aarch64 traces) - enhance the output for frames where the debug info isn't available by printing the module name
2023-04-18 00:01:41 -04:00
_ = windows.ntdll.RtlVirtualUnwind(
windows.UNW_FLAG_NHANDLER,
image_base,
current_regs.ip,
runtime_function,
&context,
&handler_data,
&establisher_frame,
null,
);
debug: replace RtlCaptureStackBackTrace (which was spuriously failing) with a new implementation which uses RtlVirtualUnwind instead (#12740) windows: add RtlCaptureContext, RtlLookupFunctionEntry, RtlVirtualUnwind and supporting types windows: fix alignment of CONTEXT structs to match winnt.h as required by RtlCaptureContext (fxsave instr) windows aarch64: fix __chkstk being defined twice if libc is not linked on msvc Co-authored-by: Jakub Konka <kubkon@jakubkonka.com>
2023-01-04 14:54:49 -05:00
} else {
// leaf function
std.debug: Fix a bitness portability issue in walkStackWindows().
2024-08-21 15:49:09 +02:00
context.setIp(@as(*usize, @ptrFromInt(current_regs.sp)).*);
debug: replace RtlCaptureStackBackTrace (which was spuriously failing) with a new implementation which uses RtlVirtualUnwind instead (#12740) windows: add RtlCaptureContext, RtlLookupFunctionEntry, RtlVirtualUnwind and supporting types windows: fix alignment of CONTEXT structs to match winnt.h as required by RtlCaptureContext (fxsave instr) windows aarch64: fix __chkstk being defined twice if libc is not linked on msvc Co-authored-by: Jakub Konka <kubkon@jakubkonka.com>
2023-01-04 14:54:49 -05:00
context.setSp(current_regs.sp + @sizeOf(usize));
}
const next_regs = context.getRegs();
all: zig fmt and rename "@XToY" to "@YFromX" Signed-off-by: Eric Joldasov <bratishkaerik@getgoogleoff.me>
2023-06-15 13:14:16 +06:00
if (next_regs.sp < @intFromPtr(tib.StackLimit) or next_regs.sp > @intFromPtr(tib.StackBase)) {
debug: replace RtlCaptureStackBackTrace (which was spuriously failing) with a new implementation which uses RtlVirtualUnwind instead (#12740) windows: add RtlCaptureContext, RtlLookupFunctionEntry, RtlVirtualUnwind and supporting types windows: fix alignment of CONTEXT structs to match winnt.h as required by RtlCaptureContext (fxsave instr) windows aarch64: fix __chkstk being defined twice if libc is not linked on msvc Co-authored-by: Jakub Konka <kubkon@jakubkonka.com>
2023-01-04 14:54:49 -05:00
break;
}
if (next_regs.ip == 0) {
break;
}
addresses[i] = next_regs.ip;
}
return i;
}
debug: x86 unwinding support, more unwinding fixes - Fix unwindFrame using the previous FDE row instead of the current one - Handle unwinding through noreturn functions - Add x86-linux getcontext - Fixup x86_64-linux getcontext not restoring the fp env - Fix start_addr filtering on x86-windows
2023-06-27 02:02:49 -04:00
pub fn writeStackTraceWindows(
run zig fmt on std lib and self hosted
2020-07-11 14:09:04 +03:00
out_stream: anytype,
std.debug: rename Info to SelfInfo This code has the hard-coded goal of supporting the executable's own debug information and makes design choices along that goal, such as memory-mapping the inputs, using dl_iterate_phdr, and doing conditional compilation on the host target. A more general-purpose implementation of debug information may be able to share code with this, but there are some fundamental incompatibilities. For example, the "SelfInfo" implementation wants to avoid bloating the binary with PDB on POSIX systems, and likewise DWARF on Windows systems, while a general-purpose implementation needs to support both PDB and DWARF from the same binary. It might, for example, inspect the debug information from a cross-compiled binary. `SourceLocation` now lives at `std.debug.SourceLocation` and is documented. Deprecate `std.debug.runtime_safety` because it returns the optimization mode of the standard library, when the caller probably wants to use the optimization mode of their own module. `std.pdb.Pdb` is moved to `std.debug.Pdb`, mirroring the recent extraction of `std.debug.Dwarf` from `std.dwarf`. I have no idea why we have both Module (with a Windows-specific definition) and WindowsModule. I left some passive aggressive doc comments to express my frustration.
2024-08-01 16:31:03 -07:00
debug_info: *SelfInfo,
std: Move std.debug.{TTY.Config,detectTTYConfig} to std.io.tty Also get rid of the TTY wrapper struct, which was exlusively used as a namespace - this is done by the tty.zig root struct now. detectTTYConfig has been renamed to just detectConfig, which is enough given the new namespace. Additionally, a doc comment had been added.
2023-05-21 14:27:28 +01:00
tty_config: io.tty.Config,
debug: x86 unwinding support, more unwinding fixes - Fix unwindFrame using the previous FDE row instead of the current one - Handle unwinding through noreturn functions - Add x86-linux getcontext - Fixup x86_64-linux getcontext not restoring the fp env - Fix start_addr filtering on x86-windows
2023-06-27 02:02:49 -04:00
context: *const windows.CONTEXT,
fix zig fmt on windows closes #1069
2018-09-12 14:26:21 -04:00
start_addr: ?usize,
) !void {
use RtlCaptureStackBackTrace on windows
2018-08-29 16:35:51 -04:00
var addr_buf: [1024]usize = undefined;
debug: x86 unwinding support, more unwinding fixes - Fix unwindFrame using the previous FDE row instead of the current one - Handle unwinding through noreturn functions - Add x86-linux getcontext - Fixup x86_64-linux getcontext not restoring the fp env - Fix start_addr filtering on x86-windows
2023-06-27 02:02:49 -04:00
const n = walkStackWindows(addr_buf[0..], context);
use RtlCaptureStackBackTrace on windows
2018-08-29 16:35:51 -04:00
const addrs = addr_buf[0..n];
lib: correct unnecessary uses of 'var'
2023-11-10 05:27:17 +00:00
const start_i: usize = if (start_addr) |saddr| blk: {
update std lib and compiler sources to new for loop syntax
2023-02-18 09:02:57 -07:00
for (addrs, 0..) |addr, i| {
use RtlCaptureStackBackTrace on windows
2018-08-29 16:35:51 -04:00
if (addr == saddr) break :blk i;
}
return;
} else 0;
for (addrs[start_i..]) |addr| {
Fix stack-trace address calculation on Windows Let's always subtract 1 from the return address so that we're sure to be inside the callee. Fixes some edge case where the stack trace skipped the first entry.
2020-01-27 13:12:01 +01:00
try printSourceAtAddress(debug_info, out_stream, addr - 1, tty_config);
use RtlCaptureStackBackTrace on windows
2018-08-29 16:35:51 -04:00
}
}
std.debug: rename Info to SelfInfo This code has the hard-coded goal of supporting the executable's own debug information and makes design choices along that goal, such as memory-mapping the inputs, using dl_iterate_phdr, and doing conditional compilation on the host target. A more general-purpose implementation of debug information may be able to share code with this, but there are some fundamental incompatibilities. For example, the "SelfInfo" implementation wants to avoid bloating the binary with PDB on POSIX systems, and likewise DWARF on Windows systems, while a general-purpose implementation needs to support both PDB and DWARF from the same binary. It might, for example, inspect the debug information from a cross-compiled binary. `SourceLocation` now lives at `std.debug.SourceLocation` and is documented. Deprecate `std.debug.runtime_safety` because it returns the optimization mode of the standard library, when the caller probably wants to use the optimization mode of their own module. `std.pdb.Pdb` is moved to `std.debug.Pdb`, mirroring the recent extraction of `std.debug.Dwarf` from `std.dwarf`. I have no idea why we have both Module (with a Windows-specific definition) and WindowsModule. I left some passive aggressive doc comments to express my frustration.
2024-08-01 16:31:03 -07:00
fn printUnknownSource(debug_info: *SelfInfo, out_stream: anytype, address: usize, tty_config: io.tty.Config) !void {
debug: fix missing stack traces during crashes on windows - walk the stack via the method that is aware of unwind info (fixes x86_64 / aarch64 traces) - enhance the output for frames where the debug info isn't available by printing the module name
2023-04-18 00:01:41 -04:00
const module_name = debug_info.getModuleNameForAddress(address);
return printLineInfo(
out_stream,
null,
address,
"???",
module_name orelse "???",
tty_config,
printLineFromFileAnyOs,
);
}
std.debug: rename Info to SelfInfo This code has the hard-coded goal of supporting the executable's own debug information and makes design choices along that goal, such as memory-mapping the inputs, using dl_iterate_phdr, and doing conditional compilation on the host target. A more general-purpose implementation of debug information may be able to share code with this, but there are some fundamental incompatibilities. For example, the "SelfInfo" implementation wants to avoid bloating the binary with PDB on POSIX systems, and likewise DWARF on Windows systems, while a general-purpose implementation needs to support both PDB and DWARF from the same binary. It might, for example, inspect the debug information from a cross-compiled binary. `SourceLocation` now lives at `std.debug.SourceLocation` and is documented. Deprecate `std.debug.runtime_safety` because it returns the optimization mode of the standard library, when the caller probably wants to use the optimization mode of their own module. `std.pdb.Pdb` is moved to `std.debug.Pdb`, mirroring the recent extraction of `std.debug.Dwarf` from `std.dwarf`. I have no idea why we have both Module (with a Windows-specific definition) and WindowsModule. I left some passive aggressive doc comments to express my frustration.
2024-08-01 16:31:03 -07:00
fn printLastUnwindError(it: *StackIterator, debug_info: *SelfInfo, out_stream: anytype, tty_config: io.tty.Config) void {
debug: skip unwind error printing on platforms that don't have_ucontext
2023-07-26 22:10:22 -04:00
if (!have_ucontext) return;
if (it.getLastError()) |unwind_error| {
printUnwindError(debug_info, out_stream, unwind_error.address, unwind_error.err, tty_config) catch {};
}
}
std.debug: rename Info to SelfInfo This code has the hard-coded goal of supporting the executable's own debug information and makes design choices along that goal, such as memory-mapping the inputs, using dl_iterate_phdr, and doing conditional compilation on the host target. A more general-purpose implementation of debug information may be able to share code with this, but there are some fundamental incompatibilities. For example, the "SelfInfo" implementation wants to avoid bloating the binary with PDB on POSIX systems, and likewise DWARF on Windows systems, while a general-purpose implementation needs to support both PDB and DWARF from the same binary. It might, for example, inspect the debug information from a cross-compiled binary. `SourceLocation` now lives at `std.debug.SourceLocation` and is documented. Deprecate `std.debug.runtime_safety` because it returns the optimization mode of the standard library, when the caller probably wants to use the optimization mode of their own module. `std.pdb.Pdb` is moved to `std.debug.Pdb`, mirroring the recent extraction of `std.debug.Dwarf` from `std.dwarf`. I have no idea why we have both Module (with a Windows-specific definition) and WindowsModule. I left some passive aggressive doc comments to express my frustration.
2024-08-01 16:31:03 -07:00
fn printUnwindError(debug_info: *SelfInfo, out_stream: anytype, address: usize, err: UnwindError, tty_config: io.tty.Config) !void {
debug: rework how unwind errors are printed, and add module name lookup for linux This change enhances stack trace output to include a note that debug info was missing, and therefore the stack trace may not be accurate. For example, if the user is using a libc compiled with -fomit-frame-pointer and doesn't have debug symbols installed, any traces that begin in a libc function may not unwind correctly. This allows the user to notice this and potentially install debug symbols to improve the output.
2023-07-02 18:15:36 -04:00
const module_name = debug_info.getModuleNameForAddress(address) orelse "???";
try tty_config.setColor(out_stream, .dim);
debug: print unwind errors if they occur on the first iteration, and differentiate between missing info and an actual unwind error in the message
2023-07-23 14:06:35 -04:00
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 });
}
debug: rework how unwind errors are printed, and add module name lookup for linux This change enhances stack trace output to include a note that debug info was missing, and therefore the stack trace may not be accurate. For example, if the user is using a libc compiled with -fomit-frame-pointer and doesn't have debug symbols installed, any traces that begin in a libc function may not unwind correctly. This allows the user to notice this and potentially install debug symbols to improve the output.
2023-07-02 18:15:36 -04:00
try tty_config.setColor(out_stream, .reset);
}
std.debug: rename Info to SelfInfo This code has the hard-coded goal of supporting the executable's own debug information and makes design choices along that goal, such as memory-mapping the inputs, using dl_iterate_phdr, and doing conditional compilation on the host target. A more general-purpose implementation of debug information may be able to share code with this, but there are some fundamental incompatibilities. For example, the "SelfInfo" implementation wants to avoid bloating the binary with PDB on POSIX systems, and likewise DWARF on Windows systems, while a general-purpose implementation needs to support both PDB and DWARF from the same binary. It might, for example, inspect the debug information from a cross-compiled binary. `SourceLocation` now lives at `std.debug.SourceLocation` and is documented. Deprecate `std.debug.runtime_safety` because it returns the optimization mode of the standard library, when the caller probably wants to use the optimization mode of their own module. `std.pdb.Pdb` is moved to `std.debug.Pdb`, mirroring the recent extraction of `std.debug.Dwarf` from `std.dwarf`. I have no idea why we have both Module (with a Windows-specific definition) and WindowsModule. I left some passive aggressive doc comments to express my frustration.
2024-08-01 16:31:03 -07:00
pub fn printSourceAtAddress(debug_info: *SelfInfo, out_stream: anytype, address: usize, tty_config: io.tty.Config) !void {
unification: osx debug info
2020-02-22 11:51:45 +01:00
const module = debug_info.getModuleForAddress(address) catch |err| switch (err) {
debug: fix missing stack traces during crashes on windows - walk the stack via the method that is aware of unwind info (fixes x86_64 / aarch64 traces) - enhance the output for frames where the debug info isn't available by printing the module name
2023-04-18 00:01:41 -04:00
error.MissingDebugInfo, error.InvalidDebugInfo => return printUnknownSource(debug_info, out_stream, address, tty_config),
debug: fix initialization of the optional fields on StackIterator dwarf: documentation fixups target: enable unwind tables on macho
2023-07-10 18:43:19 -04:00
else => return err,
unsure
2020-02-21 12:11:04 +01:00
};
debug: Split the DWARF stuff in its own file
2020-02-08 14:15:28 +01:00
debug: fix missing stack traces during crashes on windows - walk the stack via the method that is aware of unwind info (fixes x86_64 / aarch64 traces) - enhance the output for frames where the debug info isn't available by printing the module name
2023-04-18 00:01:41 -04:00
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),
debug: fix initialization of the optional fields on StackIterator dwarf: documentation fixups target: enable unwind tables on macho
2023-07-10 18:43:19 -04:00
else => return err,
debug: fix missing stack traces during crashes on windows - walk the stack via the method that is aware of unwind info (fixes x86_64 / aarch64 traces) - enhance the output for frames where the debug info isn't available by printing the module name
2023-04-18 00:01:41 -04:00
};
introduce tool for dumping coverage file with debug info resolved. begin efforts of providing `std.debug.Info`, a cross-platform abstraction for loading debug information into an in-memory format that supports queries such as "what is the source location of this virtual memory address?" Unlike `std.debug.SelfInfo`, this API does not assume the debug information in question happens to match the host CPU architecture, OS, or other target properties.
2024-08-02 16:31:49 -07:00
defer if (symbol_info.source_location) |sl| debug_info.allocator.free(sl.file_name);
soldier on
2020-02-20 20:48:54 +01:00
tmp
2020-02-09 11:55:43 +01:00
return printLineInfo(
debug: Split the DWARF stuff in its own file
2020-02-08 14:15:28 +01:00
out_stream,
introduce tool for dumping coverage file with debug info resolved. begin efforts of providing `std.debug.Info`, a cross-platform abstraction for loading debug information into an in-memory format that supports queries such as "what is the source location of this virtual memory address?" Unlike `std.debug.SelfInfo`, this API does not assume the debug information in question happens to match the host CPU architecture, OS, or other target properties.
2024-08-02 16:31:49 -07:00
symbol_info.source_location,
debug: Split the DWARF stuff in its own file
2020-02-08 14:15:28 +01:00
address,
introduce tool for dumping coverage file with debug info resolved. begin efforts of providing `std.debug.Info`, a cross-platform abstraction for loading debug information into an in-memory format that supports queries such as "what is the source location of this virtual memory address?" Unlike `std.debug.SelfInfo`, this API does not assume the debug information in question happens to match the host CPU architecture, OS, or other target properties.
2024-08-02 16:31:49 -07:00
symbol_info.name,
delete extra code, more forgiveness
2020-02-22 12:44:21 +01:00
symbol_info.compile_unit_name,
debug: Split the DWARF stuff in its own file
2020-02-08 14:15:28 +01:00
tty_config,
printLineFromFileAnyOs,
);
std.debug.printSourceAtAddressDwarf which works in freestanding mode
2018-12-02 19:34:11 -05:00
}
MacOS stack traces use the already mmapped executable ...rather than trying to find the executable on the file system. Also use a more robust PIE offset calculation based on the available metadata. And for the last function, use the data that tells the end rather than assuming 4K. Also they print in a consistent way with Linux stack traces.
2018-08-23 16:11:34 -04:00
fn printLineInfo(
run zig fmt on std lib and self hosted
2020-07-11 14:09:04 +03:00
out_stream: anytype,
introduce tool for dumping coverage file with debug info resolved. begin efforts of providing `std.debug.Info`, a cross-platform abstraction for loading debug information into an in-memory format that supports queries such as "what is the source location of this virtual memory address?" Unlike `std.debug.SelfInfo`, this API does not assume the debug information in question happens to match the host CPU architecture, OS, or other target properties.
2024-08-02 16:31:49 -07:00
source_location: ?SourceLocation,
MacOS stack traces use the already mmapped executable ...rather than trying to find the executable on the file system. Also use a more robust PIE offset calculation based on the available metadata. And for the last function, use the data that tells the end rather than assuming 4K. Also they print in a consistent way with Linux stack traces.
2018-08-23 16:11:34 -04:00
address: usize,
symbol_name: []const u8,
compile_unit_name: []const u8,
std: Move std.debug.{TTY.Config,detectTTYConfig} to std.io.tty Also get rid of the TTY wrapper struct, which was exlusively used as a namespace - this is done by the tty.zig root struct now. detectTTYConfig has been renamed to just detectConfig, which is enough given the new namespace. Additionally, a doc comment had been added.
2023-05-21 14:27:28 +01:00
tty_config: io.tty.Config,
run zig fmt on std lib and self hosted
2020-07-11 14:09:04 +03:00
comptime printLineFromFile: anytype,
MacOS stack traces use the already mmapped executable ...rather than trying to find the executable on the file system. Also use a more robust PIE offset calculation based on the available metadata. And for the last function, use the data that tells the end rather than assuming 4K. Also they print in a consistent way with Linux stack traces.
2018-08-23 16:11:34 -04:00
) !void {
zig fmt
2020-05-05 05:14:22 -06:00
nosuspend {
std.debug: Rename TTY.Color enum values to snake case
2023-05-20 22:30:02 +01:00
try tty_config.setColor(out_stream, .bold);
Refactor some code in the debug output
2020-01-21 20:51:57 +01:00
introduce tool for dumping coverage file with debug info resolved. begin efforts of providing `std.debug.Info`, a cross-platform abstraction for loading debug information into an in-memory format that supports queries such as "what is the source location of this virtual memory address?" Unlike `std.debug.SelfInfo`, this API does not assume the debug information in question happens to match the host CPU architecture, OS, or other target properties.
2024-08-02 16:31:49 -07:00
if (source_location) |*sl| {
try out_stream.print("{s}:{d}:{d}", .{ sl.file_name, sl.line, sl.column });
(breaking) rework stream abstractions The main goal here is to make the function pointers comptime, so that we don't have to do the crazy stuff with async function frames. Since InStream, OutStream, and SeekableStream are already generic across error sets, it's not really worse to make them generic across the vtable as well. See #764 for the open issue acknowledging that using generics for these abstractions is a design flaw. See #130 for the efforts to make these abstractions non-generic. This commit also changes the OutStream API so that `write` returns number of bytes written, and `writeAll` is the one that loops until the whole buffer is written.
2020-03-10 15:27:45 -04:00
} else {
try out_stream.writeAll("???:?:?");
}
std.debug: Rename TTY.Color enum values to snake case
2023-05-20 22:30:02 +01:00
try tty_config.setColor(out_stream, .reset);
(breaking) rework stream abstractions The main goal here is to make the function pointers comptime, so that we don't have to do the crazy stuff with async function frames. Since InStream, OutStream, and SeekableStream are already generic across error sets, it's not really worse to make them generic across the vtable as well. See #764 for the open issue acknowledging that using generics for these abstractions is a design flaw. See #130 for the efforts to make these abstractions non-generic. This commit also changes the OutStream API so that `write` returns number of bytes written, and `writeAll` is the one that loops until the whole buffer is written.
2020-03-10 15:27:45 -04:00
try out_stream.writeAll(": ");
std.debug: Rename TTY.Color enum values to snake case
2023-05-20 22:30:02 +01:00
try tty_config.setColor(out_stream, .dim);
std: Use {s} instead of {} when printing strings
2020-11-26 09:48:12 +01:00
try out_stream.print("0x{x} in {s} ({s})", .{ address, symbol_name, compile_unit_name });
std.debug: Rename TTY.Color enum values to snake case
2023-05-20 22:30:02 +01:00
try tty_config.setColor(out_stream, .reset);
(breaking) rework stream abstractions The main goal here is to make the function pointers comptime, so that we don't have to do the crazy stuff with async function frames. Since InStream, OutStream, and SeekableStream are already generic across error sets, it's not really worse to make them generic across the vtable as well. See #764 for the open issue acknowledging that using generics for these abstractions is a design flaw. See #130 for the efforts to make these abstractions non-generic. This commit also changes the OutStream API so that `write` returns number of bytes written, and `writeAll` is the one that loops until the whole buffer is written.
2020-03-10 15:27:45 -04:00
try out_stream.writeAll("\n");
// Show the matching source code line if possible
introduce tool for dumping coverage file with debug info resolved. begin efforts of providing `std.debug.Info`, a cross-platform abstraction for loading debug information into an in-memory format that supports queries such as "what is the source location of this virtual memory address?" Unlike `std.debug.SelfInfo`, this API does not assume the debug information in question happens to match the host CPU architecture, OS, or other target properties.
2024-08-02 16:31:49 -07:00
if (source_location) |sl| {
if (printLineFromFile(out_stream, sl)) {
if (sl.column > 0) {
(breaking) rework stream abstractions The main goal here is to make the function pointers comptime, so that we don't have to do the crazy stuff with async function frames. Since InStream, OutStream, and SeekableStream are already generic across error sets, it's not really worse to make them generic across the vtable as well. See #764 for the open issue acknowledging that using generics for these abstractions is a design flaw. See #130 for the efforts to make these abstractions non-generic. This commit also changes the OutStream API so that `write` returns number of bytes written, and `writeAll` is the one that loops until the whole buffer is written.
2020-03-10 15:27:45 -04:00
// The caret already takes one char
introduce tool for dumping coverage file with debug info resolved. begin efforts of providing `std.debug.Info`, a cross-platform abstraction for loading debug information into an in-memory format that supports queries such as "what is the source location of this virtual memory address?" Unlike `std.debug.SelfInfo`, this API does not assume the debug information in question happens to match the host CPU architecture, OS, or other target properties.
2024-08-02 16:31:49 -07:00
const space_needed = @as(usize, @intCast(sl.column - 1));
(breaking) rework stream abstractions The main goal here is to make the function pointers comptime, so that we don't have to do the crazy stuff with async function frames. Since InStream, OutStream, and SeekableStream are already generic across error sets, it's not really worse to make them generic across the vtable as well. See #764 for the open issue acknowledging that using generics for these abstractions is a design flaw. See #130 for the efforts to make these abstractions non-generic. This commit also changes the OutStream API so that `write` returns number of bytes written, and `writeAll` is the one that loops until the whole buffer is written.
2020-03-10 15:27:45 -04:00
try out_stream.writeByteNTimes(' ', space_needed);
std.debug: Rename TTY.Color enum values to snake case
2023-05-20 22:30:02 +01:00
try tty_config.setColor(out_stream, .green);
(breaking) rework stream abstractions The main goal here is to make the function pointers comptime, so that we don't have to do the crazy stuff with async function frames. Since InStream, OutStream, and SeekableStream are already generic across error sets, it's not really worse to make them generic across the vtable as well. See #764 for the open issue acknowledging that using generics for these abstractions is a design flaw. See #130 for the efforts to make these abstractions non-generic. This commit also changes the OutStream API so that `write` returns number of bytes written, and `writeAll` is the one that loops until the whole buffer is written.
2020-03-10 15:27:45 -04:00
try out_stream.writeAll("^");
std.debug: Rename TTY.Color enum values to snake case
2023-05-20 22:30:02 +01:00
try tty_config.setColor(out_stream, .reset);
(breaking) rework stream abstractions The main goal here is to make the function pointers comptime, so that we don't have to do the crazy stuff with async function frames. Since InStream, OutStream, and SeekableStream are already generic across error sets, it's not really worse to make them generic across the vtable as well. See #764 for the open issue acknowledging that using generics for these abstractions is a design flaw. See #130 for the efforts to make these abstractions non-generic. This commit also changes the OutStream API so that `write` returns number of bytes written, and `writeAll` is the one that loops until the whole buffer is written.
2020-03-10 15:27:45 -04:00
}
try out_stream.writeAll("\n");
} else |err| switch (err) {
error.EndOfFile, error.FileNotFound => {},
error.BadPathName => {},
debug: don't fail printLineInfo if the source file is not readable Without this dumping a stacktrace fails with this: Unable to dump stack trace: AccessDenied
2021-01-10 15:39:59 +01:00
error.AccessDenied => {},
(breaking) rework stream abstractions The main goal here is to make the function pointers comptime, so that we don't have to do the crazy stuff with async function frames. Since InStream, OutStream, and SeekableStream are already generic across error sets, it's not really worse to make them generic across the vtable as well. See #764 for the open issue acknowledging that using generics for these abstractions is a design flaw. See #130 for the efforts to make these abstractions non-generic. This commit also changes the OutStream API so that `write` returns number of bytes written, and `writeAll` is the one that loops until the whole buffer is written.
2020-03-10 15:27:45 -04:00
else => return err,
*WIP* proof of concept error return traces
2018-01-12 02:12:11 -05:00
}
MacOS stack traces use the already mmapped executable ...rather than trying to find the executable on the file system. Also use a more robust PIE offset calculation based on the available metadata. And for the last function, use the data that tells the end rather than assuming 4K. Also they print in a consistent way with Linux stack traces.
2018-08-23 16:11:34 -04:00
}
*WIP* proof of concept error return traces
2018-01-12 02:12:11 -05:00
}
}
introduce tool for dumping coverage file with debug info resolved. begin efforts of providing `std.debug.Info`, a cross-platform abstraction for loading debug information into an in-memory format that supports queries such as "what is the source location of this virtual memory address?" Unlike `std.debug.SelfInfo`, this API does not assume the debug information in question happens to match the host CPU architecture, OS, or other target properties.
2024-08-02 16:31:49 -07:00
fn printLineFromFileAnyOs(out_stream: anytype, source_location: SourceLocation) !void {
fix stack trace code not opening files in forced blocking mode
2020-03-10 19:28:05 -04:00
// 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.
introduce tool for dumping coverage file with debug info resolved. begin efforts of providing `std.debug.Info`, a cross-platform abstraction for loading debug information into an in-memory format that supports queries such as "what is the source location of this virtual memory address?" Unlike `std.debug.SelfInfo`, this API does not assume the debug information in question happens to match the host CPU architecture, OS, or other target properties.
2024-08-02 16:31:49 -07:00
var f = try fs.cwd().openFile(source_location.file_name, .{});
better stack traces for ELF x86_64
2017-04-24 12:01:19 -04:00
defer f.close();
// TODO fstat and make sure that the file has the correct size
runtime page size detection heap.zig: define new default page sizes heap.zig: add min/max_page_size and their options lib/std/c: add miscellaneous declarations heap.zig: add pageSize() and its options switch to new page sizes, especially in GPA/stdlib mem.zig: remove page_size
2024-10-20 14:55:57 -07:00
var buf: [4096]u8 = undefined;
std.debug: optimized printLineFromFileAnyOs (#18142) * std.debug: optimized printLineFromFileAnyOs Uses mem.indexOfScalar to speed line iteration instead of byte for byte. Also prints the whole line in a single write (or up to a page size at a time) Closes #18099 * add test cases for printLineFromFileAnyOs
2023-11-29 20:58:56 +01:00
var amt_read = try f.read(buf[0..]);
const line_start = seek: {
var current_line_start: usize = 0;
var next_line: usize = 1;
introduce tool for dumping coverage file with debug info resolved. begin efforts of providing `std.debug.Info`, a cross-platform abstraction for loading debug information into an in-memory format that supports queries such as "what is the source location of this virtual memory address?" Unlike `std.debug.SelfInfo`, this API does not assume the debug information in question happens to match the host CPU architecture, OS, or other target properties.
2024-08-02 16:31:49 -07:00
while (next_line != source_location.line) {
std.debug: optimized printLineFromFileAnyOs (#18142) * std.debug: optimized printLineFromFileAnyOs Uses mem.indexOfScalar to speed line iteration instead of byte for byte. Also prints the whole line in a single write (or up to a page size at a time) Closes #18099 * add test cases for printLineFromFileAnyOs
2023-11-29 20:58:56 +01:00
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;
better stack traces for ELF x86_64
2017-04-24 12:01:19 -04:00
}
std.debug: optimized printLineFromFileAnyOs (#18142) * std.debug: optimized printLineFromFileAnyOs Uses mem.indexOfScalar to speed line iteration instead of byte for byte. Also prints the whole line in a single write (or up to a page size at a time) Closes #18099 * add test cases for printLineFromFileAnyOs
2023-11-29 20:58:56 +01:00
}
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);
better stack traces for ELF x86_64
2017-04-24 12:01:19 -04:00
} else {
std.debug: optimized printLineFromFileAnyOs (#18142) * std.debug: optimized printLineFromFileAnyOs Uses mem.indexOfScalar to speed line iteration instead of byte for byte. Also prints the whole line in a single write (or up to a page size at a time) Closes #18099 * add test cases for printLineFromFileAnyOs
2023-11-29 20:58:56 +01:00
const line = buf[0..amt_read];
mem.replaceScalar(u8, line, '\t', ' ');
try out_stream.writeAll(line);
better stack traces for ELF x86_64
2017-04-24 12:01:19 -04:00
}
}
std.debug: optimized printLineFromFileAnyOs (#18142) * std.debug: optimized printLineFromFileAnyOs Uses mem.indexOfScalar to speed line iteration instead of byte for byte. Also prints the whole line in a single write (or up to a page size at a time) Closes #18099 * add test cases for printLineFromFileAnyOs
2023-11-29 20:58:56 +01:00
// Make sure printing last line of file inserts extra newline
try out_stream.writeByte('\n');
}
}
std: promote tests to doctests Now these show up as "example usage" in generated documentation.
2024-03-13 15:56:09 -07:00
test printLineFromFileAnyOs {
std.debug: optimized printLineFromFileAnyOs (#18142) * std.debug: optimized printLineFromFileAnyOs Uses mem.indexOfScalar to speed line iteration instead of byte for byte. Also prints the whole line in a single write (or up to a page size at a time) Closes #18099 * add test cases for printLineFromFileAnyOs
2023-11-29 20:58:56 +01:00
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();
std.debug: rename Info to SelfInfo This code has the hard-coded goal of supporting the executable's own debug information and makes design choices along that goal, such as memory-mapping the inputs, using dl_iterate_phdr, and doing conditional compilation on the host target. A more general-purpose implementation of debug information may be able to share code with this, but there are some fundamental incompatibilities. For example, the "SelfInfo" implementation wants to avoid bloating the binary with PDB on POSIX systems, and likewise DWARF on Windows systems, while a general-purpose implementation needs to support both PDB and DWARF from the same binary. It might, for example, inspect the debug information from a cross-compiled binary. `SourceLocation` now lives at `std.debug.SourceLocation` and is documented. Deprecate `std.debug.runtime_safety` because it returns the optimization mode of the standard library, when the caller probably wants to use the optimization mode of their own module. `std.pdb.Pdb` is moved to `std.debug.Pdb`, mirroring the recent extraction of `std.debug.Dwarf` from `std.dwarf`. I have no idea why we have both Module (with a Windows-specific definition) and WindowsModule. I left some passive aggressive doc comments to express my frustration.
2024-08-01 16:31:03 -07:00
// Relies on testing.tmpDir internals which is not ideal, but SourceLocation requires paths.
rename zig-cache to .zig-cache closes #20077
2024-05-29 10:20:15 -07:00
const test_dir_path = try join(allocator, &.{ ".zig-cache", "tmp", test_dir.sub_path[0..] });
std.debug: optimized printLineFromFileAnyOs (#18142) * std.debug: optimized printLineFromFileAnyOs Uses mem.indexOfScalar to speed line iteration instead of byte for byte. Also prints the whole line in a single write (or up to a page size at a time) Closes #18099 * add test cases for printLineFromFileAnyOs
2023-11-29 20:58:56 +01:00
defer allocator.free(test_dir_path);
// Cases
{
const path = try join(allocator, &.{ test_dir_path, "one_line.zig" });
defer allocator.free(path);
Rename Dir.writeFile2 -> Dir.writeFile and update all callsites writeFile was deprecated in favor of writeFile2 in f645022d16361865e24582d28f1e62312fbc73bb. This commit renames writeFile2 to writeFile and makes writeFile2 a compile error.
2024-05-02 20:54:48 -07:00
try test_dir.dir.writeFile(.{ .sub_path = "one_line.zig", .data = "no new lines in this file, but one is printed anyway" });
std.debug: optimized printLineFromFileAnyOs (#18142) * std.debug: optimized printLineFromFileAnyOs Uses mem.indexOfScalar to speed line iteration instead of byte for byte. Also prints the whole line in a single write (or up to a page size at a time) Closes #18099 * add test cases for printLineFromFileAnyOs
2023-11-29 20:58:56 +01:00
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);
Rename Dir.writeFile2 -> Dir.writeFile and update all callsites writeFile was deprecated in favor of writeFile2 in f645022d16361865e24582d28f1e62312fbc73bb. This commit renames writeFile2 to writeFile and makes writeFile2 a compile error.
2024-05-02 20:54:48 -07:00
try test_dir.dir.writeFile(.{
.sub_path = "three_lines.zig",
.data =
std.debug: optimized printLineFromFileAnyOs (#18142) * std.debug: optimized printLineFromFileAnyOs Uses mem.indexOfScalar to speed line iteration instead of byte for byte. Also prints the whole line in a single write (or up to a page size at a time) Closes #18099 * add test cases for printLineFromFileAnyOs
2023-11-29 20:58:56 +01:00
\\1
\\2
\\3
Rename Dir.writeFile2 -> Dir.writeFile and update all callsites writeFile was deprecated in favor of writeFile2 in f645022d16361865e24582d28f1e62312fbc73bb. This commit renames writeFile2 to writeFile and makes writeFile2 a compile error.
2024-05-02 20:54:48 -07:00
,
});
std.debug: optimized printLineFromFileAnyOs (#18142) * std.debug: optimized printLineFromFileAnyOs Uses mem.indexOfScalar to speed line iteration instead of byte for byte. Also prints the whole line in a single write (or up to a page size at a time) Closes #18099 * add test cases for printLineFromFileAnyOs
2023-11-29 20:58:56 +01:00
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();
adjust runtime page size APIs * fix merge conflicts * rename the declarations * reword documentation * extract FixedBufferAllocator to separate file * take advantage of locals * remove the assertion about max alignment in Allocator API, leaving it Allocator implementation defined * fix non-inline function call in start logic The GeneralPurposeAllocator implementation is totally broken because it uses global state but I didn't address that in this commit.
2025-01-29 14:16:25 -08:00
try writer.writeByteNTimes('a', std.heap.page_size_min - overlap);
std.debug: optimized printLineFromFileAnyOs (#18142) * std.debug: optimized printLineFromFileAnyOs Uses mem.indexOfScalar to speed line iteration instead of byte for byte. Also prints the whole line in a single write (or up to a page size at a time) Closes #18099 * add test cases for printLineFromFileAnyOs
2023-11-29 20:58:56 +01:00
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();
adjust runtime page size APIs * fix merge conflicts * rename the declarations * reword documentation * extract FixedBufferAllocator to separate file * take advantage of locals * remove the assertion about max alignment in Allocator API, leaving it Allocator implementation defined * fix non-inline function call in start logic The GeneralPurposeAllocator implementation is totally broken because it uses global state but I didn't address that in this commit.
2025-01-29 14:16:25 -08:00
try writer.writeByteNTimes('a', std.heap.page_size_max);
std.debug: optimized printLineFromFileAnyOs (#18142) * std.debug: optimized printLineFromFileAnyOs Uses mem.indexOfScalar to speed line iteration instead of byte for byte. Also prints the whole line in a single write (or up to a page size at a time) Closes #18099 * add test cases for printLineFromFileAnyOs
2023-11-29 20:58:56 +01:00
try printLineFromFileAnyOs(output_stream, .{ .file_name = path, .line = 1, .column = 0 });
adjust runtime page size APIs * fix merge conflicts * rename the declarations * reword documentation * extract FixedBufferAllocator to separate file * take advantage of locals * remove the assertion about max alignment in Allocator API, leaving it Allocator implementation defined * fix non-inline function call in start logic The GeneralPurposeAllocator implementation is totally broken because it uses global state but I didn't address that in this commit.
2025-01-29 14:16:25 -08:00
try expectEqualStrings(("a" ** std.heap.page_size_max) ++ "\n", output.items);
std.debug: optimized printLineFromFileAnyOs (#18142) * std.debug: optimized printLineFromFileAnyOs Uses mem.indexOfScalar to speed line iteration instead of byte for byte. Also prints the whole line in a single write (or up to a page size at a time) Closes #18099 * add test cases for printLineFromFileAnyOs
2023-11-29 20:58:56 +01:00
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();
adjust runtime page size APIs * fix merge conflicts * rename the declarations * reword documentation * extract FixedBufferAllocator to separate file * take advantage of locals * remove the assertion about max alignment in Allocator API, leaving it Allocator implementation defined * fix non-inline function call in start logic The GeneralPurposeAllocator implementation is totally broken because it uses global state but I didn't address that in this commit.
2025-01-29 14:16:25 -08:00
try writer.writeByteNTimes('a', 3 * std.heap.page_size_max);
std.debug: optimized printLineFromFileAnyOs (#18142) * std.debug: optimized printLineFromFileAnyOs Uses mem.indexOfScalar to speed line iteration instead of byte for byte. Also prints the whole line in a single write (or up to a page size at a time) Closes #18099 * add test cases for printLineFromFileAnyOs
2023-11-29 20:58:56 +01:00
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 });
adjust runtime page size APIs * fix merge conflicts * rename the declarations * reword documentation * extract FixedBufferAllocator to separate file * take advantage of locals * remove the assertion about max alignment in Allocator API, leaving it Allocator implementation defined * fix non-inline function call in start logic The GeneralPurposeAllocator implementation is totally broken because it uses global state but I didn't address that in this commit.
2025-01-29 14:16:25 -08:00
try expectEqualStrings(("a" ** (3 * std.heap.page_size_max)) ++ "\n", output.items);
std.debug: optimized printLineFromFileAnyOs (#18142) * std.debug: optimized printLineFromFileAnyOs Uses mem.indexOfScalar to speed line iteration instead of byte for byte. Also prints the whole line in a single write (or up to a page size at a time) Closes #18099 * add test cases for printLineFromFileAnyOs
2023-11-29 20:58:56 +01:00
output.clearRetainingCapacity();
try writer.writeAll("a\na");
try printLineFromFileAnyOs(output_stream, .{ .file_name = path, .line = 1, .column = 0 });
adjust runtime page size APIs * fix merge conflicts * rename the declarations * reword documentation * extract FixedBufferAllocator to separate file * take advantage of locals * remove the assertion about max alignment in Allocator API, leaving it Allocator implementation defined * fix non-inline function call in start logic The GeneralPurposeAllocator implementation is totally broken because it uses global state but I didn't address that in this commit.
2025-01-29 14:16:25 -08:00
try expectEqualStrings(("a" ** (3 * std.heap.page_size_max)) ++ "a\n", output.items);
std.debug: optimized printLineFromFileAnyOs (#18142) * std.debug: optimized printLineFromFileAnyOs Uses mem.indexOfScalar to speed line iteration instead of byte for byte. Also prints the whole line in a single write (or up to a page size at a time) Closes #18099 * add test cases for printLineFromFileAnyOs
2023-11-29 20:58:56 +01:00
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();
adjust runtime page size APIs * fix merge conflicts * rename the declarations * reword documentation * extract FixedBufferAllocator to separate file * take advantage of locals * remove the assertion about max alignment in Allocator API, leaving it Allocator implementation defined * fix non-inline function call in start logic The GeneralPurposeAllocator implementation is totally broken because it uses global state but I didn't address that in this commit.
2025-01-29 14:16:25 -08:00
const real_file_start = 3 * std.heap.page_size_min;
std.debug: optimized printLineFromFileAnyOs (#18142) * std.debug: optimized printLineFromFileAnyOs Uses mem.indexOfScalar to speed line iteration instead of byte for byte. Also prints the whole line in a single write (or up to a page size at a time) Closes #18099 * add test cases for printLineFromFileAnyOs
2023-11-29 20:58:56 +01:00
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();
better stack traces for ELF x86_64
2017-04-24 12:01:19 -04:00
std.debug: optimized printLineFromFileAnyOs (#18142) * std.debug: optimized printLineFromFileAnyOs Uses mem.indexOfScalar to speed line iteration instead of byte for byte. Also prints the whole line in a single write (or up to a page size at a time) Closes #18099 * add test cases for printLineFromFileAnyOs
2023-11-29 20:58:56 +01:00
try printLineFromFileAnyOs(output_stream, .{ .file_name = path, .line = real_file_start + 2, .column = 0 });
try expectEqualStrings("def\n", output.items);
output.clearRetainingCapacity();
better stack traces for ELF x86_64
2017-04-24 12:01:19 -04:00
}
}
MacOS stack traces use the already mmapped executable ...rather than trying to find the executable on the file system. Also use a more robust PIE offset calculation based on the available metadata. And for the last function, use the data that tells the end rather than assuming 4K. Also they print in a consistent way with Linux stack traces.
2018-08-23 16:11:34 -04:00
/// TODO multithreaded awareness
allocgate: std Allocator interface refactor
2021-10-29 00:37:25 +01:00
var debug_info_allocator: ?mem.Allocator = null;
std.debug: dumpStackTrace & friends use DirectAllocator this has the downside of failing to print a stack trace when the system is out of memory (maybe we could add a FallbackAllocator which tries DirectAllocator and falls back on the 200KB preallocated buffer). but for the more common use case when the system is not out of memory, but the debug info cannot fit in std.debug.global_allocator, now stack traces will work. this is the case for the self hosted compiler.
2018-04-15 20:15:19 -04:00
var debug_info_arena_allocator: std.heap.ArenaAllocator = undefined;
allocgate: std Allocator interface refactor
2021-10-29 00:37:25 +01:00
fn getDebugInfoAllocator() mem.Allocator {
std.debug: dumpStackTrace & friends use DirectAllocator this has the downside of failing to print a stack trace when the system is out of memory (maybe we could add a FallbackAllocator which tries DirectAllocator and falls back on the 200KB preallocated buffer). but for the more common use case when the system is not out of memory, but the debug info cannot fit in std.debug.global_allocator, now stack traces will work. this is the case for the self hosted compiler.
2018-04-15 20:15:19 -04:00
if (debug_info_allocator) |a| return a;
rename std.heap.direct_allocator to std.heap.page_allocator std.heap.direct_allocator is still available for now but it is marked deprecated.
2019-11-25 17:25:06 -05:00
debug_info_arena_allocator = std.heap.ArenaAllocator.init(std.heap.page_allocator);
allocgate: renamed getAllocator function to allocator
2021-10-29 02:08:41 +01:00
const allocator = debug_info_arena_allocator.allocator();
allocgate: std Allocator interface refactor
2021-10-29 00:37:25 +01:00
debug_info_allocator = allocator;
return allocator;
std.debug: dumpStackTrace & friends use DirectAllocator this has the downside of failing to print a stack trace when the system is out of memory (maybe we could add a FallbackAllocator which tries DirectAllocator and falls back on the 200KB preallocated buffer). but for the more common use case when the system is not out of memory, but the debug info cannot fit in std.debug.global_allocator, now stack traces will work. this is the case for the self hosted compiler.
2018-04-15 20:15:19 -04:00
}
stack traces on segfault by default for linux-x86_64 closes #2355
2019-07-02 13:27:40 -04:00
/// Whether or not the current target can print useful debug information when a segfault occurs.
std: change `@import("builtin")` to `std.builtin`
2021-04-12 16:43:50 -07:00
pub const have_segfault_handling_support = switch (native_os) {
debug: implement segfault handler for macOS aarch64 Tested on a M1 MacBook Pro, macOS Monterey 12.2.
2022-02-07 18:20:33 +01:00
.linux,
.macos,
.netbsd,
.solaris,
Add illumos OS tag - Adds `illumos` to the `Target.Os.Tag` enum. A new function, `isSolarish` has been added that returns true if the tag is either Solaris or Illumos. This matches the naming convention found in Rust's `libc` crate[1]. - Add the tag wherever `.solaris` is being checked against. - Check for the C pre-processor macro `__illumos__` in CMake to set the proper target tuple. Illumos distros patch their compilers to have this in the "built-in" set (verified with `echo | cc -dM -E -`). Alternatively you could check the output of `uname -o`. Right now, both Solaris and Illumos import from `c/solaris.zig`. In the future it may be worth putting the shared ABI bits in a base file, and mixing that in with specific `c/solaris.zig`/`c/illumos.zig` files. [1]: https://github.com/rust-lang/libc/tree/6e02a329a2a27f6887ea86952f389ca11e06448c/src/unix/solarish
2023-10-01 23:09:14 +11:00
.illumos,
debug: implement segfault handler for macOS aarch64 Tested on a M1 MacBook Pro, macOS Monterey 12.2.
2022-02-07 18:20:33 +01:00
.windows,
=> true,
std.c reorganization It is now composed of these main sections: * Declarations that are shared among all operating systems. * Declarations that have the same name, but different type signatures depending on the operating system. Often multiple operating systems share the same type signatures however. * Declarations that are specific to a single operating system. - These are imported one per line so you can see where they come from, protected by a comptime block to prevent accessing the wrong one. Closes #19352 by changing the convention to making types `void` and functions `{}`, so that it becomes possible to update `@hasDecl` sites to use `@TypeOf(f) != void` or `T != void`. Happily, this ended up removing some duplicate logic and update some bitrotted feature detection checks. A handful of types have been modified to gain namespacing and type safety. This is a breaking change. Oh, and the last usage of `usingnamespace` site is eliminated.
2024-07-18 23:35:19 -07:00
.freebsd, .openbsd => have_ucontext,
std: Fix more NetBSD bits Fix some more libc definitions.
2020-04-01 11:03:36 +02:00
else => false,
};
std: collect all options under one namespace
2023-01-03 19:37:11 +02:00
const enable_segfault_handler = std.options.enable_segfault_handler;
pub const default_enable_segfault_handler = runtime_safety and have_segfault_handling_support;
disable segfault handler when panicking this prevents a segfault in stack trace printing to activate the segfault handler.
2019-07-22 12:15:16 -04:00
pub fn maybeEnableSegfaultHandler() void {
if (enable_segfault_handler) {
remove formatted panics implements #17969
2024-09-25 11:11:48 -07:00
attachSegfaultHandler();
disable segfault handler when panicking this prevents a segfault in stack trace printing to activate the segfault handler.
2019-07-22 12:15:16 -04:00
}
}
var windows_segfault_handle: ?windows.HANDLE = null;
stack traces on segfault by default for linux-x86_64 closes #2355
2019-07-02 13:27:40 -04:00
std.posix: Consider invalid signal numbers to sigaction() to be programmer error. The set of signals that cannot have their action changed is documented in POSIX, and any additional, non-standard signals are documented by the specific OS. I see no valid reason why EINVAL should be considered an unpredictable error here.
2024-07-21 13:31:06 +02:00
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);
fix sigaction double panic Fixes #8357
2022-01-21 10:14:44 +01:00
}
Fix simple doc mistakes. (#17624) * Add missing period in Stack's description This looks fine in the source, but looks bad when seen on the documentation website. * Correct documentation for attachSegfaultHandler() The description for attachSegfaultHandler() looks pretty bad without indicating that the stuff at the end is code * Added missing 'the's in Queue.put's documentation * Fixed several errors in Stack's documentation `push()` and `pop()` were not styled as code There was no period after `pop()`, which looks bad on the documentation. * Fix multiple problems in base64.zig Both "invalid"s in Base64.decoder were not capitalized. Missing period in documentation of Base64DecoderWithIgnore.calcSizeUpperBound. * Fix capitalization typos in bit_set.zig In DynamicBitSetUnmanaged.deinit's and DynamicBitSet.deinit's documentation, "deinitializes" was uncapitalized. * Fix typos in fifo.zig's documentation Added a previously missing period to the end of the first line of LinearFifo.writableSlice's documentation. Added missing periods to both lines of LinearFifo.pump's documentation. * Fix typos in fmt.bufPrint's documentation The starts of both lines were not capitalized. * Fix minor documentation problems in fs/file.zig Missing periods in documentation for Permissions.setReadOnly, PermissionsWindows.setReadOnly, MetadataUnix.created, MetadataLinux.created, and MetadataWindows.created. * Fix a glaring typo in enums.zig * Correct errors in fs.zig * Fixed documentation problems in hash_map.zig The added empty line in verify_context's documentation is needed, otherwise autodoc for some reason assumes that the list hasn't been terminated and continues reading off the rest of the documentation as if it were part of the second list item. * Added lines between consecutive URLs in http.zig Makes the documentation conform closer to what was intended. * Fix wrongfully ended sentence in Uri.zig * Handle wrongly entered comma in valgrind.zig. * Add missing periods in wasm.zig's documentation * Fix odd spacing in event/loop.zig * Add missing period in http/Headers.zig * Added missing period in io/limited_reader.zig This isn't in the documentation due to what I guess is a limitation of autodoc, but it's clearly supposed to be. If it was, it would look pretty bad. * Correct documentation in math/big/int.zig * Correct formatting in math/big/rational.zig * Create an actual link to ZIGNOR's paper. * Fixed grammatical issues in sort/block.zig This will not show up in the documentation currently. * Fix typo in hash_map.zig
2023-10-21 17:24:55 -04:00
/// Attaches a global SIGSEGV handler which calls `@panic("segmentation fault");`
stack traces on segfault by default for linux-x86_64 closes #2355
2019-07-02 13:27:40 -04:00
pub fn attachSegfaultHandler() void {
if (!have_segfault_handling_support) {
@compileError("segfault handler not supported for this target");
}
std: change `@import("builtin")` to `std.builtin`
2021-04-12 16:43:50 -07:00
if (native_os == .windows) {
disable segfault handler when panicking this prevents a segfault in stack trace printing to activate the segfault handler.
2019-07-22 12:15:16 -04:00
windows_segfault_handle = windows.kernel32.AddVectoredExceptionHandler(0, handleSegfaultWindows);
return;
added segfault handler support for windows
2019-07-03 10:16:52 -05:00
}
sigset_t: sigemptyset() and sigfillset() are functions that return sigset_t By returning an initialized sigset (instead of taking the set as an output parameter), these functions can be used to directly initialize the `mask` parameter of a `Sigaction` instance.
2025-04-22 14:19:06 -07:00
const act = posix.Sigaction{
Implement segfault handler for macOS x86_64
2022-01-17 17:46:48 +01:00
.handler = .{ .sigaction = handleSegfaultPosix },
sigset_t: sigemptyset() and sigfillset() are functions that return sigset_t By returning an initialized sigset (instead of taking the set as an output parameter), these functions can be used to directly initialize the `mask` parameter of a `Sigaction` instance.
2025-04-22 14:19:06 -07:00
.mask = posix.sigemptyset(),
extract std.posix from std.os closes #5019
2024-03-18 22:39:59 -07:00
.flags = (posix.SA.SIGINFO | posix.SA.RESTART | posix.SA.RESETHAND),
disable segfault handler when panicking this prevents a segfault in stack trace printing to activate the segfault handler.
2019-07-22 12:15:16 -04:00
};
std.posix: Consider invalid signal numbers to sigaction() to be programmer error. The set of signals that cannot have their action changed is documented in POSIX, and any additional, non-standard signals are documented by the specific OS. I see no valid reason why EINVAL should be considered an unpredictable error here.
2024-07-21 13:31:06 +02:00
updateSegfaultHandler(&act);
stack traces on segfault by default for linux-x86_64 closes #2355
2019-07-02 13:27:40 -04:00
}
disable segfault handler when panicking this prevents a segfault in stack trace printing to activate the segfault handler.
2019-07-22 12:15:16 -04:00
fn resetSegfaultHandler() void {
std: change `@import("builtin")` to `std.builtin`
2021-04-12 16:43:50 -07:00
if (native_os == .windows) {
disable segfault handler when panicking this prevents a segfault in stack trace printing to activate the segfault handler.
2019-07-22 12:15:16 -04:00
if (windows_segfault_handle) |handle| {
assert(windows.kernel32.RemoveVectoredExceptionHandler(handle) != 0);
windows_segfault_handle = null;
}
return;
}
sigset_t: sigemptyset() and sigfillset() are functions that return sigset_t By returning an initialized sigset (instead of taking the set as an output parameter), these functions can be used to directly initialize the `mask` parameter of a `Sigaction` instance.
2025-04-22 14:19:06 -07:00
const act = posix.Sigaction{
extract std.posix from std.os closes #5019
2024-03-18 22:39:59 -07:00
.handler = .{ .handler = posix.SIG.DFL },
sigset_t: sigemptyset() and sigfillset() are functions that return sigset_t By returning an initialized sigset (instead of taking the set as an output parameter), these functions can be used to directly initialize the `mask` parameter of a `Sigaction` instance.
2025-04-22 14:19:06 -07:00
.mask = posix.sigemptyset(),
stack traces on segfault by default for linux-x86_64 closes #2355
2019-07-02 13:27:40 -04:00
.flags = 0,
};
std.posix: Consider invalid signal numbers to sigaction() to be programmer error. The set of signals that cannot have their action changed is documented in POSIX, and any additional, non-standard signals are documented by the specific OS. I see no valid reason why EINVAL should be considered an unpredictable error here.
2024-07-21 13:31:06 +02:00
updateSegfaultHandler(&act);
disable segfault handler when panicking this prevents a segfault in stack trace printing to activate the segfault handler.
2019-07-22 12:15:16 -04:00
}
all: update to `std.builtin.Type.Pointer.Size` field renames This was done by regex substitution with `sed`. I then manually went over the entire diff and fixed any incorrect changes. This diff also changes a lot of `callconv(.C)` to `callconv(.c)`, since my regex happened to also trigger here. I opted to leave these changes in, since they *are* a correct migration, even if they're not the one I was trying to do!
2025-01-15 17:53:05 +00:00
fn handleSegfaultPosix(sig: i32, info: *const posix.siginfo_t, ctx_ptr: ?*anyopaque) callconv(.c) noreturn {
disable segfault handler when panicking this prevents a segfault in stack trace printing to activate the segfault handler.
2019-07-22 12:15:16 -04:00
// 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();
stack traces on segfault by default for linux-x86_64 closes #2355
2019-07-02 13:27:40 -04:00
std: change `@import("builtin")` to `std.builtin`
2021-04-12 16:43:50 -07:00
const addr = switch (native_os) {
all: zig fmt and rename "@XToY" to "@YFromX" Signed-off-by: Eric Joldasov <bratishkaerik@getgoogleoff.me>
2023-06-15 13:14:16 +06:00
.linux => @intFromPtr(info.fields.sigfault.addr),
.freebsd, .macos => @intFromPtr(info.addr),
.netbsd => @intFromPtr(info.info.reason.fault.addr),
.openbsd => @intFromPtr(info.data.fault.addr),
Add illumos OS tag - Adds `illumos` to the `Target.Os.Tag` enum. A new function, `isSolarish` has been added that returns true if the tag is either Solaris or Illumos. This matches the naming convention found in Rust's `libc` crate[1]. - Add the tag wherever `.solaris` is being checked against. - Check for the C pre-processor macro `__illumos__` in CMake to set the proper target tuple. Illumos distros patch their compilers to have this in the "built-in" set (verified with `echo | cc -dM -E -`). Alternatively you could check the output of `uname -o`. Right now, both Solaris and Illumos import from `c/solaris.zig`. In the future it may be worth putting the shared ABI bits in a base file, and mixing that in with specific `c/solaris.zig`/`c/illumos.zig` files. [1]: https://github.com/rust-lang/libc/tree/6e02a329a2a27f6887ea86952f389ca11e06448c/src/unix/solarish
2023-10-01 23:09:14 +11:00
.solaris, .illumos => @intFromPtr(info.reason.fault.addr),
std: Fix more NetBSD bits Fix some more libc definitions.
2020-04-01 11:03:36 +02:00
else => unreachable,
};
std: Avoid deadlock in the signal handler stderr_mutex may still be held when we reach the signal handler, grab our own stderr handle to print the error messages and avoid deadlocking. Closes #7247
2020-11-28 15:31:26 +01:00
bsd: debitrot atomic and debug closes #18119
2023-11-26 02:06:54 -05:00
const code = if (native_os == .netbsd) info.info.code else info.code;
std.debug: fix segfault/panic race condition closes #7859 closes #12207
2023-04-08 08:36:31 -07:00
nosuspend switch (panic_stage) {
0 => {
panic_stage = 1;
std.builtin: make atomic order fields lowercase
2024-02-18 21:52:23 -08:00
_ = panicking.fetchAdd(1, .seq_cst);
std.debug: fix segfault/panic race condition closes #7859 closes #12207
2023-04-08 08:36:31 -07:00
{
std.debug: lock stderr mutex when panicking The doc comments for this global said: "Locked to avoid interleaving panic messages from multiple threads." Huh? There's already a mutex for that, it's the stderr mutex. Lock that one instead.
2024-06-11 15:14:06 -07:00
lockStdErr();
defer unlockStdErr();
std.debug: fix segfault/panic race condition closes #7859 closes #12207
2023-04-08 08:36:31 -07:00
bsd: debitrot atomic and debug closes #18119
2023-11-26 02:06:54 -05:00
dumpSegfaultInfoPosix(sig, code, addr, ctx_ptr);
std.debug: fix segfault/panic race condition closes #7859 closes #12207
2023-04-08 08:36:31 -07:00
}
waitForOtherThreadToFinishPanicking();
},
else => {
// panic mutex already locked
bsd: debitrot atomic and debug closes #18119
2023-11-26 02:06:54 -05:00
dumpSegfaultInfoPosix(sig, code, addr, ctx_ptr);
std.debug: fix segfault/panic race condition closes #7859 closes #12207
2023-04-08 08:36:31 -07:00
},
};
// 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.
extract std.posix from std.os closes #5019
2024-03-18 22:39:59 -07:00
posix.abort();
std.debug: fix segfault/panic race condition closes #7859 closes #12207
2023-04-08 08:36:31 -07:00
}
std.debug: reorg and clarify API goals After this commit: `std.debug.SelfInfo` is a cross-platform abstraction for the current executable's own debug information, with a goal of minimal code bloat and compilation speed penalty. `std.debug.Dwarf` does not assume the current executable is itself the thing being debugged, however, it does assume the debug info has the same CPU architecture and OS as the current executable. It is planned to remove this limitation.
2024-08-01 22:04:40 -07:00
fn dumpSegfaultInfoPosix(sig: i32, code: i32, addr: usize, ctx_ptr: ?*anyopaque) void {
std.debug: fix segfault/panic race condition closes #7859 closes #12207
2023-04-08 08:36:31 -07:00
const stderr = io.getStdErr().writer();
_ = switch (sig) {
extract std.posix from std.os closes #5019
2024-03-18 22:39:59 -07:00
posix.SIG.SEGV => if (native_arch == .x86_64 and native_os == .linux and code == 128) // SI_KERNEL
std.debug: detect general protection faults on x86_64-linux ```zig const std = @import("std"); pub fn main() !void { var addr: *u8 = @ptrFromInt(0xaaaaaaaaaaaaaaaa); addr.* = 1; } ``` On x86_64-linux: Before: ``` $ zig run x.zig Segmentation fault at address 0x0 /home/wooster/Desktop/zig/x.zig:5:5: 0x21d887 in main (x) addr.* = 1; ^ /home/wooster/Desktop/zig-linux-x86_64/lib/std/start.zig:583:37: 0x21d847 in posixCallMainAndExit (x) const result = root.main() catch |err| { ^ /home/wooster/Desktop/zig-linux-x86_64/lib/std/start.zig:251:5: 0x21d371 in _start (x) asm volatile (switch (native_arch) { ^ ???:?:?: 0x0 in ??? (???) Aborted (core dumped) ``` After: ``` $ zig run x.zig --zig-lib-dir lib General protection exception /home/wooster/Desktop/zig/x.zig:5:5: 0x21d907 in main (x) addr.* = 1; ^ /home/wooster/Desktop/zig/lib/std/start.zig:583:37: 0x21d8c7 in posixCallMainAndExit (x) const result = root.main() catch |err| { ^ /home/wooster/Desktop/zig/lib/std/start.zig:251:5: 0x21d3f1 in _start (x) asm volatile (switch (native_arch) { ^ ???:?:?: 0x0 in ??? (???) Aborted (core dumped) ``` As @IntegratedQuantum pointed out in <https://github.com/ziglang/zig/issues/17745#issuecomment-1783815386>, it seems that if `code` of the `siginfo_t` instance is a certain value (128), you are able to distinguish between a general protection exception and a segmentation fault. This does not seem to be documented on `man sigaction`: ``` The following values can be placed in si_code for a SIGSEGV signal: SEGV_MAPERR Address not mapped to object. SEGV_ACCERR Invalid permissions for mapped object. SEGV_BNDERR (since Linux 3.19) Failed address bound checks. SEGV_PKUERR (since Linux 4.6) Access was denied by memory protection keys. See pkeys(7). The protection key which applied to this access is available via si_pkey. ``` (those constants are 1, 2, 3, and 4; none of them are the 128) I can't find a lot of documentation about this but it seems to work consistently for me on x86_64-linux. Here is a gist which provides additional evidence that this is a reliable way of checking for a general protection fault: https://gist.github.com/ytoshima/5682393 (read comment in first line) See also: https://stackoverflow.com/questions/64309366/why-is-the-segfault-address-null-when-accessing-memory-that-has-any-of-the-16-mo This only seems to affect x86_64 and on 32-bit x86 this does not seem to be a problem. Helps with #17745 but doesn't close it because the issue still exists on Windows and other POSIX OSs. I also limited this to x86_64-linux for now because that's the only platform where I tested it. Might work on more POSIX OSs.
2023-10-29 19:21:32 +01:00
// 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}),
extract std.posix from std.os closes #5019
2024-03-18 22:39:59 -07:00
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}),
std.debug: fix segfault/panic race condition closes #7859 closes #12207
2023-04-08 08:36:31 -07:00
else => unreachable,
extract std.posix from std.os closes #5019
2024-03-18 22:39:59 -07:00
} catch posix.abort();
std: Avoid deadlock in the signal handler stderr_mutex may still be held when we reach the signal handler, grab our own stderr handle to print the error messages and avoid deadlocking. Closes #7247
2020-11-28 15:31:26 +01:00
std: change `@import("builtin")` to `std.builtin`
2021-04-12 16:43:50 -07:00
switch (native_arch) {
- rework StackIterator to optionally use debug_info to unwind the stack - add abi routines for getting register values - unwding is working!
2023-05-15 01:52:53 -04:00
.x86,
.x86_64,
.arm,
std.debug: Add handling for armeb, thumb, thumbeb, and aarch64_be.
2024-11-04 08:29:18 +01:00
.armeb,
.thumb,
.thumbeb,
- rework StackIterator to optionally use debug_info to unwind the stack - add abi routines for getting register values - unwding is working!
2023-05-15 01:52:53 -04:00
.aarch64,
std.debug: Add handling for armeb, thumb, thumbeb, and aarch64_be.
2024-11-04 08:29:18 +01:00
.aarch64_be,
- rework StackIterator to optionally use debug_info to unwind the stack - add abi routines for getting register values - unwding is working!
2023-05-15 01:52:53 -04:00
=> {
std.debug: reorg and clarify API goals After this commit: `std.debug.SelfInfo` is a cross-platform abstraction for the current executable's own debug information, with a goal of minimal code bloat and compilation speed penalty. `std.debug.Dwarf` does not assume the current executable is itself the thing being debugged, however, it does assume the debug info has the same CPU architecture and OS as the current executable. It is planned to remove this limitation.
2024-08-01 22:04:40 -07:00
const ctx: *posix.ucontext_t = @ptrCast(@alignCast(ctx_ptr));
- rework StackIterator to optionally use debug_info to unwind the stack - add abi routines for getting register values - unwding is working!
2023-05-15 01:52:53 -04:00
dumpStackTraceFromBase(ctx);
Correct signal bits for MIPS Also enable the segfault handler for all the supported architectures beside MIPS.
2019-10-01 15:57:38 +02:00
},
else => {},
}
stack traces on segfault by default for linux-x86_64 closes #2355
2019-07-02 13:27:40 -04:00
}
added segfault handler support for windows
2019-07-03 10:16:52 -05:00
std.os.windows: Deprecate WINAPI in favor of CallingConvention.winapi.
2024-11-01 01:06:45 +01:00
fn handleSegfaultWindows(info: *windows.EXCEPTION_POINTERS) callconv(.winapi) c_long {
added segfault handler support for windows
2019-07-03 10:16:52 -05:00
switch (info.ExceptionRecord.ExceptionCode) {
Add an advanced segfault handler on windows
2020-01-29 16:57:43 +02:00
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"),
added segfault handler support for windows
2019-07-03 10:16:52 -05:00
else => return windows.EXCEPTION_CONTINUE_SEARCH,
}
}
improvements targeted at improving async functions * Reuse bytes of async function frames when non-async functions make `noasync` calls. This prevents explosive stack growth. * Zig now passes a stack size argument to the linker when linking ELF binaries. Linux ignores this value, but it is available as a program header called GNU_STACK. I prototyped some code that memory maps extra space to the stack using this program header, but there was still a problem when accessing stack memory very far down. Stack probing is needed or not working or something. I also prototyped using `@newStackCall` to call main and that does work around the issue but it also brings its own issues. That code is commented out for now in std/special/start.zig. I'm on a plane with no Internet, but I plan to consult with the musl community for advice when I get a chance. * Added `noasync` to a bunch of function calls in std.debug. It's very messy but it's a workaround that makes stack traces functional with evented I/O enabled. Eventually these will be cleaned up as the root bugs are found and fixed. Programs built in blocking mode are unaffected. * Lowered the default stack size of std.io.InStream (for the async version) to 1 MiB instead of 4. Until we figure out how to get choosing a stack size working (see 2nd bullet point above), 4 MiB tends to cause segfaults due to stack size running out, or usage of stack memory too far apart, or something like that. * Default thread stack size is bumped from 8 MiB to 16 to match the size we give for the main thread. It's planned to eventually remove this hard coded value and have Zig able to determine this value during semantic analysis, with call graph analysis and function pointer annotations and extern function annotations.
2019-09-11 20:22:49 -04:00
remove formatted panics implements #17969
2024-09-25 11:11:48 -07:00
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();
std.debug: fix segfault/panic race condition closes #7859 closes #12207
2023-04-08 08:36:31 -07:00
dumpSegfaultInfoWindows(info, msg, label);
remove formatted panics implements #17969
2024-09-25 11:11:48 -07:00
}
waitForOtherThreadToFinishPanicking();
},
1 => {
panic_stage = 2;
io.getStdErr().writeAll("aborting due to recursive panic\n") catch {};
},
else => {},
};
posix.abort();
Add an advanced segfault handler on windows
2020-01-29 16:57:43 +02:00
}
std.debug: fix segfault/panic race condition closes #7859 closes #12207
2023-04-08 08:36:31 -07:00
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]}),
debug: x86 unwinding support, more unwinding fixes - Fix unwindFrame using the previous FDE row instead of the current one - Handle unwinding through noreturn functions - Add x86-linux getcontext - Fixup x86_64-linux getcontext not restoring the fp env - Fix start_addr filtering on x86-windows
2023-06-27 02:02:49 -04:00
2 => stderr.print("Illegal instruction at address 0x{x}\n", .{info.ContextRecord.getRegs().ip}),
std.debug: fix segfault/panic race condition closes #7859 closes #12207
2023-04-08 08:36:31 -07:00
else => unreachable,
extract std.posix from std.os closes #5019
2024-03-18 22:39:59 -07:00
} catch posix.abort();
std.debug: fix segfault/panic race condition closes #7859 closes #12207
2023-04-08 08:36:31 -07:00
debug: x86 unwinding support, more unwinding fixes - Fix unwindFrame using the previous FDE row instead of the current one - Handle unwinding through noreturn functions - Add x86-linux getcontext - Fixup x86_64-linux getcontext not restoring the fp env - Fix start_addr filtering on x86-windows
2023-06-27 02:02:49 -04:00
dumpStackTraceFromBase(info.ContextRecord);
std.debug: fix segfault/panic race condition closes #7859 closes #12207
2023-04-08 08:36:31 -07:00
}
improvements targeted at improving async functions * Reuse bytes of async function frames when non-async functions make `noasync` calls. This prevents explosive stack growth. * Zig now passes a stack size argument to the linker when linking ELF binaries. Linux ignores this value, but it is available as a program header called GNU_STACK. I prototyped some code that memory maps extra space to the stack using this program header, but there was still a problem when accessing stack memory very far down. Stack probing is needed or not working or something. I also prototyped using `@newStackCall` to call main and that does work around the issue but it also brings its own issues. That code is commented out for now in std/special/start.zig. I'm on a plane with no Internet, but I plan to consult with the musl community for advice when I get a chance. * Added `noasync` to a bunch of function calls in std.debug. It's very messy but it's a workaround that makes stack traces functional with evented I/O enabled. Eventually these will be cleaned up as the root bugs are found and fixed. Programs built in blocking mode are unaffected. * Lowered the default stack size of std.io.InStream (for the async version) to 1 MiB instead of 4. Until we figure out how to get choosing a stack size working (see 2nd bullet point above), 4 MiB tends to cause segfaults due to stack size running out, or usage of stack memory too far apart, or something like that. * Default thread stack size is bumped from 8 MiB to 16 to match the size we give for the main thread. It's planned to eventually remove this hard coded value and have Zig able to determine this value during semantic analysis, with call graph analysis and function pointer annotations and extern function annotations.
2019-09-11 20:22:49 -04:00
pub fn dumpStackPointerAddr(prefix: []const u8) void {
ran zig fmt on stdlib
2019-09-25 18:17:29 +03:00
const sp = asm (""
zig fmt: respect trailing commas in inline assembly
2021-08-29 11:57:32 +02:00
: [argc] "={rsp}" (-> usize),
ran zig fmt on stdlib
2019-09-25 18:17:29 +03:00
);
remove formatted panics implements #17969
2024-09-25 11:11:48 -07:00
print("{s} sp = 0x{x}\n", .{ prefix, sp });
improvements targeted at improving async functions * Reuse bytes of async function frames when non-async functions make `noasync` calls. This prevents explosive stack growth. * Zig now passes a stack size argument to the linker when linking ELF binaries. Linux ignores this value, but it is available as a program header called GNU_STACK. I prototyped some code that memory maps extra space to the stack using this program header, but there was still a problem when accessing stack memory very far down. Stack probing is needed or not working or something. I also prototyped using `@newStackCall` to call main and that does work around the issue but it also brings its own issues. That code is commented out for now in std/special/start.zig. I'm on a plane with no Internet, but I plan to consult with the musl community for advice when I get a chance. * Added `noasync` to a bunch of function calls in std.debug. It's very messy but it's a workaround that makes stack traces functional with evented I/O enabled. Eventually these will be cleaned up as the root bugs are found and fixed. Programs built in blocking mode are unaffected. * Lowered the default stack size of std.io.InStream (for the async version) to 1 MiB instead of 4. Until we figure out how to get choosing a stack size working (see 2nd bullet point above), 4 MiB tends to cause segfaults due to stack size running out, or usage of stack memory too far apart, or something like that. * Default thread stack size is bumped from 8 MiB to 16 to match the size we give for the main thread. It's planned to eventually remove this hard coded value and have Zig able to determine this value during semantic analysis, with call graph analysis and function pointer annotations and extern function annotations.
2019-09-11 20:22:49 -04:00
}
debug: add smoke test
2022-04-21 10:14:23 +02:00
std.debug: disable sporadically failing test see tracking issue #13963
2022-12-15 15:56:13 -07:00
test "manage resources correctly" {
test: test with `-fstrip` and fix failures Closes #17513
2023-11-30 14:27:18 -05:00
if (builtin.strip_debug_info) return error.SkipZigTest;
extract std.posix from std.os closes #5019
2024-03-18 22:39:59 -07:00
if (native_os == .wasi) return error.SkipZigTest;
debug: add smoke test
2022-04-21 10:14:23 +02:00
extract std.posix from std.os closes #5019
2024-03-18 22:39:59 -07:00
if (native_os == .windows) {
std.debug: disable sporadically failing test see tracking issue #13963
2023-01-29 12:48:38 -07:00
// https://github.com/ziglang/zig/issues/13963
return error.SkipZigTest;
}
std: disable failing debug info test for self-hosted
2024-08-16 16:08:18 -04:00
// self-hosted debug info is still too buggy
if (builtin.zig_backend != .stage2_llvm) return error.SkipZigTest;
debug: add smoke test
2022-04-21 10:14:23 +02:00
const writer = std.io.null_writer;
fix compilation on powerpc GNU systems ...which have a ucontext_t but not a PC register. The current stack unwinding implementation does not yet support this architecture. Also fix name of `std.debug.SelfInfo.openSelf` to remove redundancy. Also removed this hook into root providing an "openSelfDebugInfo" function. Sorry, this debugging code is not of sufficient quality to offer a plugin API right now.
2024-08-02 12:00:08 -07:00
var di = try SelfInfo.open(testing.allocator);
debug: add smoke test
2022-04-21 10:14:23 +02:00
defer di.deinit();
std: Move std.debug.{TTY.Config,detectTTYConfig} to std.io.tty Also get rid of the TTY wrapper struct, which was exlusively used as a namespace - this is done by the tty.zig root struct now. detectTTYConfig has been renamed to just detectConfig, which is enough given the new namespace. Additionally, a doc comment had been added.
2023-05-21 14:27:28 +01:00
try printSourceAtAddress(&di, writer, showMyTrace(), io.tty.detectConfig(std.io.getStdErr()));
debug: add smoke test
2022-04-21 10:14:23 +02:00
}
noinline fn showMyTrace() usize {
return @returnAddress();
}
introduce std.debug.Trace And use it to debug a LazySrcLoc in stage2 that is set to a bogus value. The actual fix in this commit is: ```diff - try sema.emitBackwardBranch(&child_block, call_src); + try sema.emitBackwardBranch(block, call_src); ```
2022-06-07 17:48:53 -07:00
std.debug.Trace: improve API Now `std.debug.Trace` is a concrete type with pre-chosen defaults. `std.debug.ConfigurableTrace` can be used for more advanced cases.
2022-06-08 12:55:24 -07:00
/// 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);
AstGen: detect declarations shadowing locals Closes #9355
2022-08-16 16:55:49 +03:00
pub fn ConfigurableTrace(comptime size: usize, comptime stack_frame_count: usize, comptime is_enabled: bool) type {
introduce std.debug.Trace And use it to debug a LazySrcLoc in stage2 that is set to a bogus value. The actual fix in this commit is: ```diff - try sema.emitBackwardBranch(&child_block, call_src); + try sema.emitBackwardBranch(block, call_src); ```
2022-06-07 17:48:53 -07:00
return struct {
std.debug.Trace: follow the struct default field guidance
2024-05-24 10:34:29 -07:00
addrs: [actual_size][stack_frame_count]usize,
notes: [actual_size][]const u8,
index: Index,
introduce std.debug.Trace And use it to debug a LazySrcLoc in stage2 that is set to a bogus value. The actual fix in this commit is: ```diff - try sema.emitBackwardBranch(&child_block, call_src); + try sema.emitBackwardBranch(block, call_src); ```
2022-06-07 17:48:53 -07:00
std.debug.Trace: improve API Now `std.debug.Trace` is a concrete type with pre-chosen defaults. `std.debug.ConfigurableTrace` can be used for more advanced cases.
2022-06-08 12:55:24 -07:00
const actual_size = if (enabled) size else 0;
const Index = if (enabled) usize else u0;
introduce std.debug.Trace And use it to debug a LazySrcLoc in stage2 that is set to a bogus value. The actual fix in this commit is: ```diff - try sema.emitBackwardBranch(&child_block, call_src); + try sema.emitBackwardBranch(block, call_src); ```
2022-06-07 17:48:53 -07:00
std.debug.Trace: follow the struct default field guidance
2024-05-24 10:34:29 -07:00
pub const init: @This() = .{
.addrs = undefined,
.notes = undefined,
.index = 0,
};
AstGen: detect declarations shadowing locals Closes #9355
2022-08-16 16:55:49 +03:00
pub const enabled = is_enabled;
std.debug.Trace: improve API Now `std.debug.Trace` is a concrete type with pre-chosen defaults. `std.debug.ConfigurableTrace` can be used for more advanced cases.
2022-06-08 12:55:24 -07:00
pub const add = if (enabled) addNoInline else addNoOp;
pub noinline fn addNoInline(t: *@This(), note: []const u8) void {
comptime assert(enabled);
introduce std.debug.Trace And use it to debug a LazySrcLoc in stage2 that is set to a bogus value. The actual fix in this commit is: ```diff - try sema.emitBackwardBranch(&child_block, call_src); + try sema.emitBackwardBranch(block, call_src); ```
2022-06-07 17:48:53 -07:00
return addAddr(t, @returnAddress(), note);
}
std.debug.Trace: improve API Now `std.debug.Trace` is a concrete type with pre-chosen defaults. `std.debug.ConfigurableTrace` can be used for more advanced cases.
2022-06-08 12:55:24 -07:00
pub inline fn addNoOp(t: *@This(), note: []const u8) void {
_ = t;
_ = note;
comptime assert(!enabled);
}
introduce std.debug.Trace And use it to debug a LazySrcLoc in stage2 that is set to a bogus value. The actual fix in this commit is: ```diff - try sema.emitBackwardBranch(&child_block, call_src); + try sema.emitBackwardBranch(block, call_src); ```
2022-06-07 17:48:53 -07:00
pub fn addAddr(t: *@This(), addr: usize, note: []const u8) void {
std.debug.Trace: improve API Now `std.debug.Trace` is a concrete type with pre-chosen defaults. `std.debug.ConfigurableTrace` can be used for more advanced cases.
2022-06-08 12:55:24 -07:00
if (!enabled) return;
introduce std.debug.Trace And use it to debug a LazySrcLoc in stage2 that is set to a bogus value. The actual fix in this commit is: ```diff - try sema.emitBackwardBranch(&child_block, call_src); + try sema.emitBackwardBranch(block, call_src); ```
2022-06-07 17:48:53 -07:00
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 {
std.debug.Trace: improve API Now `std.debug.Trace` is a concrete type with pre-chosen defaults. `std.debug.ConfigurableTrace` can be used for more advanced cases.
2022-06-08 12:55:24 -07:00
if (!enabled) return;
std: Move std.debug.{TTY.Config,detectTTYConfig} to std.io.tty Also get rid of the TTY wrapper struct, which was exlusively used as a namespace - this is done by the tty.zig root struct now. detectTTYConfig has been renamed to just detectConfig, which is enough given the new namespace. Additionally, a doc comment had been added.
2023-05-21 14:27:28 +01:00
const tty_config = io.tty.detectConfig(std.io.getStdErr());
introduce std.debug.Trace And use it to debug a LazySrcLoc in stage2 that is set to a bogus value. The actual fix in this commit is: ```diff - try sema.emitBackwardBranch(&child_block, call_src); + try sema.emitBackwardBranch(block, call_src); ```
2022-06-07 17:48:53 -07:00
const stderr = io.getStdErr().writer();
all: rename `@maximum` to `@max` and `@minimum` to `@min`
2022-10-03 20:04:30 +03:30
const end = @min(t.index, size);
introduce std.debug.Trace And use it to debug a LazySrcLoc in stage2 that is set to a bogus value. The actual fix in this commit is: ```diff - try sema.emitBackwardBranch(&child_block, call_src); + try sema.emitBackwardBranch(block, call_src); ```
2022-06-07 17:48:53 -07:00
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;
};
update std lib and compiler sources to new for loop syntax
2023-02-18 09:02:57 -07:00
for (t.addrs[0..end], 0..) |frames_array, i| {
introduce std.debug.Trace And use it to debug a LazySrcLoc in stage2 that is set to a bogus value. The actual fix in this commit is: ```diff - try sema.emitBackwardBranch(&child_block, call_src); + try sema.emitBackwardBranch(block, call_src); ```
2022-06-07 17:48:53 -07:00
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,
};
std.debug: remove allocator from std.debug.writeStackTrace()
2024-08-22 17:10:32 -07:00
writeStackTrace(stack_trace, stderr, debug_info, tty_config) catch continue;
introduce std.debug.Trace And use it to debug a LazySrcLoc in stage2 that is set to a bogus value. The actual fix in this commit is: ```diff - try sema.emitBackwardBranch(&child_block, call_src); + try sema.emitBackwardBranch(block, call_src); ```
2022-06-07 17:48:53 -07:00
}
if (t.index > end) {
stderr.print("{d} more traces not shown; consider increasing trace size\n", .{
t.index - end,
}) catch return;
}
}
add std.debug.Trace.format This makes it show up in some useful places; for example in the self-hosted compiler we already print it now with --debug-compile-errors.
2022-06-12 00:57:59 -07:00
pub fn format(
std.debug: fix format on ConfigurableTrace
2025-01-20 02:01:55 +03:00
t: @This(),
add std.debug.Trace.format This makes it show up in some useful places; for example in the self-hosted compiler we already print it now with --debug-compile-errors.
2022-06-12 00:57:59 -07:00
comptime fmt: []const u8,
options: std.fmt.FormatOptions,
writer: anytype,
) !void {
Make invalidFmtError public and use in place of compileErrors for bad format strings (#13526) * Export invalidFmtErr To allow consistent use of "invalid format string" compile error response for badly formatted format strings. See https://github.com/ziglang/zig/pull/13489#issuecomment-1311759340. * Replace format compile errors with invalidFmtErr - Provides more consistent compile errors. - Gives user info about the type of the badly formated value. * Rename invalidFmtErr as invalidFmtError For consistency. Zig seems to use “Error” more often than “Err”. * std: add invalid format string checks to remaining custom formatters * pass reference-trace to comp when building build file; fix checkobjectstep
2022-11-12 20:03:24 +01:00
if (fmt.len != 0) std.fmt.invalidFmtError(fmt, t);
add std.debug.Trace.format This makes it show up in some useful places; for example in the self-hosted compiler we already print it now with --debug-compile-errors.
2022-06-12 00:57:59 -07:00
_ = options;
if (enabled) {
try writer.writeAll("\n");
t.dump();
try writer.writeAll("\n");
} else {
return writer.writeAll("(value tracing disabled)");
}
}
introduce std.debug.Trace And use it to debug a LazySrcLoc in stage2 that is set to a bogus value. The actual fix in this commit is: ```diff - try sema.emitBackwardBranch(&child_block, call_src); + try sema.emitBackwardBranch(block, call_src); ```
2022-06-07 17:48:53 -07:00
};
}
fixups from previous commit * rename the functions * make the other function public and give it a better name * interact with stderr_mutex * std lib test coverage
2024-01-08 00:21:57 -07:00
std: introduce pointer stability locks to hash maps (#17719) This adds std.debug.SafetyLock and uses it in std.HashMapUnmanaged by adding lockPointers() and unlockPointers(). This provides a way to detect when an illegal modification has happened and panic rather than invoke undefined behavior.
2024-03-16 15:45:10 -07:00
pub const SafetyLock = struct {
add assertLocked to std.debug.SafetyLock
2024-10-07 01:16:20 -07:00
state: State = if (runtime_safety) .unlocked else .unknown,
std: introduce pointer stability locks to hash maps (#17719) This adds std.debug.SafetyLock and uses it in std.HashMapUnmanaged by adding lockPointers() and unlockPointers(). This provides a way to detect when an illegal modification has happened and panic rather than invoke undefined behavior.
2024-03-16 15:45:10 -07:00
add assertLocked to std.debug.SafetyLock
2024-10-07 01:16:20 -07:00
pub const State = if (runtime_safety) enum { unlocked, locked } else enum { unknown };
std: introduce pointer stability locks to hash maps (#17719) This adds std.debug.SafetyLock and uses it in std.HashMapUnmanaged by adding lockPointers() and unlockPointers(). This provides a way to detect when an illegal modification has happened and panic rather than invoke undefined behavior.
2024-03-16 15:45:10 -07:00
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);
}
add assertLocked to std.debug.SafetyLock
2024-10-07 01:16:20 -07:00
pub fn assertLocked(l: SafetyLock) void {
if (!runtime_safety) return;
assert(l.state == .locked);
}
std: introduce pointer stability locks to hash maps (#17719) This adds std.debug.SafetyLock and uses it in std.HashMapUnmanaged by adding lockPointers() and unlockPointers(). This provides a way to detect when an illegal modification has happened and panic rather than invoke undefined behavior.
2024-03-16 15:45:10 -07:00
};
add assertLocked to std.debug.SafetyLock
2024-10-07 01:16:20 -07:00
test SafetyLock {
var safety_lock: SafetyLock = .{};
safety_lock.assertUnlocked();
safety_lock.lock();
safety_lock.assertLocked();
safety_lock.unlock();
safety_lock.assertUnlocked();
}
add std.debug.inValgrind This is like `@inComptime` but for the Valgrind virtual machine. Related #17717
2024-03-21 14:35:08 -07:00
/// 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;
}
fixups from previous commit * rename the functions * make the other function public and give it a better name * interact with stderr_mutex * std lib test coverage
2024-01-08 00:21:57 -07:00
test {
fix compilation on powerpc GNU systems ...which have a ucontext_t but not a PC register. The current stack unwinding implementation does not yet support this architecture. Also fix name of `std.debug.SelfInfo.openSelf` to remove redundancy. Also removed this hook into root providing an "openSelfDebugInfo" function. Sorry, this debugging code is not of sufficient quality to offer a plugin API right now.
2024-08-02 12:00:08 -07:00
_ = &Dwarf;
_ = &MemoryAccessor;
std.debug.FixedBufferReader is fine it does not need to be deprecated
2024-08-02 21:22:33 -07:00
_ = &FixedBufferReader;
fix compilation on powerpc GNU systems ...which have a ucontext_t but not a PC register. The current stack unwinding implementation does not yet support this architecture. Also fix name of `std.debug.SelfInfo.openSelf` to remove redundancy. Also removed this hook into root providing an "openSelfDebugInfo" function. Sorry, this debugging code is not of sufficient quality to offer a plugin API right now.
2024-08-02 12:00:08 -07:00
_ = &Pdb;
_ = &SelfInfo;
debug: correct dump_hex and dump_hex_fallible casing (#19296) #1097 is closed.
2024-07-22 09:00:08 +09:00
_ = &dumpHex;
fixups from previous commit * rename the functions * make the other function public and give it a better name * interact with stderr_mutex * std lib test coverage
2024-01-08 00:21:57 -07:00
}
Reference in New Issue Copy Permalink