@zigc/lib 0.16.0-test.1 → 0.17.0-dev.131

package/std/crypto/ascon.zig

@@ -681,6 +681,8 @@ pub const AsconXof128 = struct {
 
     st: AsconState,
     squeezed: bool,
+    buf: [block_length]u8,
+    buf_len: usize,
 
     pub const Options = struct {};
 
@@ -698,7 +700,7 @@ pub const AsconXof128 = struct {
         const words: [5]u64 = .{ iv, 0, 0, 0, 0 };
         var st = AsconState.initFromWords(words);
         st.permuteR(12);
-        return AsconXof128{ .st = st, .squeezed = false };
+        return AsconXof128{ .st = st, .squeezed = false, .buf = @splat(0), .buf_len = 0 };
     }
 
     /// Hash a slice of bytes with variable-length output.
@@ -726,24 +728,26 @@ pub const AsconXof128 = struct {
 
         var i: usize = 0;
 
-        // Process full 64-bit blocks
-        while (i + 8 <= b.len) : (i += 8) {
-            self.st.addBytes(b[i..][0..8]);
+        if (self.buf_len > 0) {
+            const to_fill = @min(block_length - self.buf_len, b.len);
+            @memcpy(self.buf[self.buf_len..][0..to_fill], b[0..to_fill]);
+            self.buf_len += to_fill;
+            i += to_fill;
+            if (self.buf_len == block_length) {
+                self.st.addBytes(&self.buf);
+                self.st.permuteR(12);
+                self.buf_len = 0;
+            }
+        }
+
+        while (i + block_length <= b.len) : (i += block_length) {
+            self.st.addBytes(b[i..][0..block_length]);
             self.st.permuteR(12);
         }
 
-        // Store partial block for finalization
         if (i < b.len) {
-            var padded: [8]u8 = @splat(0);
-            const remaining = b.len - i;
-            @memcpy(padded[0..remaining], b[i..]);
-            padded[remaining] = 0x01;
-            self.st.addBytes(&padded);
-        } else {
-            // Add padding block
-            var padded: [8]u8 = @splat(0);
-            padded[0] = 0x01;
-            self.st.addBytes(&padded);
+            self.buf_len = b.len - i;
+            @memcpy(self.buf[0..self.buf_len], b[i..]);
         }
     }
 
@@ -756,7 +760,10 @@ pub const AsconXof128 = struct {
     /// After first call, no more data can be absorbed with update().
     pub fn squeeze(self: *AsconXof128, out: []u8) void {
         if (!self.squeezed) {
-            // First squeeze - apply final permutation
+            var padded: [block_length]u8 = @splat(0);
+            @memcpy(padded[0..self.buf_len], self.buf[0..self.buf_len]);
+            padded[self.buf_len] = 0x01;
+            self.st.addBytes(&padded);
             self.st.permuteR(12);
             self.squeezed = true;
         }
@@ -783,6 +790,8 @@ pub const AsconCxof128 = struct {
 
     st: AsconState,
     squeezed: bool,
+    buf: [block_length]u8,
+    buf_len: usize,
 
     pub const Options = struct { custom: []const u8 = "" };
 
@@ -804,7 +813,7 @@ pub const AsconCxof128 = struct {
         var st = AsconState.initFromWords(words);
         st.permuteR(12);
 
-        var self = AsconCxof128{ .st = st, .squeezed = false };
+        var self = AsconCxof128{ .st = st, .squeezed = false, .buf = @splat(0), .buf_len = 0 };
 
         // Process customization string - always process length and padding
         // First block: length of customization string
@@ -867,28 +876,30 @@ pub const AsconCxof128 = struct {
     ///
     /// Note: Cannot be called after squeeze() has been called
     pub fn update(self: *AsconCxof128, b: []const u8) void {
-        debug.assert(!self.squeezed);
+        debug.assert(!self.squeezed); // Cannot update after squeezing
 
         var i: usize = 0;
 
-        // Process full 64-bit blocks
-        while (i + 8 <= b.len) : (i += 8) {
-            self.st.addBytes(b[i..][0..8]);
+        if (self.buf_len > 0) {
+            const to_fill = @min(block_length - self.buf_len, b.len);
+            @memcpy(self.buf[self.buf_len..][0..to_fill], b[0..to_fill]);
+            self.buf_len += to_fill;
+            i += to_fill;
+            if (self.buf_len == block_length) {
+                self.st.addBytes(&self.buf);
+                self.st.permuteR(12);
+                self.buf_len = 0;
+            }
+        }
+
+        while (i + block_length <= b.len) : (i += block_length) {
+            self.st.addBytes(b[i..][0..block_length]);
             self.st.permuteR(12);
         }
 
-        // Store partial block for finalization
         if (i < b.len) {
-            var padded: [8]u8 = @splat(0);
-            const remaining = b.len - i;
-            @memcpy(padded[0..remaining], b[i..]);
-            padded[remaining] = 0x01;
-            self.st.addBytes(&padded);
-        } else {
-            // Add padding block
-            var padded: [8]u8 = @splat(0);
-            padded[0] = 0x01;
-            self.st.addBytes(&padded);
+            self.buf_len = b.len - i;
+            @memcpy(self.buf[0..self.buf_len], b[i..]);
         }
     }
 
@@ -901,7 +912,10 @@ pub const AsconCxof128 = struct {
     /// After first call, no more data can be absorbed with update().
     pub fn squeeze(self: *AsconCxof128, out: []u8) void {
         if (!self.squeezed) {
-            // First squeeze - apply final permutation
+            var padded: [block_length]u8 = @splat(0);
+            @memcpy(padded[0..self.buf_len], self.buf[0..self.buf_len]);
+            padded[self.buf_len] = 0x01;
+            self.st.addBytes(&padded);
             self.st.permuteR(12);
             self.squeezed = true;
         }
@@ -1267,6 +1281,34 @@ test "Ascon-XOF128 official test vectors" {
     }
 }
 
+test "Ascon-XOF128/CXOF128 streaming chunking invariance" {
+    const msg = "Hello, World!";
+
+    // XOF128: one-shot vs split must match
+    var out1: [32]u8 = undefined;
+    var out2: [32]u8 = undefined;
+    var xof1 = AsconXof128.init(.{});
+    xof1.update(msg);
+    xof1.squeeze(&out1);
+    var xof2 = AsconXof128.init(.{});
+    xof2.update("Hello, ");
+    xof2.update("World!");
+    xof2.squeeze(&out2);
+    try testing.expectEqualSlices(u8, &out1, &out2);
+
+    // CXOF128: one-shot vs split must match
+    var cout1: [32]u8 = undefined;
+    var cout2: [32]u8 = undefined;
+    var cxof1 = AsconCxof128.init(.{ .custom = "cust" });
+    cxof1.update(msg);
+    cxof1.squeeze(&cout1);
+    var cxof2 = AsconCxof128.init(.{ .custom = "cust" });
+    cxof2.update("Hello, ");
+    cxof2.update("World!");
+    cxof2.squeeze(&cout2);
+    try testing.expectEqualSlices(u8, &cout1, &cout2);
+}
+
 test "Ascon-CXOF128 official test vectors" {
 
     // Test vector 1: Empty message, empty customization, 64-byte output

package/std/crypto/codecs/asn1/Oid.zig

@@ -85,6 +85,14 @@ test toDot {
     }
 }
 
+test "malformed OID" {
+    var empty: der.Decoder = .{ .bytes = &.{ 0x06, 0x00 } };
+    try std.testing.expectError(error.EndOfStream, decodeDer(&empty));
+
+    var truncated: der.Decoder = .{ .bytes = &.{ 0x06, 0x02, 0x2a, 0x80 } };
+    try std.testing.expectError(error.InvalidEncoding, decodeDer(&truncated));
+}
+
 const TestCase = struct {
     encoded: []const u8,
     dot_notation: []const u8,
@@ -109,7 +117,10 @@ pub const asn1_tag = asn1.Tag.init(.oid, false, .universal);
 
 pub fn decodeDer(decoder: *der.Decoder) !Oid {
     const ele = try decoder.element(asn1_tag.toExpected());
-    return Oid{ .encoded = decoder.view(ele) };
+    const encoded = decoder.view(ele);
+    if (encoded.len == 0) return error.EndOfStream;
+    if (encoded[encoded.len - 1] & 0x80 != 0) return error.InvalidEncoding;
+    return Oid{ .encoded = encoded };
 }
 
 pub fn encodeDer(self: Oid, encoder: *der.Encoder) !void {

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

@@ -47,8 +47,7 @@ pub const hex = struct {
         }
         _ = decodeAny(bin, encoded, null) catch |err| {
             switch (err) {
-                error.InvalidCharacter => return error.InvalidCharacter,
-                error.InvalidPadding => return error.InvalidPadding,
+                error.InvalidCharacter, error.InvalidPadding => |e| return e,
                 else => unreachable,
             }
         };
@@ -93,7 +92,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,
@@ -228,8 +227,7 @@ pub const base64 = struct {
     pub fn decode(bin: []u8, encoded: []const u8, comptime variant: Variant) error{ InvalidCharacter, InvalidPadding }![]const u8 {
         return decodeAny(bin, encoded, variant, null) catch |err| {
             switch (err) {
-                error.InvalidCharacter => return error.InvalidCharacter,
-                error.InvalidPadding => return error.InvalidPadding,
+                error.InvalidCharacter, error.InvalidPadding => |e| return e,
                 else => unreachable,
             }
         };
@@ -269,7 +267,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 +302,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 +310,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 +451,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/crypto/ml_kem.zig

@@ -1725,15 +1725,8 @@ const NistDRBG = struct {
     v: [16]u8,
 
     fn incV(g: *NistDRBG) void {
-        var j: usize = 15;
-        while (j >= 0) : (j -= 1) {
-            if (g.v[j] == 255) {
-                g.v[j] = 0;
-            } else {
-                g.v[j] += 1;
-                break;
-            }
-        }
+        const val = std.mem.readInt(u128, &g.v, .big);
+        std.mem.writeInt(u128, &g.v, val +% 1, .big);
     }
 
     // AES256_CTR_DRBG_Update(pd, &g.key, &g.v).

package/std/crypto/tls/Client.zig

@@ -353,7 +353,7 @@ pub fn init(input: *Reader, output: *Writer, options: Options) InitError!Client
         if (record_len > tls.max_ciphertext_len) return error.TlsRecordOverflow;
         const record_buffer = input.take(record_len) catch |err| switch (err) {
             error.EndOfStream => return error.TlsConnectionTruncated,
-            error.ReadFailed => return error.ReadFailed,
+            error.ReadFailed => |e| return e,
         };
         var record_decoder: tls.Decoder = .fromTheirSlice(record_buffer);
         var ctd, const ct = content: switch (cipher_state) {
@@ -382,7 +382,9 @@ pub fn init(input: *Reader, output: *Writer, options: Options) InitError!Client
                         P.AEAD.decrypt(cleartext, ciphertext, auth_tag, record_header, nonce, pv.server_handshake_key) catch
                             return error.TlsBadRecordMac;
                         // TODO use scalar, non-slice version
-                        cleartext_fragment_end += mem.trimEnd(u8, cleartext, "\x00").len;
+                        const trimmed_len = mem.trimEnd(u8, cleartext, "\x00").len;
+                        if (trimmed_len == 0) return error.TlsDecodeError;
+                        cleartext_fragment_end += trimmed_len;
                     },
                 }
                 read_seq += 1;
@@ -1155,7 +1157,7 @@ fn readIndirect(c: *Client) Reader.Error!usize {
                 return failRead(c, error.TlsConnectionTruncated);
             }
         },
-        error.ReadFailed => return error.ReadFailed,
+        error.ReadFailed => |e| return e,
     };
     const ct: tls.ContentType = @enumFromInt(record_header[0]);
     const legacy_version = mem.readInt(u16, record_header[1..][0..2], .big);
@@ -1166,7 +1168,7 @@ fn readIndirect(c: *Client) Reader.Error!usize {
     if (record_end > input.buffered().len) {
         input.fillMore() catch |err| switch (err) {
             error.EndOfStream => return failRead(c, error.TlsConnectionTruncated),
-            error.ReadFailed => return error.ReadFailed,
+            error.ReadFailed => |e| return e,
         };
         if (record_end > input.buffered().len) return 0;
     }
@@ -1176,6 +1178,7 @@ fn readIndirect(c: *Client) Reader.Error!usize {
             .tls_1_3 => {
                 const pv = &p.tls_1_3;
                 const P = @TypeOf(p.*);
+                if (record_len < P.AEAD.tag_length) return failRead(c, error.TlsRecordOverflow);
                 const ad = input.take(tls.record_header_len) catch unreachable; // already peeked
                 const ciphertext_len = record_len - P.AEAD.tag_length;
                 const ciphertext = input.take(ciphertext_len) catch unreachable; // already peeked
@@ -1192,6 +1195,7 @@ fn readIndirect(c: *Client) Reader.Error!usize {
                     return failRead(c, error.TlsBadRecordMac);
                 // TODO use scalar, non-slice version
                 const msg = mem.trimEnd(u8, cleartext, "\x00");
+                if (msg.len == 0) return failRead(c, error.TlsDecodeError);
                 break :cleartext .{ msg.len - 1, @enumFromInt(msg[msg.len - 1]) };
             },
             .tls_1_2 => {
@@ -1668,3 +1672,74 @@ else
         .AES_256_GCM_SHA384,
         .ECDHE_RSA_WITH_AES_256_GCM_SHA384,
     });
+
+fn testReadError(input_buf: []const u8, cipher: tls.ApplicationCipher) ReadError {
+    var input_reader: Reader = .fixed(input_buf);
+    var read_buf: [tls.max_ciphertext_record_len]u8 = undefined;
+    var c: Client = .{
+        .input = &input_reader,
+        .reader = .{
+            .buffer = &read_buf,
+            .vtable = &.{ .stream = stream, .readVec = readVec },
+            .seek = 0,
+            .end = 0,
+        },
+        .output = undefined,
+        .writer = undefined,
+        .tls_version = .tls_1_3,
+        .read_seq = 0,
+        .write_seq = 0,
+        .received_close_notify = false,
+        .allow_truncation_attacks = false,
+        .application_cipher = cipher,
+        .ssl_key_log = null,
+    };
+    var w: Writer = .failing;
+    std.testing.expectError(error.ReadFailed, c.reader.stream(&w, .unlimited)) catch
+        @panic("expected ReadFailed");
+    return c.read_err.?;
+}
+
+test "empty inner plaintext" {
+    const AEAD = crypto.aead.chacha_poly.ChaCha20Poly1305;
+    const key: [AEAD.key_length]u8 = @splat(0);
+    const iv: [AEAD.nonce_length]u8 = @splat(0);
+
+    const plaintext = [1]u8{0x00};
+    var ciphertext: [plaintext.len]u8 = undefined;
+    var tag: [AEAD.tag_length]u8 = undefined;
+    const content_len: u16 = plaintext.len + AEAD.tag_length;
+    const record_header = [_]u8{ 0x17, 0x03, 0x03 } ++ mem.toBytes(big(content_len));
+    AEAD.encrypt(&ciphertext, &tag, &plaintext, &record_header, iv, key);
+
+    try std.testing.expectEqual(error.TlsDecodeError, testReadError(
+        &record_header ++ ciphertext ++ tag,
+        .{ .CHACHA20_POLY1305_SHA256 = .{ .tls_1_3 = .{
+            .server_key = key,
+            .server_iv = iv,
+            .client_secret = undefined,
+            .server_secret = undefined,
+            .client_key = undefined,
+            .client_iv = undefined,
+        } } },
+    ));
+}
+
+test "record shorter than tag" {
+    const AEAD = crypto.aead.chacha_poly.ChaCha20Poly1305;
+    const record_len: u16 = AEAD.tag_length - 1;
+    const header = [_]u8{ 0x17, 0x03, 0x03 } ++ mem.toBytes(big(record_len));
+    const wire = header ++ @as([record_len]u8, @splat(0));
+
+    try std.testing.expectEqual(error.TlsRecordOverflow, testReadError(
+        &wire,
+        .{ .CHACHA20_POLY1305_SHA256 = .{ .tls_1_3 = .{
+            .server_key = undefined,
+            .server_iv = undefined,
+            .client_secret = undefined,
+            .server_secret = undefined,
+            .client_key = undefined,
+            .client_iv = undefined,
+        } } },
+    ));
+}

package/std/crypto/tls.zig

@@ -666,7 +666,7 @@ pub const Decoder = struct {
         if (request_amt > dest.len) return error.TlsRecordOverflow;
         stream.readSlice(dest[0..request_amt]) catch |err| switch (err) {
             error.EndOfStream => return error.TlsConnectionTruncated,
-            error.ReadFailed => return error.ReadFailed,
+            error.ReadFailed => |e| return e,
         };
         d.cap += request_amt;
     }

package/std/crypto.zig

@@ -367,6 +367,7 @@ test {
     _ = ff;
     _ = errors;
     _ = tls;
+    _ = tls.Client;
     _ = Certificate;
     _ = codecs;
 }

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,
                 };