@zigc/lib 0.17.0-dev.607 → 0.17.0-dev.633

package/libc/include/x86_64-netbsd-none/machine/types.h

@@ -1,4 +1,4 @@
-/*	$NetBSD: types.h,v 1.71 2021/04/01 04:35:45 simonb Exp $	*/
+/*	$NetBSD: types.h,v 1.73 2025/05/08 05:31:16 imil Exp $	*/
 
 /*-
  * Copyright (c) 1990 The Regents of the University of California.
@@ -101,6 +101,7 @@ typedef	unsigned char		__cpu_simple_lock_nv_t;
 #define	__HAVE_MM_MD_DIRECT_MAPPED_PHYS
 #define	__HAVE_UCAS_FULL
 #define	__HAVE_BUS_SPACE_8
+#define	__HAVE_BOOT_DURATION
 
 #ifdef _KERNEL_OPT
 #define	__HAVE_RAS

package/libc/netbsd/lib/csu/arch/riscv/crt0.S

@@ -0,0 +1,62 @@
+/*	$NetBSD: crt0.S,v 1.3.4.1 2026/03/04 19:27:22 martin Exp $	*/
+
+/*-
+ * Copyright (c) 2014 The NetBSD Foundation, Inc.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to The NetBSD Foundation
+ * by Matt Thomas of 3am Software Foundry.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <machine/asm.h>
+
+RCSID("$NetBSD: crt0.S,v 1.3.4.1 2026/03/04 19:27:22 martin Exp $")
+
+STRONG_ALIAS(_start,__start)
+
+_ENTRY(__start)
+	/*
+	 * void ___start(void (*cleanup)(void), struct ps_strings *ps_strings);
+	 */
+	.option push
+	.option norelax
+	lla	gp, __global_pointer$
+	.option pop
+
+	j	___start
+END(__start)
+
+	.option push
+	.option norelax
+
+_ENTRY(_start_setgp)
+	lla	gp, __global_pointer$
+	.option pop
+	ret
+END(_start_setgp)
+
+	.section	.preinit_array, "aw"
+	.p2align	PTR_SCALESHIFT
+	PTR_WORD	_start_setgp
+

package/libc/netbsd/lib/csu/common/crt0-common.c

@@ -1,4 +1,4 @@
-/* $NetBSD: crt0-common.c,v 1.27 2022/06/21 06:52:17 skrll Exp $ */
+/* $NetBSD: crt0-common.c,v 1.30 2025/05/02 23:04:06 riastradh Exp $ */
 
 /*
  * Copyright (c) 1998 Christos Zoulas
@@ -36,13 +36,16 @@
  */
 
 #include <sys/cdefs.h>
-__RCSID("$NetBSD: crt0-common.c,v 1.27 2022/06/21 06:52:17 skrll Exp $");
+__RCSID("$NetBSD: crt0-common.c,v 1.30 2025/05/02 23:04:06 riastradh Exp $");
 
 #include <sys/types.h>
 #include <sys/exec.h>
 #include <sys/exec_elf.h>
 #include <sys/syscall.h>
+
 #include <machine/profile.h>
+
+#include <limits.h>
 #include <stdlib.h>
 #include <unistd.h>
 
@@ -55,7 +58,6 @@ typedef void (*fptr_t)(void);
 extern void	_init(void);
 extern void	_fini(void);
 #endif
-extern void	_libc_init(void);
 
 /*
  * Arrange for _DYNAMIC to be weak and undefined (and therefore to show up
@@ -254,11 +256,19 @@ relocate_self(struct ps_strings *ps_strings)
 
 	Elf_Dyn *dynp = (Elf_Dyn *)((uint8_t *)dynphdr->p_vaddr + relocbase);
 
+	const Elf_Relr *relr = 0, *relrlim;
 	const REL_TYPE *relocs = 0, *relocslim;
-	Elf_Addr relocssz = 0;
+	Elf_Addr relrsz = 0, relocssz = 0;
 
 	for (; dynp->d_tag != DT_NULL; dynp++) {
 		switch (dynp->d_tag) {
+		case DT_RELR:
+			relr =
+			    (const Elf_Relr *)(relocbase + dynp->d_un.d_ptr);
+			break;
+		case DT_RELRSZ:
+			relrsz = dynp->d_un.d_val;
+			break;
 		case REL_TAG:
 			relocs =
 			    (const REL_TYPE *)(relocbase + dynp->d_un.d_ptr);
@@ -268,7 +278,22 @@ relocate_self(struct ps_strings *ps_strings)
 			break;
 		}
 	}
+	relrlim = (const Elf_Relr *)((const uint8_t *)relr + relrsz);
 	relocslim = (const REL_TYPE *)((const uint8_t *)relocs + relocssz);
+	while (relr < relrlim) {
+		Elf_Addr *where;
+
+		where = (Elf_Addr *)(relocbase + *relr);
+		*where++ += relocbase;
+		while (++relr < relrlim && *relr & 1) {
+			unsigned i;
+
+			for (i = 1; i < CHAR_BIT*sizeof(*relr); i++, where++) {
+				if (*relr & ((Elf_Relr)1 << i))
+					*where += relocbase;
+			}
+		}
+	}
 	for (; relocs < relocslim; ++relocs) {
 		Elf_Addr *where;
 
@@ -318,9 +343,6 @@ ___start(void (*cleanup)(void),			/* from shared loader */
 		__progname = empty_string;
 	}
 
-	if (cleanup != NULL)
-		atexit(cleanup);
-
 	_libc_init();
 
 	if (&rtld_DYNAMIC == NULL) {
@@ -334,6 +356,9 @@ ___start(void (*cleanup)(void),			/* from shared loader */
 
 	_preinit();
 
+	if (cleanup != NULL)
+		atexit(cleanup);
+
 #ifdef MCRT0
 	atexit(_mcleanup);
 	monstartup((u_long)&__eprol, (u_long)&__etext);

package/libc/netbsd/lib/csu/common/csu-common.h

@@ -36,3 +36,5 @@
 extern char *__progname __common;
 extern char **environ __common;
 extern struct ps_strings *__ps_strings __common;
+
+void    _libc_init(void) __attribute__((__constructor__, __used__));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zigc/lib",
-  "version": "0.17.0-dev.607",
+  "version": "0.17.0-dev.633",
   "description": "Zig standard library and libc headers (shared across all platforms)",
   "repository": {
     "type": "git",

package/std/Build/Cache/Path.zig

@@ -2,7 +2,6 @@ const Path = @This();
 
 const std = @import("../../std.zig");
 const Io = std.Io;
-const fs = std.fs;
 const assert = std.debug.assert;
 const Allocator = std.mem.Allocator;
 const Cache = std.Build.Cache;
@@ -33,13 +32,13 @@ pub fn join(p: Path, arena: Allocator, sub_path: []const u8) Allocator.Error!Pat
         if (p.sub_path.len == 0) &.{sub_path} else &.{ p.sub_path, sub_path };
     return .{
         .root_dir = p.root_dir,
-        .sub_path = try fs.path.join(arena, parts),
+        .sub_path = try Io.Dir.path.join(arena, parts),
     };
 }
 
 pub fn resolvePosix(p: Path, arena: Allocator, sub_path: []const u8) Allocator.Error!Path {
     if (sub_path.len == 0) return p;
-    const new_sub_path = try fs.path.resolvePosix(arena, &.{ p.sub_path, sub_path });
+    const new_sub_path = try Io.Dir.path.resolvePosix(arena, &.{ p.sub_path, sub_path });
     return .{
         .root_dir = p.root_dir,
         // Use "" instead of "." to represent `root_dir` itself.
@@ -60,9 +59,9 @@ pub fn joinStringZ(p: Path, gpa: Allocator, sub_path: []const u8) Allocator.Erro
 }
 
 pub fn openFile(p: Path, io: Io, sub_path: []const u8, flags: Io.Dir.OpenFileOptions) !Io.File {
-    var buf: [fs.max_path_bytes]u8 = undefined;
+    var buf: [Io.Dir.max_path_bytes]u8 = undefined;
     const joined_path = if (p.sub_path.len == 0) sub_path else p: {
-        break :p std.fmt.bufPrint(&buf, "{s}" ++ fs.path.sep_str ++ "{s}", .{
+        break :p std.fmt.bufPrint(&buf, "{s}" ++ Io.Dir.path.sep_str ++ "{s}", .{
             p.sub_path, sub_path,
         }) catch return error.NameTooLong;
     };
@@ -75,19 +74,19 @@ pub fn openDir(
     sub_path: []const u8,
     args: Io.Dir.OpenOptions,
 ) Io.Dir.OpenError!Io.Dir {
-    var buf: [fs.max_path_bytes]u8 = undefined;
+    var buf: [Io.Dir.max_path_bytes]u8 = undefined;
     const joined_path = if (p.sub_path.len == 0) sub_path else p: {
-        break :p std.fmt.bufPrint(&buf, "{s}" ++ fs.path.sep_str ++ "{s}", .{
+        break :p std.fmt.bufPrint(&buf, "{s}" ++ Io.Dir.path.sep_str ++ "{s}", .{
             p.sub_path, sub_path,
         }) catch return error.NameTooLong;
     };
     return p.root_dir.handle.openDir(io, joined_path, args);
 }
 
-pub fn createDirPathOpen(p: Path, io: Io, sub_path: []const u8, opts: Io.Dir.OpenOptions) !Io.Dir {
-    var buf: [fs.max_path_bytes]u8 = undefined;
+pub fn createDirPathOpen(p: Path, io: Io, sub_path: []const u8, opts: Io.Dir.CreateDirPathOpenOptions) !Io.Dir {
+    var buf: [Io.Dir.max_path_bytes]u8 = undefined;
     const joined_path = if (p.sub_path.len == 0) sub_path else p: {
-        break :p std.fmt.bufPrint(&buf, "{s}" ++ fs.path.sep_str ++ "{s}", .{
+        break :p std.fmt.bufPrint(&buf, "{s}" ++ Io.Dir.path.sep_str ++ "{s}", .{
             p.sub_path, sub_path,
         }) catch return error.NameTooLong;
     };
@@ -95,9 +94,9 @@ pub fn createDirPathOpen(p: Path, io: Io, sub_path: []const u8, opts: Io.Dir.Ope
 }
 
 pub fn statFile(p: Path, io: Io, sub_path: []const u8) !Io.Dir.Stat {
-    var buf: [fs.max_path_bytes]u8 = undefined;
+    var buf: [Io.Dir.max_path_bytes]u8 = undefined;
     const joined_path = if (p.sub_path.len == 0) sub_path else p: {
-        break :p std.fmt.bufPrint(&buf, "{s}" ++ fs.path.sep_str ++ "{s}", .{
+        break :p std.fmt.bufPrint(&buf, "{s}" ++ Io.Dir.path.sep_str ++ "{s}", .{
             p.sub_path, sub_path,
         }) catch return error.NameTooLong;
     };
@@ -108,21 +107,21 @@ pub fn atomicFile(
     p: Path,
     io: Io,
     sub_path: []const u8,
-    options: Io.Dir.AtomicFileOptions,
-    buf: *[fs.max_path_bytes]u8,
-) !fs.AtomicFile {
+    options: Io.Dir.CreateFileAtomicOptions,
+    buf: *[Io.Dir.max_path_bytes]u8,
+) !Io.File.Atomic {
     const joined_path = if (p.sub_path.len == 0) sub_path else p: {
-        break :p std.fmt.bufPrint(buf, "{s}" ++ fs.path.sep_str ++ "{s}", .{
+        break :p std.fmt.bufPrint(buf, "{s}" ++ Io.Dir.path.sep_str ++ "{s}", .{
             p.sub_path, sub_path,
         }) catch return error.NameTooLong;
     };
-    return p.root_dir.handle.atomicFile(io, joined_path, options);
+    return p.root_dir.handle.createFileAtomic(io, joined_path, options);
 }
 
 pub fn access(p: Path, io: Io, sub_path: []const u8, flags: Io.Dir.AccessOptions) !void {
-    var buf: [fs.max_path_bytes]u8 = undefined;
+    var buf: [Io.Dir.max_path_bytes]u8 = undefined;
     const joined_path = if (p.sub_path.len == 0) sub_path else p: {
-        break :p std.fmt.bufPrint(&buf, "{s}" ++ fs.path.sep_str ++ "{s}", .{
+        break :p std.fmt.bufPrint(&buf, "{s}" ++ Io.Dir.path.sep_str ++ "{s}", .{
             p.sub_path, sub_path,
         }) catch return error.NameTooLong;
     };
@@ -130,9 +129,9 @@ pub fn access(p: Path, io: Io, sub_path: []const u8, flags: Io.Dir.AccessOptions
 }
 
 pub fn createDirPath(p: Path, io: Io, sub_path: []const u8) !void {
-    var buf: [fs.max_path_bytes]u8 = undefined;
+    var buf: [Io.Dir.max_path_bytes]u8 = undefined;
     const joined_path = if (p.sub_path.len == 0) sub_path else p: {
-        break :p std.fmt.bufPrint(&buf, "{s}" ++ fs.path.sep_str ++ "{s}", .{
+        break :p std.fmt.bufPrint(&buf, "{s}" ++ Io.Dir.path.sep_str ++ "{s}", .{
             p.sub_path, sub_path,
         }) catch return error.NameTooLong;
     };
@@ -154,7 +153,7 @@ pub fn fmtEscapeString(path: Path) std.fmt.Alt(Path, formatEscapeString) {
 pub fn formatEscapeString(path: Path, writer: *Io.Writer) Io.Writer.Error!void {
     if (path.root_dir.path) |p| {
         try std.zig.stringEscape(p, writer);
-        if (path.sub_path.len > 0) try std.zig.stringEscape(fs.path.sep_str, writer);
+        if (path.sub_path.len > 0) try std.zig.stringEscape(Io.Dir.path.sep_str, writer);
     }
     if (path.sub_path.len > 0) {
         try std.zig.stringEscape(path.sub_path, writer);
@@ -170,7 +169,7 @@ pub fn fmtEscapeChar(path: Path) std.fmt.Alt(Path, formatEscapeChar) {
 pub fn formatEscapeChar(path: Path, writer: *Io.Writer) Io.Writer.Error!void {
     if (path.root_dir.path) |p| {
         for (p) |byte| try std.zig.charEscape(byte, writer);
-        if (path.sub_path.len > 0) try writer.writeByte(fs.path.sep);
+        if (path.sub_path.len > 0) try writer.writeByte(Io.Dir.path.sep);
     }
     if (path.sub_path.len > 0) {
         for (path.sub_path) |byte| try std.zig.charEscape(byte, writer);
@@ -178,14 +177,14 @@ pub fn formatEscapeChar(path: Path, writer: *Io.Writer) Io.Writer.Error!void {
 }
 
 pub fn format(self: Path, writer: *Io.Writer) Io.Writer.Error!void {
-    if (fs.path.isAbsolute(self.sub_path)) {
+    if (Io.Dir.path.isAbsolute(self.sub_path)) {
         try writer.writeAll(self.sub_path);
         return;
     }
     if (self.root_dir.path) |p| {
         try writer.writeAll(p);
         if (self.sub_path.len > 0) {
-            try writer.writeAll(fs.path.sep_str);
+            try writer.writeAll(Io.Dir.path.sep_str);
             try writer.writeAll(self.sub_path);
         }
         return;
@@ -210,18 +209,18 @@ pub fn subPathOrDot(self: Path) []const u8 {
 }
 
 pub fn stem(p: Path) []const u8 {
-    return fs.path.stem(p.sub_path);
+    return Io.Dir.path.stem(p.sub_path);
 }
 
 pub fn dirname(p: Path) ?Path {
     return .{
         .root_dir = p.root_dir,
-        .sub_path = fs.path.dirname(p.subPathOpt() orelse return null) orelse "",
+        .sub_path = Io.Dir.path.dirname(p.subPathOpt() orelse return null) orelse "",
     };
 }
 
 pub fn basename(p: Path) []const u8 {
-    return fs.path.basename(p.sub_path);
+    return Io.Dir.path.basename(p.sub_path);
 }
 
 /// Useful to make `Path` a key in `std.ArrayHashMap`.

package/std/Build/Cache.zig

@@ -982,6 +982,7 @@ pub const Manifest = struct {
             .stat = undefined,
             .bin_digest = undefined,
             .contents = null,
+            .handle = null,
         };
 
         self.files.lockPointers();

package/std/Build/Configuration.zig

@@ -2219,14 +2219,6 @@ pub const TargetQuery = struct {
         windows: std.Target.Os.WindowsVersion,
         default: void,
 
-        pub fn init(x: ?std.Target.Query.OsVersion) @This() {
-            return switch (x orelse return .default) {
-                .none => .none,
-                .semver => .semver,
-                .windows => .windows,
-            };
-        }
-
         pub fn unwrap(this: @This(), c: *const Configuration) ?std.Target.Query.OsVersion {
             return switch (this) {
                 .none => .none,

package/std/Build/Step/Compile.zig

@@ -573,7 +573,7 @@ pub fn setVersionScript(compile: *Compile, source: LazyPath) void {
 
 pub fn forceUndefinedSymbol(compile: *Compile, symbol_name: []const u8) void {
     const graph = compile.step.owner.graph;
-    const arena = graph.allocator;
+    const arena = graph.arena;
     compile.force_undefined_symbols.put(arena, graph.dupeString(symbol_name), {}) catch @panic("OOM");
 }
 
@@ -710,12 +710,6 @@ pub fn getEmittedPdb(compile: *Compile) LazyPath {
     return compile.getEmittedFileGeneric(&compile.generated_pdb);
 }
 
-/// Returns the generated compiler_rt dynamic library.
-/// This is a hack for stage2_x86_64 + coff.
-pub fn getEmittedCompilerRtDynLib(compile: *Compile) ?LazyPath {
-    return compile.getEmittedFileGeneric(&compile.generated_compiler_rt_dyn_lib);
-}
-
 /// Returns the path to the generated documentation directory.
 pub fn getEmittedDocs(compile: *Compile) LazyPath {
     return compile.getEmittedFileGeneric(&compile.generated_docs);
@@ -740,7 +734,7 @@ pub fn setExecCmd(compile: *Compile, args: []const ?[]const u8) void {
     const graph = compile.step.owner.graph;
     const arena = graph.arena;
     assert(compile.kind == .@"test");
-    const duped_args = arena.alloc(?[]u8, args.len) catch @panic("OOM");
+    const duped_args = arena.alloc(?[]const u8, args.len) catch @panic("OOM");
     for (args, 0..) |arg, i| {
         duped_args[i] = if (arg) |a| graph.dupeString(a) else null;
     }

package/std/Build/Step/ObjCopy.zig

@@ -89,7 +89,7 @@ pub const UpdateSectionOptions = struct {
 };
 
 pub fn updateSection(oc: *ObjCopy, section_name: []const u8, options: UpdateSectionOptions) void {
-    const graph = oc.owner.graph;
+    const graph = oc.step.owner.graph;
     const arena = graph.arena;
     const wc = &graph.wip_configuration;
     oc.update_sections.append(arena, .{
@@ -106,7 +106,7 @@ pub const AddSectionOptions = struct {
 };
 
 pub fn addSection(oc: *ObjCopy, section_name: []const u8, options: AddSectionOptions) void {
-    const graph = oc.owner.graph;
+    const graph = oc.step.owner.graph;
     const arena = graph.arena;
     const wc = &graph.wip_configuration;
     oc.add_sections.append(arena, .{

package/std/Build/Step/Options.zig

@@ -421,8 +421,8 @@ pub fn addOptionPath(options: *Options, name: []const u8, path: LazyPath) void {
     const wc = &graph.wip_configuration;
 
     options.args.append(arena, .{
-        .name = try wc.addString(name),
-        .path = path.dupe(options.step.owner),
+        .name = wc.addString(name) catch @panic("OOM"),
+        .path = path.dupe(options.step.owner.graph),
     }) catch @panic("OOM");
     path.addStepDependencies(&options.step);
 }

package/std/Build/Step/Run.zig

@@ -556,39 +556,6 @@ pub fn clearEnvironment(run: *Run) void {
     run.environ_map = new_env_map;
 }
 
-pub fn addPathDir(run: *Run, search_path: []const u8) void {
-    const b = run.step.owner;
-    const environ_map = getEnvMapInternal(run);
-
-    const use_wine = b.enable_wine and b.graph.host.result.os.tag != .windows and use_wine: switch (run.argv.items[0]) {
-        .artifact => |p| p.artifact.rootModuleTarget().os.tag == .windows,
-        .lazy_path => |p| {
-            switch (p.lazy_path) {
-                .generated => |g| if (g.file.step.cast(Step.Compile)) |cs| break :use_wine cs.rootModuleTarget().os.tag == .windows,
-                else => {},
-            }
-            break :use_wine std.mem.endsWith(u8, p.lazy_path.basename(b, &run.step), ".exe");
-        },
-        .decorated_directory => false,
-        .file_content => unreachable, // not allowed as first arg
-        .bytes => |bytes| std.mem.endsWith(u8, bytes, ".exe"),
-        .output_file, .output_file_dep, .output_directory => false,
-    };
-    const key = if (use_wine) "WINEPATH" else "PATH";
-    const prev_path = environ_map.get(key);
-
-    if (prev_path) |pp| {
-        const new_path = b.fmt("{s}{c}{s}", .{
-            pp,
-            if (use_wine) Dir.path.delimiter_windows else Dir.path.delimiter,
-            search_path,
-        });
-        environ_map.put(key, new_path) catch @panic("OOM");
-    } else {
-        environ_map.put(key, b.dupePath(search_path)) catch @panic("OOM");
-    }
-}
-
 pub fn getEnvMap(run: *Run) *EnvMap {
     return getEnvMapInternal(run);
 }

package/std/Build.zig

@@ -945,7 +945,7 @@ pub fn addRunArtifact(b: *Build, exe: *Step.Compile) *Step.Run {
 /// * `addSystemCommand`
 /// * `addRunArtifact`
 pub fn addRunFile(b: *Build, executable: LazyPath) *Step.Run {
-    const run_step = Step.Run.create(b, b.fmt("run {f}", .{executable.fmt(b.graph)}));
+    const run_step = Step.Run.create(b, b.fmt("run {f}", .{executable}));
     run_step.addFileArg(executable);
     return run_step;
 }

package/std/Target.zig

@@ -538,7 +538,7 @@ pub const Os = struct {
 
                             break :blk default_min;
                         },
-                        .max = .{ .major = 10, .minor = 1, .patch = 0 },
+                        .max = .{ .major = 11, .minor = 0, .patch = 0 },
                     },
                 },
                 .openbsd => .{
@@ -2802,6 +2802,8 @@ pub const DynamicLinker = struct {
                 .mips64,
                 .mips64el,
                 .powerpc,
+                .riscv32,
+                .riscv64,
                 .sh,
                 .sheb,
                 .sparc,

package/std/debug/Pdb.zig

@@ -26,10 +26,11 @@ pub const Module = struct {
     symbols: []u8,
     subsect_info: []u8,
     checksum_offset: ?usize,
-    /// The inlinee source lines, sorted by inlinee. This saves us from repeatedly doing linear
-    /// searches over all inlinees. We prefer binary search over a hashmap as LLVM somtimes outputs
-    /// multiple entries for a single inlinee ID, see `getInlineeSourceLines` for more info.
-    inlinee_source_lines: []InlineeSourceLine,
+    /// The inlinee source lines, sorted by inlinee, then file, then line number.
+    /// This saves us from repeatedly doing linear searches over all inlinees.
+    /// We prefer binary search over a hashmap as LLVM somtimes outputs multiple entries
+    /// for a single inlinee ID, see `getInlineeSourceLines` for more info.
+    inlinee_source_lines: []*align(1) const pdb.InlineeSourceLine,
 
     pub fn deinit(self: *Module, allocator: Allocator) void {
         allocator.free(self.module_name);
@@ -669,44 +670,68 @@ pub fn getSymbolName(self: *Pdb, proc_sym: *align(1) const pdb.ProcSym) []const
     return std.mem.sliceTo(@as([*:0]const u8, @ptrCast(&proc_sym.name[0])), 0);
 }
 
-pub const InlineeSourceLine = struct {
-    signature: pdb.InlineeSourceLineSignature,
-    info: *align(1) const pdb.InlineeSourceLine,
+fn inlineeSourceLineLessThan(
+    _: void,
+    lhs: *align(1) const pdb.InlineeSourceLine,
+    rhs: *align(1) const pdb.InlineeSourceLine,
+) bool {
+    if (lhs.inlinee < rhs.inlinee) return true;
+    if (lhs.inlinee > rhs.inlinee) return false;
+    if (lhs.file_id < rhs.file_id) return true;
+    if (lhs.file_id > rhs.file_id) return false;
+    return lhs.source_line_num < rhs.source_line_num;
+}
 
-    fn lessThan(_: void, lhs: InlineeSourceLine, rhs: InlineeSourceLine) bool {
-        return lhs.info.inlinee < rhs.info.inlinee;
-    }
+fn compareInlineeSourceLineInlinee(
+    inlinee: u32,
+    inlinee_src_line: *align(1) const pdb.InlineeSourceLine,
+) std.math.Order {
+    return std.math.order(inlinee, inlinee_src_line.inlinee);
+}
 
-    fn compare(inlinee: u32, self: InlineeSourceLine) std.math.Order {
-        return std.math.order(inlinee, self.info.inlinee);
+pub const InlineeSourceLocationIterator = struct {
+    /// The iterator assumes that all source lines in the slice are associated
+    /// with the same inlinee, and that it is sorted by file, then line number.
+    lines: []*align(1) const pdb.InlineeSourceLine,
+
+    pub const empty: InlineeSourceLocationIterator = .{ .lines = &.{} };
+
+    pub fn next(iter: *InlineeSourceLocationIterator) ?*align(1) const pdb.InlineeSourceLine {
+        if (iter.lines.len == 0) return null;
+        const line = iter.lines[0];
+        iter.lines = iter.lines[1..];
+        // Filter out duplicate entries
+        while (iter.lines.len != 0 and
+            iter.lines[0].file_id == line.file_id and
+            iter.lines[0].source_line_num == line.source_line_num)
+        {
+            iter.lines = iter.lines[1..];
+        }
+        return line;
     }
 };
 
-/// Returns all `InlineeSourceLine`s for a given module with the given inlinee. Ideally there would
-/// only be one entry per inlinee, but LLVM appears to assign all functions that share a name the
-/// same inlinee ID. This appears to be a bug, so the best the caller can do right now is print all
-/// the results.
-pub fn getInlineeSourceLines(
-    self: *Pdb,
-    mod: *Module,
-    inlinee: u32,
-) []const InlineeSourceLine {
+/// Returns all `pdb.InlineeSourceLine`s for a given module with the given inlinee. Ideally
+/// there would only be one entry per inlinee, but LLVM appears to assign all functions that share
+/// a name the same inlinee ID. This is a bug: https://github.com/llvm/llvm-project/issues/191787
+/// The best the caller can do right now is print all the results.
+pub fn getInlineeSourceLines(self: *Pdb, mod: *Module, inlinee: u32) InlineeSourceLocationIterator {
     _ = self;
 
     // Binary search to an arbitrary match, if there are other matches they will be adjacent
     const any = std.sort.binarySearch(
-        InlineeSourceLine,
+        *align(1) const pdb.InlineeSourceLine,
         mod.inlinee_source_lines,
         inlinee,
-        InlineeSourceLine.compare,
-    ) orelse return &.{};
+        compareInlineeSourceLineInlinee,
+    ) orelse return .empty;
 
     // Linearly scan to the first match
     const begin = b: {
         var begin = any;
         while (begin > 0) {
             const prev = begin - 1;
-            if (mod.inlinee_source_lines[prev].info.inlinee != inlinee) break;
+            if (mod.inlinee_source_lines[prev].inlinee != inlinee) break;
             begin = prev;
         }
         break :b begin;
@@ -716,13 +741,13 @@ pub fn getInlineeSourceLines(
     const end = b: {
         var end = any + 1;
         while (end < mod.inlinee_source_lines.len and
-            mod.inlinee_source_lines[end].info.inlinee == inlinee) : (end += 1)
+            mod.inlinee_source_lines[end].inlinee == inlinee) : (end += 1)
         {}
         break :b end;
     };
 
-    // Return a slice of all the matches
-    return mod.inlinee_source_lines[begin..end];
+    // Return an iterator over all matches (the iterator filters out duplicate entries)
+    return .{ .lines = mod.inlinee_source_lines[begin..end] };
 }
 
 pub fn getLineNumberInfo(self: *Pdb, gpa: Allocator, module: *Module, address: u64) !std.debug.SourceLocation {
@@ -845,7 +870,7 @@ pub fn getModule(self: *Pdb, index: usize) !?*Module {
     mod.subsect_info = try reader.readAlloc(gpa, mod.mod_info.c13_byte_size);
     errdefer gpa.free(mod.subsect_info);
     mod.inlinee_source_lines = b: {
-        var inlinee_source_lines: std.ArrayList(InlineeSourceLine) = .empty;
+        var inlinee_source_lines: std.ArrayList(*align(1) const pdb.InlineeSourceLine) = .empty;
         defer inlinee_source_lines.deinit(gpa);
         var subsects: Io.Reader = .fixed(mod.subsect_info);
         while (subsects.takeStructPointer(pdb.DebugSubsectionHeader) catch null) |subsect_hdr| {
@@ -866,15 +891,17 @@ pub fn getModule(self: *Pdb, index: usize) !?*Module {
                             return error.InvalidDebugInfo;
                     }
 
-                    try inlinee_source_lines.append(gpa, .{
-                        .signature = inlinee_source_line_signature,
-                        .info = info,
-                    });
+                    try inlinee_source_lines.append(gpa, info);
                 }
             }
         }
 
-        std.mem.sortUnstable(InlineeSourceLine, inlinee_source_lines.items, {}, InlineeSourceLine.lessThan);
+        std.mem.sortUnstable(
+            *align(1) const pdb.InlineeSourceLine,
+            inlinee_source_lines.items,
+            {},
+            inlineeSourceLineLessThan,
+        );
         break :b try inlinee_source_lines.toOwnedSlice(gpa);
     };
     errdefer gpa.free(mod.inlinee_source_lines);