The Great std.debug Refactor

build.zig

@@ -563,7 +563,8 @@ pub fn build(b: *std.Build) !void {
         .skip_release = skip_release,
     }));
     test_step.dependOn(tests.addLinkTests(b, enable_macos_sdk, enable_ios_sdk, enable_symlinks_windows));
-    test_step.dependOn(tests.addStackTraceTests(b, test_filters, optimization_modes));
+    test_step.dependOn(tests.addStackTraceTests(b, test_filters, skip_non_native));
+    test_step.dependOn(tests.addErrorTraceTests(b, test_filters, optimization_modes, skip_non_native));
     test_step.dependOn(tests.addCliTests(b));
     if (tests.addDebuggerTests(b, .{
         .test_filters = test_filters,

lib/compiler/test_runner.zig

@@ -140,7 +140,7 @@ fn mainServer() !void {
                     else => {
                         fail = true;
                         if (@errorReturnTrace()) |trace| {
-                            std.debug.dumpStackTrace(trace.*);
+                            std.debug.dumpStackTrace(trace);
                         }
                     },
                 };
@@ -182,7 +182,7 @@ fn mainServer() !void {
                     error.SkipZigTest => return,
                     else => {
                         if (@errorReturnTrace()) |trace| {
-                            std.debug.dumpStackTrace(trace.*);
+                            std.debug.dumpStackTrace(trace);
                         }
                         std.debug.print("failed with error.{t}\n", .{err});
                         std.process.exit(1);
@@ -261,7 +261,7 @@ fn mainTerminal() void {
                     std.debug.print("FAIL ({t})\n", .{err});
                 }
                 if (@errorReturnTrace()) |trace| {
-                    std.debug.dumpStackTrace(trace.*);
+                    std.debug.dumpStackTrace(trace);
                 }
                 test_node.end();
             },
@@ -398,7 +398,7 @@ pub fn fuzz(
                 error.SkipZigTest => return,
                 else => {
                     std.debug.lockStdErr();
-                    if (@errorReturnTrace()) |trace| std.debug.dumpStackTrace(trace.*);
+                    if (@errorReturnTrace()) |trace| std.debug.dumpStackTrace(trace);
                     std.debug.print("failed with error.{t}\n", .{err});
                     std.process.exit(1);
                 },

lib/std/Build.zig

@@ -2195,7 +2195,7 @@ fn dependencyInner(
         sub_builder.runBuild(bz) catch @panic("unhandled error");
 
         if (sub_builder.validateUserInputDidItFail()) {
-            std.debug.dumpCurrentStackTrace(@returnAddress());
+            std.debug.dumpCurrentStackTrace(.{ .first_address = @returnAddress() });
         }
     }
 

lib/std/Build/Step.zig

@@ -60,7 +60,7 @@ test_results: TestResults,
 
 /// The return address associated with creation of this step that can be useful
 /// to print along with debugging messages.
-debug_stack_trace: []usize,
+debug_stack_trace: std.builtin.StackTrace,
 
 pub const TestResults = struct {
     fail_count: u32 = 0,
@@ -220,16 +220,9 @@ pub fn init(options: StepOptions) Step {
         .state = .precheck_unstarted,
         .max_rss = options.max_rss,
         .debug_stack_trace = blk: {
-            if (!std.debug.sys_can_stack_trace) break :blk &.{};
-            const addresses = arena.alloc(usize, options.owner.debug_stack_frames_count) catch @panic("OOM");
-            @memset(addresses, 0);
+            const addr_buf = arena.alloc(usize, options.owner.debug_stack_frames_count) catch @panic("OOM");
             const first_ret_addr = options.first_ret_addr orelse @returnAddress();
-            var stack_trace = std.builtin.StackTrace{
-                .instruction_addresses = addresses,
-                .index = 0,
-            };
-            std.debug.captureStackTrace(first_ret_addr, &stack_trace);
-            break :blk addresses;
+            break :blk std.debug.captureCurrentStackTrace(.{ .first_address = first_ret_addr }, addr_buf);
         },
         .result_error_msgs = .{},
         .result_error_bundle = std.zig.ErrorBundle.empty,
@@ -282,18 +275,6 @@ pub fn dependOn(step: *Step, other: *Step) void {
     step.dependencies.append(other) catch @panic("OOM");
 }
 
-pub fn getStackTrace(s: *Step) ?std.builtin.StackTrace {
-    var len: usize = 0;
-    while (len < s.debug_stack_trace.len and s.debug_stack_trace[len] != 0) {
-        len += 1;
-    }
-
-    return if (len == 0) null else .{
-        .instruction_addresses = s.debug_stack_trace,
-        .index = len,
-    };
-}
-
 fn makeNoOp(step: *Step, options: MakeOptions) anyerror!void {
     _ = options;
 
@@ -315,18 +296,9 @@ pub fn cast(step: *Step, comptime T: type) ?*T {
 
 /// For debugging purposes, prints identifying information about this Step.
 pub fn dump(step: *Step, w: *std.Io.Writer, tty_config: std.Io.tty.Config) void {
-    const debug_info = std.debug.getSelfDebugInfo() catch |err| {
-        w.print("Unable to dump stack trace: Unable to open debug info: {s}\n", .{
-            @errorName(err),
-        }) catch {};
-        return;
-    };
-    if (step.getStackTrace()) |stack_trace| {
+    if (step.debug_stack_trace.instruction_addresses.len > 0) {
         w.print("name: '{s}'. creation stack trace:\n", .{step.name}) catch {};
-        std.debug.writeStackTrace(stack_trace, w, debug_info, tty_config) catch |err| {
-            w.print("Unable to dump stack trace: {s}\n", .{@errorName(err)}) catch {};
-            return;
-        };
+        std.debug.writeStackTrace(&step.debug_stack_trace, w, tty_config) catch {};
     } else {
         const field = "debug_stack_frames_count";
         comptime assert(@hasField(Build, field));

lib/std/Build/Step/CheckObject.zig

@@ -1097,44 +1097,38 @@ const MachODumper = struct {
 
             for (ctx.symtab.items) |sym| {
                 const sym_name = ctx.getString(sym.n_strx);
-                if (sym.stab()) {
-                    const tt = switch (sym.n_type) {
-                        macho.N_SO => "SO",
-                        macho.N_OSO => "OSO",
-                        macho.N_BNSYM => "BNSYM",
-                        macho.N_ENSYM => "ENSYM",
-                        macho.N_FUN => "FUN",
-                        macho.N_GSYM => "GSYM",
-                        macho.N_STSYM => "STSYM",
-                        else => "UNKNOWN STAB",
+                if (sym.n_type.bits.is_stab != 0) {
+                    const tt = switch (sym.n_type.stab) {
+                        _ => "UNKNOWN STAB",
+                        else => @tagName(sym.n_type.stab),
                     };
                     try writer.print("{x}", .{sym.n_value});
                     if (sym.n_sect > 0) {
                         const sect = ctx.sections.items[sym.n_sect - 1];
                         try writer.print(" ({s},{s})", .{ sect.segName(), sect.sectName() });
                     }
                     try writer.print(" {s} (stab) {s}\n", .{ tt, sym_name });
-                } else if (sym.sect()) {
+                } else if (sym.n_type.bits.type == .sect) {
                     const sect = ctx.sections.items[sym.n_sect - 1];
                     try writer.print("{x} ({s},{s})", .{
                         sym.n_value,
                         sect.segName(),
                         sect.sectName(),
                     });
-                    if (sym.n_desc & macho.REFERENCED_DYNAMICALLY != 0) try writer.writeAll(" [referenced dynamically]");
-                    if (sym.weakDef()) try writer.writeAll(" weak");
-                    if (sym.weakRef()) try writer.writeAll(" weakref");
-                    if (sym.ext()) {
-                        if (sym.pext()) try writer.writeAll(" private");
+                    if (sym.n_desc.referenced_dynamically) try writer.writeAll(" [referenced dynamically]");
+                    if (sym.n_desc.weak_def_or_ref_to_weak) try writer.writeAll(" weak");
+                    if (sym.n_desc.weak_ref) try writer.writeAll(" weakref");
+                    if (sym.n_type.bits.ext) {
+                        if (sym.n_type.bits.pext) try writer.writeAll(" private");
                         try writer.writeAll(" external");
-                    } else if (sym.pext()) try writer.writeAll(" (was private external)");
+                    } else if (sym.n_type.bits.pext) try writer.writeAll(" (was private external)");
                     try writer.print(" {s}\n", .{sym_name});
                 } else if (sym.tentative()) {
-                    const alignment = (sym.n_desc >> 8) & 0x0F;
+                    const alignment = (@as(u16, @bitCast(sym.n_desc)) >> 8) & 0x0F;
                     try writer.print("  0x{x:0>16} (common) (alignment 2^{d})", .{ sym.n_value, alignment });
-                    if (sym.ext()) try writer.writeAll(" external");
+                    if (sym.n_type.bits.ext) try writer.writeAll(" external");
                     try writer.print(" {s}\n", .{sym_name});
-                } else if (sym.undf()) {
+                } else if (sym.n_type.bits.type == .undf) {
                     const ordinal = @divFloor(@as(i16, @bitCast(sym.n_desc)), macho.N_SYMBOL_RESOLVER);
                     const import_name = blk: {
                         if (ordinal <= 0) {
@@ -1153,8 +1147,8 @@ const MachODumper = struct {
                         break :blk basename[0..ext];
                     };
                     try writer.writeAll("(undefined)");
-                    if (sym.weakRef()) try writer.writeAll(" weakref");
-                    if (sym.ext()) try writer.writeAll(" external");
+                    if (sym.n_desc.weak_ref) try writer.writeAll(" weakref");
+                    if (sym.n_type.bits.ext) try writer.writeAll(" external");
                     try writer.print(" {s} (from {s})\n", .{
                         sym_name,
                         import_name,

lib/std/Thread.zig

@@ -530,7 +530,7 @@ fn callFn(comptime f: anytype, args: anytype) switch (Impl) {
                     @call(.auto, f, args) catch |err| {
                         std.debug.print("error: {s}\n", .{@errorName(err)});
                         if (@errorReturnTrace()) |trace| {
-                            std.debug.dumpStackTrace(trace.*);
+                            std.debug.dumpStackTrace(trace);
                         }
                     };
 

lib/std/builtin.zig

@@ -38,20 +38,17 @@ pub const StackTrace = struct {
     index: usize,
     instruction_addresses: []usize,
 
-    pub fn format(self: StackTrace, writer: *std.Io.Writer) std.Io.Writer.Error!void {
+    pub fn format(st: *const StackTrace, writer: *std.Io.Writer) std.Io.Writer.Error!void {
         // TODO: re-evaluate whether to use format() methods at all.
         // Until then, avoid an error when using GeneralPurposeAllocator with WebAssembly
         // where it tries to call detectTTYConfig here.
         if (builtin.os.tag == .freestanding) return;
 
-        const debug_info = std.debug.getSelfDebugInfo() catch |err| {
-            return writer.print("\nUnable to print stack trace: Unable to open debug info: {s}\n", .{@errorName(err)});
-        };
-        const tty_config = std.Io.tty.detectConfig(std.fs.File.stderr());
+        // TODO: why on earth are we using stderr's ttyconfig?
+        // If we want colored output, we should just make a formatter out of `writeStackTrace`.
+        const tty_config = std.Io.tty.detectConfig(.stderr());
         try writer.writeAll("\n");
-        std.debug.writeStackTrace(self, writer, debug_info, tty_config) catch |err| {
-            try writer.print("Unable to print stack trace: {s}\n", .{@errorName(err)});
-        };
+        try std.debug.writeStackTrace(st, writer, tty_config);
     }
 };