@zigc/lib 0.16.0-test.1 → 0.16.0

package/std/array_list.zig

@@ -857,16 +857,8 @@ pub fn Aligned(comptime T: type, comptime alignment: ?mem.Alignment) type {
             len: usize,
             new_items: []const T,
         ) Allocator.Error!void {
-            const after_range = start + len;
-            const range = self.items[start..after_range];
-            if (range.len < new_items.len) {
-                const first = new_items[0..range.len];
-                const rest = new_items[range.len..];
-                @memcpy(range[0..first.len], first);
-                try self.insertSlice(gpa, after_range, rest);
-            } else {
-                self.replaceRangeAssumeCapacity(start, len, new_items);
-            }
+            try self.ensureTotalCapacity(gpa, try addOrOom(self.items.len - len, new_items.len));
+            self.replaceRangeAssumeCapacity(start, len, new_items);
         }
 
         /// Grows or shrinks the list as necessary.
@@ -874,26 +866,20 @@ pub fn Aligned(comptime T: type, comptime alignment: ?mem.Alignment) type {
         /// Never invalidates element pointers.
         ///
         /// Asserts the capacity is enough for additional items.
-        pub fn replaceRangeAssumeCapacity(self: *Self, start: usize, len: usize, new_items: []const T) void {
-            const after_range = start + len;
-            const range = self.items[start..after_range];
-
-            if (range.len == new_items.len)
-                @memcpy(range[0..new_items.len], new_items)
-            else if (range.len < new_items.len) {
-                const first = new_items[0..range.len];
-                const rest = new_items[range.len..];
-                @memcpy(range[0..first.len], first);
-                const dst = self.addManyAtAssumeCapacity(after_range, rest.len);
-                @memcpy(dst, rest);
-            } else {
-                const extra = range.len - new_items.len;
-                @memcpy(range[0..new_items.len], new_items);
-                const src = self.items[after_range..];
-                @memmove(self.items[after_range - extra ..][0..src.len], src);
-                @memset(self.items[self.items.len - extra ..], undefined);
-                self.items.len -= extra;
-            }
+        pub fn replaceRangeAssumeCapacity(
+            self: *Self,
+            start: usize,
+            len: usize,
+            new_items: []const T,
+        ) void {
+            std.debug.assert(self.capacity - self.items.len >= new_items.len -| len);
+
+            const tail = self.items[start + len ..];
+            const vacated = self.items[self.items.len - (len -| new_items.len) ..];
+            self.items.len = self.items.len - len + new_items.len;
+            @memmove(self.items[start + new_items.len ..], tail);
+            @memcpy(self.items[start..][0..new_items.len], new_items);
+            @memset(vacated, undefined);
         }
 
         /// Grows or shrinks the list as necessary.
@@ -902,7 +888,12 @@ pub fn Aligned(comptime T: type, comptime alignment: ?mem.Alignment) type {
         ///
         /// If the unused capacity is insufficient for additional items,
         /// returns `error.OutOfMemory`.
-        pub fn replaceRangeBounded(self: *Self, start: usize, len: usize, new_items: []const T) error{OutOfMemory}!void {
+        pub fn replaceRangeBounded(
+            self: *Self,
+            start: usize,
+            len: usize,
+            new_items: []const T,
+        ) error{OutOfMemory}!void {
             if (self.capacity - self.items.len < new_items.len -| len) return error.OutOfMemory;
             return replaceRangeAssumeCapacity(self, start, len, new_items);
         }

package/std/bit_set.zig

@@ -68,16 +68,24 @@ pub fn IntegerBitSet(comptime size: u16) type {
         /// The bit mask, as a single integer
         mask: MaskInt,
 
+        /// Deprecated: use `.empty`.
         /// Creates a bit set with no elements present.
         pub fn initEmpty() Self {
             return .{ .mask = 0 };
         }
 
+        /// Deprecated: use `.full`.
         /// Creates a bit set with all elements present.
         pub fn initFull() Self {
             return .{ .mask = ~@as(MaskInt, 0) };
         }
 
+        /// A bit set with no elements present.
+        pub const empty: Self = .{ .mask = 0 };
+
+        /// A bit set with all elements present.
+        pub const full: Self = .{ .mask = ~@as(MaskInt, 0) };
+
         /// Returns the number of bits in this bit set
         pub inline fn capacity(self: Self) usize {
             _ = self;
@@ -387,11 +395,13 @@ pub fn ArrayBitSet(comptime MaskIntType: type, comptime size: usize) type {
         /// Padding bits at the end are undefined.
         masks: [num_masks]MaskInt,
 
+        /// Deprecated: use `.empty`.
         /// Creates a bit set with no elements present.
         pub fn initEmpty() Self {
             return .{ .masks = [_]MaskInt{0} ** num_masks };
         }
 
+        /// Deprecated: use `.full`.
         /// Creates a bit set with all elements present.
         pub fn initFull() Self {
             if (num_masks == 0) {
@@ -401,6 +411,12 @@ pub fn ArrayBitSet(comptime MaskIntType: type, comptime size: usize) type {
             }
         }
 
+        /// A bit set with no elements present.
+        pub const empty: Self = .{ .masks = @splat(0) };
+
+        /// A bit set with all elements present.
+        pub const full: Self = .{ .masks = if (num_masks == 0) .{} else ([_]MaskInt{~@as(MaskInt, 0)} ** (num_masks - 1) ++ [_]MaskInt{last_item_mask}) };
+
         /// Returns the number of bits in this bit set
         pub inline fn capacity(self: Self) usize {
             _ = self;
@@ -1633,17 +1649,17 @@ fn fillOdd(set: anytype, len: usize) void {
 }
 
 fn testPureBitSet(comptime Set: type) !void {
-    const empty = Set.initEmpty();
-    const full = Set.initFull();
+    const empty = Set.empty;
+    const full = Set.full;
 
     const even = even: {
-        var bit_set = Set.initEmpty();
+        var bit_set = Set.empty;
         fillEven(&bit_set, Set.bit_length);
         break :even bit_set;
     };
 
     const odd = odd: {
-        var bit_set = Set.initEmpty();
+        var bit_set = Set.empty;
         fillOdd(&bit_set, Set.bit_length);
         break :odd bit_set;
     };
@@ -1686,8 +1702,8 @@ fn testPureBitSet(comptime Set: type) !void {
 }
 
 fn testStaticBitSet(comptime Set: type) !void {
-    var a = Set.initEmpty();
-    var b = Set.initFull();
+    var a = Set.empty;
+    var b = Set.full;
     try testing.expectEqual(@as(usize, 0), a.count());
     try testing.expectEqual(@as(usize, Set.bit_length), b.count());
 

package/std/builtin/assembly.zig

@@ -682,6 +682,40 @@ pub const Clobbers = switch (@import("builtin").cpu.arch) {
         x30: bool = false,
         x31: bool = false,
 
+        // ABI aliases for integer registers
+        ra: bool = false,
+        sp: bool = false,
+        gp: bool = false,
+        tp: bool = false,
+        t0: bool = false,
+        t1: bool = false,
+        t2: bool = false,
+        s0: bool = false,
+        fp: bool = false,
+        s1: bool = false,
+        a0: bool = false,
+        a1: bool = false,
+        a2: bool = false,
+        a3: bool = false,
+        a4: bool = false,
+        a5: bool = false,
+        a6: bool = false,
+        a7: bool = false,
+        s2: bool = false,
+        s3: bool = false,
+        s4: bool = false,
+        s5: bool = false,
+        s6: bool = false,
+        s7: bool = false,
+        s8: bool = false,
+        s9: bool = false,
+        s10: bool = false,
+        s11: bool = false,
+        t3: bool = false,
+        t4: bool = false,
+        t5: bool = false,
+        t6: bool = false,
+
         fflags: bool = false,
         frm: bool = false,
 
@@ -718,6 +752,40 @@ pub const Clobbers = switch (@import("builtin").cpu.arch) {
         f30: bool = false,
         f31: bool = false,
 
+        // ABI aliases for float registers
+        ft0: bool = false,
+        ft1: bool = false,
+        ft2: bool = false,
+        ft3: bool = false,
+        ft4: bool = false,
+        ft5: bool = false,
+        ft6: bool = false,
+        ft7: bool = false,
+        fs0: bool = false,
+        fs1: bool = false,
+        fa0: bool = false,
+        fa1: bool = false,
+        fa2: bool = false,
+        fa3: bool = false,
+        fa4: bool = false,
+        fa5: bool = false,
+        fa6: bool = false,
+        fa7: bool = false,
+        fs2: bool = false,
+        fs3: bool = false,
+        fs4: bool = false,
+        fs5: bool = false,
+        fs6: bool = false,
+        fs7: bool = false,
+        fs8: bool = false,
+        fs9: bool = false,
+        fs10: bool = false,
+        fs11: bool = false,
+        ft8: bool = false,
+        ft9: bool = false,
+        ft10: bool = false,
+        ft11: bool = false,
+
         vtype: bool = false,
         vl: bool = false,
         vxsat: bool = false,

package/std/c.zig

@@ -3721,14 +3721,14 @@ pub const W = switch (native_os) {
         pub fn TERMSIG(x: u32) SIG {
             return @enumFromInt(status(x));
         }
-        pub fn STOPSIG(x: u32) u32 {
-            return x >> 8;
+        pub fn STOPSIG(x: u32) SIG {
+            return @enumFromInt(x >> 8);
         }
         pub fn IFEXITED(x: u32) bool {
             return status(x) == 0;
         }
         pub fn IFSTOPPED(x: u32) bool {
-            return status(x) == stopped and STOPSIG(x) != 0x13;
+            return status(x) == stopped and @as(u32, @intFromEnum(STOPSIG(x))) != 0x13;
         }
         pub fn IFSIGNALED(x: u32) bool {
             return status(x) != stopped and status(x) != 0;
@@ -3754,8 +3754,8 @@ pub const W = switch (native_os) {
         pub fn TERMSIG(s: u32) SIG {
             return @enumFromInt(s & 0x7f);
         }
-        pub fn STOPSIG(s: u32) u32 {
-            return EXITSTATUS(s);
+        pub fn STOPSIG(s: u32) SIG {
+            return @enumFromInt(EXITSTATUS(s));
         }
         pub fn IFEXITED(s: u32) bool {
             return (s & 0x7f) == 0;
@@ -3782,8 +3782,8 @@ pub const W = switch (native_os) {
         pub fn TERMSIG(s: u32) SIG {
             return @enumFromInt(s & 0x7f);
         }
-        pub fn STOPSIG(s: u32) u32 {
-            return EXITSTATUS(s);
+        pub fn STOPSIG(s: u32) SIG {
+            return @enumFromInt(EXITSTATUS(s));
         }
         pub fn IFEXITED(s: u32) bool {
             return (s & 0x7f) == 0;
@@ -3816,8 +3816,8 @@ pub const W = switch (native_os) {
         pub fn TERMSIG(s: u32) SIG {
             return @enumFromInt(s & 0x7f);
         }
-        pub fn STOPSIG(s: u32) u32 {
-            return EXITSTATUS(s);
+        pub fn STOPSIG(s: u32) SIG {
+            return @enumFromInt(EXITSTATUS(s));
         }
         pub fn IFEXITED(s: u32) bool {
             return (s & 0x7f) == 0;
@@ -3850,8 +3850,8 @@ pub const W = switch (native_os) {
         pub fn TERMSIG(s: u32) SIG {
             return @enumFromInt(s & 0x7f);
         }
-        pub fn STOPSIG(s: u32) u32 {
-            return EXITSTATUS(s);
+        pub fn STOPSIG(s: u32) SIG {
+            return @enumFromInt(EXITSTATUS(s));
         }
         pub fn IFEXITED(s: u32) bool {
             return (s & 0x7f) == 0;
@@ -3879,8 +3879,8 @@ pub const W = switch (native_os) {
             return @enumFromInt((s >> 8) & 0xff);
         }
 
-        pub fn STOPSIG(s: u32) u32 {
-            return (s >> 16) & 0xff;
+        pub fn STOPSIG(s: u32) SIG {
+            return @enumFromInt((s >> 16) & 0xff);
         }
 
         pub fn IFEXITED(s: u32) bool {
@@ -3906,8 +3906,8 @@ pub const W = switch (native_os) {
         pub fn TERMSIG(s: u32) SIG {
             return @enumFromInt(s & 0x7f);
         }
-        pub fn STOPSIG(s: u32) u32 {
-            return EXITSTATUS(s);
+        pub fn STOPSIG(s: u32) SIG {
+            return @enumFromInt(EXITSTATUS(s));
         }
         pub fn IFEXITED(s: u32) bool {
             return (s & 0x7f) == 0;
@@ -3938,8 +3938,8 @@ pub const W = switch (native_os) {
             return @intCast((s & 0xff00) >> 8);
         }
 
-        pub fn STOPSIG(s: u32) u32 {
-            return EXITSTATUS(s);
+        pub fn STOPSIG(s: u32) SIG {
+            return @enumFromInt(EXITSTATUS(s));
         }
 
         pub fn TERMSIG(s: u32) SIG {

package/std/compress/flate/Compress.zig

@@ -1488,7 +1488,7 @@ const PackedContainer = packed struct(u2) {
 
 test Compress {
     const fbufs = try testingFreqBufs();
-    defer if (!builtin.fuzz) std.testing.allocator.destroy(fbufs);
+    defer std.testing.allocator.destroy(fbufs);
     try std.testing.fuzz(fbufs, testFuzzedCompressInput, .{});
 }
 
@@ -1818,7 +1818,7 @@ pub const Raw = struct {
 
 test Raw {
     const data_buf = try std.testing.allocator.create([4 * 65536]u8);
-    defer if (!builtin.fuzz) std.testing.allocator.destroy(data_buf);
+    defer std.testing.allocator.destroy(data_buf);
     var prng: std.Random.DefaultPrng = .init(std.testing.random_seed);
     prng.random().bytes(data_buf);
     try std.testing.fuzz(data_buf, testFuzzedRawInput, .{});
@@ -2491,7 +2491,7 @@ pub const Huffman = struct {
 
 test Huffman {
     const fbufs = try testingFreqBufs();
-    defer if (!builtin.fuzz) std.testing.allocator.destroy(fbufs);
+    defer std.testing.allocator.destroy(fbufs);
     try std.testing.fuzz(fbufs, testFuzzedHuffmanInput, .{});
 }
 

package/std/crypto/Certificate/Bundle.zig

@@ -184,7 +184,8 @@ pub fn addCertsFromDirPath(
 ) AddCertsFromDirPathError!void {
     var iterable_dir = try dir.openDir(io, sub_dir_path, .{ .iterate = true });
     defer iterable_dir.close(io);
-    return addCertsFromDir(cb, gpa, io, iterable_dir);
+    const now = Io.Clock.real.now(io);
+    return addCertsFromDir(cb, gpa, io, now, iterable_dir);
 }
 
 pub fn addCertsFromDirPathAbsolute(
@@ -331,6 +332,19 @@ const MapContext = struct {
     }
 };
 
+test "addCertsFromDirPath compiles and accepts an empty directory" {
+    const io = std.testing.io;
+    const gpa = std.testing.allocator;
+
+    var tmp = std.testing.tmpDir(.{ .iterate = true });
+    defer tmp.cleanup();
+
+    var bundle: Bundle = .empty;
+    defer bundle.deinit(gpa);
+
+    try bundle.addCertsFromDirPath(gpa, io, tmp.dir, ".");
+}
+
 test "scan for OS-provided certificates" {
     if (builtin.os.tag == .wasi) return error.SkipZigTest;
 

package/std/crypto/codecs/asn1.zig

@@ -73,13 +73,13 @@ pub const Tag = struct {
         const tag1: FirstTag = @bitCast(try reader.takeByte());
         var number: u14 = tag1.number;
 
-        if (tag1.number == 15) {
+        if (tag1.number == 31) {
             const tag2: NextTag = @bitCast(try reader.takeByte());
             number = tag2.number;
             if (tag2.continues) {
                 const tag3: NextTag = @bitCast(try reader.takeByte());
                 number = (number << 7) + tag3.number;
-                if (tag3.continues) return error.InvalidLength;
+                if (tag3.continues) return error.EndOfStream;
             }
         }
 
@@ -183,7 +183,7 @@ pub const Element = struct {
         }
     };
 
-    pub const DecodeError = error{ InvalidLength, EndOfStream };
+    pub const DecodeError = error{EndOfStream};
 
     /// Safely decode a DER/BER/CER element at `index`:
     /// - Ensures length uses shortest form
@@ -192,26 +192,35 @@ pub const Element = struct {
     pub fn decode(bytes: []const u8, index: Index) DecodeError!Element {
         var reader: std.Io.Reader = .fixed(bytes[index..]);
 
-        const tag = try Tag.decode(&reader);
-        const size_or_len_size = try reader.takeByte();
+        const tag = Tag.decode(&reader) catch |err| switch (err) {
+            error.ReadFailed => unreachable, // it's all fixed buffers
+            else => |e| return e,
+        };
+        const size_or_len_size = reader.takeByte() catch |err| switch (err) {
+            error.ReadFailed => unreachable, // it's all fixed buffers
+            else => |e| return e,
+        };
 
-        var start = index + 2;
-        var end = start + size_or_len_size;
-        // short form between 0-127
-        if (size_or_len_size < 128) {
-            if (end > bytes.len) return error.InvalidLength;
-        } else {
+        const len = if (size_or_len_size < 128)
+            // short form between 0-127
+            size_or_len_size
+        else blk: {
             // long form between 0 and std.math.maxInt(u1024)
             const len_size: u7 = @truncate(size_or_len_size);
-            start += len_size;
-            if (len_size > @sizeOf(Index)) return error.InvalidLength;
+            if (len_size > @sizeOf(Index)) return error.EndOfStream;
 
-            const len = try reader.takeVarInt(Index, .big, len_size);
-            if (len < 128) return error.InvalidLength; // should have used short form
+            const len = reader.takeVarInt(Index, .big, len_size) catch |err| switch (err) {
+                error.ReadFailed => unreachable, // it's all fixed buffers
+                else => |e| return e,
+            };
+            if (len < 128) return error.EndOfStream; // should have used short form
 
-            end = std.math.add(Index, start, len) catch return error.InvalidLength;
-            if (end > bytes.len) return error.InvalidLength;
-        }
+            break :blk len;
+        };
+
+        const start = index + @as(Index, @intCast(reader.seek));
+        const end = std.math.add(Index, start, len) catch return error.EndOfStream;
+        if (end > bytes.len) return error.EndOfStream;
 
         return Element{ .tag = tag, .slice = Slice{ .start = start, .end = end } };
     }
@@ -229,6 +238,12 @@ test Element {
         .tag = Tag.universal(.sequence, true),
         .slice = Element.Slice{ .start = 3, .end = long_form.len },
     }, Element.decode(&long_form, 0));
+
+    const multi_byte_tag = [_]u8{ 0x1F, 0x20, 0x08, 0x30, 0x36, 0x3A, 0x32, 0x37, 0x3A, 0x31, 0x35 };
+    try std.testing.expectEqual(Element{
+        .tag = Tag.universal(.time_of_day, false),
+        .slice = Element.Slice{ .start = 3, .end = multi_byte_tag.len },
+    }, Element.decode(&multi_byte_tag, 0));
 }
 
 /// For decoding.

package/std/crypto/codecs/base64_hex_ct.zig

@@ -93,7 +93,7 @@ pub const hex = struct {
     /// The decoder will skip any characters that are in the ignore list.
     /// The ignore list must not contain any valid hexadecimal characters.
     pub fn decoderWithIgnore(ignore_chars: []const u8) error{InvalidCharacter}!DecoderWithIgnore {
-        var ignored_chars = StaticBitSet(256).initEmpty();
+        var ignored_chars = StaticBitSet(256).empty;
         for (ignore_chars) |c| {
             switch (c) {
                 '0'...'9', 'a'...'f', 'A'...'F' => return error.InvalidCharacter,
@@ -269,7 +269,7 @@ pub const base64 = struct {
 
     /// Creates a new decoder that ignores certain characters.
     pub fn decoderWithIgnore(ignore_chars: []const u8) error{InvalidCharacter}!DecoderWithIgnore {
-        var ignored_chars = StaticBitSet(256).initEmpty();
+        var ignored_chars = StaticBitSet(256).empty;
         for (ignore_chars) |c| {
             switch (c) {
                 'A'...'Z', 'a'...'z', '0'...'9' => return error.InvalidCharacter,
@@ -304,7 +304,7 @@ pub const base64 = struct {
         return (lt(x, 26) & (x +% 'A')) |
             (ge(x, 26) & lt(x, 52) & (x +% 'a' -% 26)) |
             (ge(x, 52) & lt(x, 62) & (x +% '0' -% 52)) |
-            (eq(x, 62) & '+') | (eq(x, 63) & if (urlsafe) '_' else '/');
+            (eq(x, 62) & if (urlsafe) '-' else '+') | (eq(x, 63) & if (urlsafe) '_' else '/');
     }
 
     fn byteFromChar(c: u8, comptime urlsafe: bool) u8 {
@@ -312,7 +312,7 @@ pub const base64 = struct {
             (ge(c, 'A') & le(c, 'Z') & (c -% 'A')) |
             (ge(c, 'a') & le(c, 'z') & (c -% 'a' +% 26)) |
             (ge(c, '0') & le(c, '9') & (c -% '0' +% 52)) |
-            (eq(c, '+') & 62) | (eq(c, if (urlsafe) '_' else '/') & 63);
+            (eq(c, if (urlsafe) '-' else '+') & 62) | (eq(c, if (urlsafe) '_' else '/') & 63);
         return x | (eq(x, 0) & ~eq(c, 'A'));
     }
 
@@ -453,6 +453,16 @@ test "hex with ignored chars" {
     try testing.expectEqualSlices(u8, &expected, bin);
 }
 
+test "base64 urlsafe" {
+    const input = [_]u8{ 0xfb, 0xff };
+    var enc_buf: [4]u8 = undefined;
+    var dec_buf: [2]u8 = undefined;
+    const encoded = try base64.encode(&enc_buf, &input, .urlsafe);
+    try testing.expectEqualSlices(u8, "-_8=", encoded);
+    const decoded = try base64.decode(&dec_buf, encoded, .urlsafe);
+    try testing.expectEqualSlices(u8, &input, decoded);
+}
+
 test "base64 with ignored chars" {
     const encoded = "dGVzdCBi\r\nYXNlNjQ=\n";
     const expected = "test base64";

package/std/debug/Dwarf.zig

@@ -22,7 +22,9 @@ const cast = std.math.cast;
 const maxInt = std.math.maxInt;
 const ArrayList = std.ArrayList;
 const Endian = std.builtin.Endian;
-const Reader = std.Io.Reader;
+const Io = std.Io;
+const Reader = Io.Reader;
+const Error = std.debug.SelfInfoError;
 
 const Dwarf = @This();
 
@@ -1218,6 +1220,7 @@ pub fn populateSrcLocCache(d: *Dwarf, gpa: Allocator, endian: Endian, cu: *Compi
 pub fn getLineNumberInfo(
     d: *Dwarf,
     gpa: Allocator,
+    text_arena: Allocator,
     endian: Endian,
     compile_unit: *CompileUnit,
     target_address: u64,
@@ -1230,7 +1233,7 @@ pub fn getLineNumberInfo(
     const file_entry = &slc.files[file_index];
     if (file_entry.dir_index >= slc.directories.len) return bad();
     const dir_name = slc.directories[file_entry.dir_index].path;
-    const file_name = try std.fs.path.join(gpa, &.{ dir_name, file_entry.path });
+    const file_name = try std.fs.path.join(text_arena, &.{ dir_name, file_entry.path });
     return .{
         .line = entry.line,
         .column = entry.column,
@@ -1543,21 +1546,38 @@ fn getStringGeneric(opt_str: ?[]const u8, offset: u64) ![:0]const u8 {
     return str[casted_offset..last :0];
 }
 
-pub fn getSymbol(di: *Dwarf, gpa: Allocator, endian: Endian, address: u64) !std.debug.Symbol {
+pub fn getSymbols(
+    di: *Dwarf,
+    symbol_allocator: Allocator,
+    text_arena: Allocator,
+    endian: Endian,
+    address: u64,
+    resolve_inline_callers: bool,
+    symbols: *std.ArrayList(std.debug.Symbol),
+) std.debug.SelfInfoError!void {
+    _ = resolve_inline_callers;
+    const gpa = std.debug.getDebugInfoAllocator();
+
     const compile_unit = di.findCompileUnit(endian, address) catch |err| switch (err) {
-        error.MissingDebugInfo, error.InvalidDebugInfo => return .unknown,
-        else => return err,
+        error.EndOfStream => return error.MissingDebugInfo,
+        error.Overflow => return error.InvalidDebugInfo,
+        error.ReadFailed, error.InvalidDebugInfo, error.MissingDebugInfo => |e| return e,
     };
-    return .{
+    try symbols.append(symbol_allocator, .{
         .name = di.getSymbolName(address),
         .compile_unit_name = compile_unit.die.getAttrString(di, endian, std.dwarf.AT.name, di.section(.debug_str), compile_unit) catch |err| switch (err) {
             error.MissingDebugInfo, error.InvalidDebugInfo => null,
         },
-        .source_location = di.getLineNumberInfo(gpa, endian, compile_unit, address) catch |err| switch (err) {
+        .source_location = di.getLineNumberInfo(gpa, text_arena, endian, compile_unit, address) catch |err| switch (err) {
             error.MissingDebugInfo, error.InvalidDebugInfo => null,
-            else => return err,
+            error.ReadFailed,
+            error.EndOfStream,
+            error.Overflow,
+            error.StreamTooLong,
+            => return error.InvalidDebugInfo,
+            else => |e| return e,
         },
-    };
+    });
 }
 
 /// DWARF5 7.4: "In the 32-bit DWARF format, all values that represent lengths of DWARF sections and

package/std/debug/Info.zig

@@ -99,6 +99,10 @@ pub fn resolveAddresses(
             // due to split debug information. For now, we'll just resolve the addreses one by one.
             for (sorted_pc_addrs, output) |pc_addr, *src_loc| {
                 const dwarf, const dwarf_pc_addr = mf.getDwarfForAddress(gpa, io, pc_addr) catch |err| switch (err) {
+                    error.MissingDebugInfo => {
+                        src_loc.* = .invalid;
+                        continue;
+                    },
                     error.InvalidMachO, error.InvalidDwarf => return error.InvalidDebugInfo,
                     else => |e| return e,
                 };