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

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.644",
   "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

@@ -2144,6 +2144,33 @@ pub const ResolvedTarget = struct {
             return (unwrap(this) orelse return null).get(c);
         }
     };
+
+    pub fn unwrapQuery(rt: *const ResolvedTarget, c: *const Configuration) ?std.Target.Query {
+        const tq = rt.query.get(c) orelse return null;
+        const cpu_arch = tq.flags.cpu_arch.unwrap() orelse rt.result.get(c).flags.cpu_arch.unwrap().?;
+        return .{
+            .cpu_arch = cpu_arch,
+            .cpu_model = switch (tq.flags.cpu_model) {
+                .native => .native,
+                .baseline => .baseline,
+                .determined_by_arch_os => .determined_by_arch_os,
+                .explicit => .{ .explicit = cpu_arch.parseCpuModel(tq.cpu_name.value.?.slice(c)).? },
+            },
+            .cpu_features_add = tq.cpu_features_add.value orelse .empty,
+            .cpu_features_sub = tq.cpu_features_sub.value orelse .empty,
+            .os_tag = tq.flags.os_tag.unwrap(),
+            .os_version_min = tq.os_version_min.u.unwrap(c),
+            .os_version_max = tq.os_version_max.u.unwrap(c),
+            .glibc_version = if (tq.glibc_version.value) |s|
+                std.SemanticVersion.parse(s.slice(c)) catch unreachable
+            else
+                null,
+            .android_api_level = tq.android_api_level.value,
+            .abi = tq.flags.abi.unwrap(),
+            .dynamic_linker = if (tq.dynamic_linker.value) |s| .init(s.slice(c)) else null,
+            .ofmt = tq.flags.object_format.unwrap(),
+        };
+    }
 };
 
 pub const TargetQuery = struct {
@@ -2219,14 +2246,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,
@@ -2739,29 +2758,50 @@ pub const TargetQuery = struct {
         dynamic_linker: bool,
     };
 
-    pub fn unwrap(tq: *const TargetQuery, c: *const Configuration) std.Target.Query {
-        const cpu_arch = tq.flags.cpu_arch.unwrap();
+    pub fn unwrapTarget(tq: *const TargetQuery, c: *const Configuration) std.Target {
+        const cpu_arch = tq.flags.cpu_arch.unwrap().?;
+        const os_tag = tq.flags.os_tag.unwrap().?;
         return .{
-            .cpu_arch = cpu_arch,
-            .cpu_model = switch (tq.flags.cpu_model) {
-                .native => .native,
-                .baseline => .baseline,
-                .determined_by_arch_os => .determined_by_arch_os,
-                .explicit => .{ .explicit = cpu_arch.?.parseCpuModel(tq.cpu_name.value.?.slice(c)).? },
+            .cpu = .{
+                .arch = cpu_arch,
+                .model = cpu_arch.parseCpuModel(tq.cpu_name.value.?.slice(c)).?,
+                .features = tq.cpu_features_add.value.?,
             },
-            .cpu_features_add = tq.cpu_features_add.value orelse .empty,
-            .cpu_features_sub = tq.cpu_features_sub.value orelse .empty,
-            .os_tag = tq.flags.os_tag.unwrap(),
-            .os_version_min = tq.os_version_min.u.unwrap(c),
-            .os_version_max = tq.os_version_max.u.unwrap(c),
-            .glibc_version = if (tq.glibc_version.value) |s|
-                std.SemanticVersion.parse(s.slice(c)) catch unreachable
-            else
-                null,
-            .android_api_level = tq.android_api_level.value,
-            .abi = tq.flags.abi.unwrap(),
-            .dynamic_linker = if (tq.dynamic_linker.value) |s| .init(s.slice(c)) else null,
-            .ofmt = tq.flags.object_format.unwrap(),
+            .os = .{
+                .tag = os_tag,
+                .version_range = switch (os_tag) {
+                    .linux => .{ .linux = .{
+                        .range = .{
+                            .min = tq.os_version_min.u.unwrap(c).?.semver,
+                            .max = tq.os_version_max.u.unwrap(c).?.semver,
+                        },
+                        .glibc = std.SemanticVersion.parse(tq.glibc_version.value.?.slice(c)) catch unreachable,
+                        .android = tq.android_api_level.value.?,
+                    } },
+                    .hurd => .{ .hurd = .{
+                        .range = .{
+                            .min = tq.os_version_min.u.unwrap(c).?.semver,
+                            .max = tq.os_version_max.u.unwrap(c).?.semver,
+                        },
+                        .glibc = std.SemanticVersion.parse(tq.glibc_version.value.?.slice(c)) catch unreachable,
+                    } },
+                    .windows => .{ .windows = .{
+                        .min = tq.os_version_min.u.unwrap(c).?.windows,
+                        .max = tq.os_version_max.u.unwrap(c).?.windows,
+                    } },
+                    else => switch (tq.os_version_min.u.unwrap(c).?) {
+                        .none => .{ .none = {} },
+                        .semver => |min| .{ .semver = .{
+                            .min = min,
+                            .max = tq.os_version_max.u.unwrap(c).?.semver,
+                        } },
+                        .windows => unreachable,
+                    },
+                },
+            },
+            .abi = tq.flags.abi.unwrap().?,
+            .ofmt = tq.flags.object_format.unwrap().?,
+            .dynamic_linker = .init(if (tq.dynamic_linker.value) |s| s.slice(c) else null),
         };
     }
 };

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

@@ -830,7 +830,17 @@ pub fn addModule(b: *Build, name: []const u8, options: Module.CreateOptions) *Mo
     const graph = b.graph;
     const arena = graph.arena;
     const module = Module.create(b, options);
-    b.modules.put(arena, graph.dupeString(name), module) catch @panic("OOM");
+    const gop = b.modules.getOrPutValue(
+        arena,
+        graph.dupeString(name),
+        module,
+    ) catch @panic("OOM");
+    if (gop.found_existing) {
+        panic(
+            "A module with the name '{s}' has already been added to the package. Consider creating a private module with std.Build.createModule",
+            .{name},
+        );
+    }
     return module;
 }
 
@@ -945,7 +955,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;
 }
@@ -992,13 +1002,33 @@ pub fn addWriteFile(b: *Build, file_path: []const u8, data: []const u8) *Step.Wr
 pub fn addNamedWriteFiles(b: *Build, name: []const u8) *Step.WriteFile {
     const graph = b.graph;
     const wf = Step.WriteFile.create(b);
-    b.named_writefiles.put(graph.arena, graph.dupeString(name), wf) catch @panic("OOM");
+    const gop = b.named_writefiles.getOrPutValue(
+        graph.arena,
+        graph.dupeString(name),
+        wf,
+    ) catch @panic("OOM");
+    if (gop.found_existing) {
+        panic(
+            "A WriteFile step with the name '{s}' has already been added to the package. Consider creating a private WriteFile step with std.Build.addWriteFiles",
+            .{name},
+        );
+    }
     return wf;
 }
 
 pub fn addNamedLazyPath(b: *Build, name: []const u8, lp: LazyPath) void {
     const graph = b.graph;
-    b.named_lazy_paths.put(graph.arena, graph.dupeString(name), lp.dupe(graph)) catch @panic("OOM");
+    const gop = b.named_lazy_paths.getOrPutValue(
+        graph.arena,
+        graph.dupeString(name),
+        lp.dupe(graph),
+    ) catch @panic("OOM");
+    if (gop.found_existing) {
+        panic(
+            "A LazyPath with the name '{s}' has already been added to the package.",
+            .{name},
+        );
+    }
 }
 
 /// Creates a step for mutating files inside a temporary directory created lazily

package/std/Io/Kqueue.zig

@@ -1403,7 +1403,7 @@ fn openSocketPosix(
 
     if (options.ip6_only) {
         if (posix.IPV6 == void) return error.OptionUnsupported;
-        try setSocketOption(k, socket_fd, posix.IPPROTO.IPV6, posix.IPV6.V6ONLY, 0);
+        try setSocketOption(k, socket_fd, posix.IPPROTO.IPV6, posix.IPV6.V6ONLY, 1);
     }
 
     return socket_fd;